Merge pull request #11 from simd-lite/rust-1.64-updates

Updates for Rust 1.64.0

Author: Licenser

.github/dependabot.yml

@@ -0,0 +1,7 @@
+version: 2
+updates:
+- package-ecosystem: cargo
+  directory: "/"
+  schedule:
+    interval: daily
+  open-pull-requests-limit: 10

.github/workflows/nightly.yml

@@ -0,0 +1,33 @@
+name: Tests - Nightly
+
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+
+
+jobs:
+  build-nightly:
+    strategy:
+      matrix:
+        rustflags:
+          - '-C target-cpu=native'
+        features:
+          - ''
+          - '--features 128bit'
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v1
+    - uses: actions-rs/toolchain@v1
+      with:
+        toolchain: nightly
+        override: true
+    - name: Build
+      env:
+        RUSTFLAGS: ${{ matrix.rustflags }}
+      run: cargo build ${{ matrix.features }}
+    - name: Run tests
+      env:
+        RUSTFLAGS: ${{ matrix.rustflags }}
+      run: cargo test ${{ matrix.features }}

.github/workflows/quality.yaml

@@ -0,0 +1,63 @@
+name: Quality
+
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+
+
+jobs:
+  clippy_check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v1
+      - uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          profiles: minimal
+          override: true
+          components: rustfmt,clippy
+      - name: Validate cargo format
+        run: cargo fmt -- --check
+      - name: Check workflow permissions
+        id: check_permissions
+        uses: scherermichael-oss/action-has-permission@1.0.6
+        with:
+          required-permission: write
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      - name: Run clippy action to produce annotations
+        uses: actions-rs/clippy-check@v1
+        if: steps.check_permissions.outputs.has-permission
+        env:
+          RUSTFLAGS: "-C target-cpu=native"
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          args: --all
+      - name: Run clippy manually without annotations
+        if: ${{ !steps.check_permissions.outputs.has-permission }}
+        env:
+          RUSTFLAGS: "-C target-cpu=native"
+        run: cargo clippy --all
+  coverage:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v1
+      - uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable        
+          profile: minimal
+          components: llvm-tools-preview
+      - name: Install cargo-llvm-cov
+        uses: taiki-e/install-action@cargo-llvm-cov
+      - name: Run codecov
+        env:
+          RUSTFLAGS: "-C target-cpu=native"
+        run: cargo llvm-cov --lcov --output-path lcov.txt 
+      - uses: codecov/codecov-action@v3
+        with:
+          files: ./lcov.txt # optional
+          flags: ${{ env.flags }} # optional
+          fail_ci_if_error: true # optional (default = false)
+          verbose: true # optional (default = false)

.github/workflows/tests.yml

@@ -0,0 +1,32 @@
+name: Tests
+
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        rustflags:
+          - '-C target-cpu=native'
+        features:
+          - ''
+          - '--features 128bit'
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v1
+    - uses: actions-rs/toolchain@v1
+      with:
+        toolchain: stable
+        override: true
+    - name: Build
+      env:
+        RUSTFLAGS: ${{ matrix.rustflags }}
+      run: cargo build ${{ matrix.features }}
+    - name: Run tests
+      env:
+        RUSTFLAGS: ${{ matrix.rustflags }}
+      run: cargo test ${{ matrix.features }}

Cargo.toml

@@ -9,6 +9,7 @@ documentation = "https://docs.rs/simd-json-derive"
 readme = "README.md"
 homepage = "https://docs.rs/simd-json-derive"
 repository = "https://github.com/simd-lite/simd-json-derive/"
+rust-version = "1.59"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -28,3 +29,13 @@ serde = "1"
 default = ["impl-chrono"]
 impl-chrono = ["chrono"]
 128bit = ["simd-json-derive-int/128bit", "simd-json/128bit"]
+allow-non-simd = [
+    "simd-json-derive-int/allow-non-simd",
+    "simd-json/allow-non-simd",
+]
+
+[package.metadata.docs.rs]
+features = ["allow-non-simd"]
+
+[[example]]
+name = "enum1"

README.md

@@ -1,11 +1,45 @@
-Derives for high performance JSON serialisation (and eventually deserialisation).
+# simd-json-derive
 
-Attributres are supported for both `#[simd_json(...)]` and for compatibilty also for `#[serde(...)]` and follow the same nameing conventions as serde.
+[![Latest version](https://img.shields.io/crates/v/simd-json-derive.svg)](https://crates.io/crates/simd-json-derive)
+[![documentation](https://img.shields.io/docsrs/simd-json-derive)](https://docs.rs/simd-json-derive)
+![License](https://img.shields.io/crates/l/simd-json-derive.svg)
+
+
+Derives for high performance JSON serialisation and deserialisation.
+
+## Usage
+
+```rust
+
+#[derive(Serialize, Deserialize, Debug)]
+#[simd_json(deny_unknown_fields, rename_all = "camelCase")]
+struct MyStruct {
+    first_field: String,
+    #[simd_json(rename = "foo")]
+    second_field: Option<usize>
+}
+
+fn main -> Result<(), simd_json::Error> {
+    let my_struct = MyStruct {
+        first_field: "i am first".to_string(),
+        second_field: None
+    }
+    println!("Before: {my_struct:?}");
+    let mut json_string = my_struct.json_string()?;
+    let deserialized = MyStruct::from_str(json_string.as_mut_str())?;
+    println!("After: {deserialized:?}");
+}
+```
+
+## Supported Attributes
+
+Attributres are supported for both `#[simd_json(...)]` and for compatibilty also for `#[serde(...)]` and follow the same naming conventions as serde.
 
 For fields:
 
 * `rename = "new_name"` - renames a field
 
 For structs:
 
-* `rename_all = "camelCase"` - renames all (not otherwise renamed) based on the rule, `camelCase` is currently supportd
+* `rename_all = "camelCase"` - renames all (not otherwise renamed) based on the rule, `camelCase` is currently supported
+* `deny_unknown_fields` - Errors if unknown fields are encountered

examples/enum1.rs

@@ -1,9 +1,18 @@
-#[derive(simd_json_derive::Deserialize)]
+use simd_json_derive::{Deserialize, Serialize};
+
+#[derive(Deserialize, Serialize, Debug)]
 pub enum StoredVariants {
     YesNo(bool),
     Small(u8, i8),
     Signy(i64),
     Stringy(String),
 }
 
-fn main() {}
+fn main() {
+    let x = StoredVariants::Signy(-1);
+    let mut serialized = x.json_string().expect("serialization shouldnt fail :(");
+    let deserialized = StoredVariants::from_str(serialized.as_mut_str())
+        .expect("serialized stuff should be deserializable");
+    println!("Serialized: {x:?}");
+    println!("Deserialized: {deserialized:?}");
+}

simd-json-derive-int/Cargo.toml

@@ -15,7 +15,9 @@ proc-macro = true
 proc-macro2 = "1.0"
 quote = "1.0"
 syn = { version = "1.0", features = ["visit", "extra-traits"] }
-simd-json = { version = "0.6", features = ["allow-non-simd"] }
+simd-json = "0.6"
 
 [features]
+default = ["allow-non-simd"]
 128bit = ["simd-json/128bit"]
+allow-non-simd = ["simd-json/allow-non-simd"]

simd-json-derive-int/src/args.rs

@@ -69,22 +69,22 @@ impl RenameAll {
 #[derive(Debug)]
 pub(crate) struct StructAttrs {
     rename_all: RenameAll,
-    // deny_unknown_fields: bool,
+    deny_unknown_fields: bool,
 }
 
 impl Default for StructAttrs {
     fn default() -> Self {
         StructAttrs {
             rename_all: RenameAll::None,
-            // deny_unknown_fields: false,
+            deny_unknown_fields: false,
         }
     }
 }
 
 impl Parse for StructAttrs {
     fn parse(input: ParseStream) -> syn::Result<Self> {
         let mut rename_all = RenameAll::None;
-        let mut _deny_unknown_fields = false;
+        let mut deny_unknown_fields = false;
         while !input.is_empty() {
             let attr: Ident = input.parse()?;
             match attr.to_string().as_str() {
@@ -103,7 +103,7 @@ impl Parse for StructAttrs {
                     }
                 }
                 "deny_unknown_fields" => {
-                    _deny_unknown_fields = true;
+                    deny_unknown_fields = true;
                 }
                 other => {
                     return Err(syn::Error::new(
@@ -118,7 +118,7 @@ impl Parse for StructAttrs {
         }
         Ok(StructAttrs {
             rename_all,
-            // deny_unknown_fields,
+            deny_unknown_fields,
         })
     }
 }
@@ -143,24 +143,29 @@ pub(crate) fn get_attr<'field>(
         .next()
 }
 
-pub(crate) fn name(struct_attr: &StructAttrs, field: &Field) -> Option<String> {
-    if let Some(attr) = get_attr(&field.attrs, "simd_json")
-        .map(field_attrs)
-        .and_then(|a| a.rename)
-    {
-        Some(format!("{}:", simd_json::OwnedValue::from(attr).encode()))
-    } else if let Some(attr) = get_attr(&field.attrs, "serde")
-        .map(field_attrs)
-        .and_then(|a| a.rename)
-    {
-        Some(format!("{}:", simd_json::OwnedValue::from(attr).encode()))
-    } else {
-        field.ident.as_ref().map(|ident| {
-            format!(
-                "{}:",
-                simd_json::OwnedValue::from(struct_attr.rename_all.apply(&ident.to_string()))
-                    .encode()
-            )
-        })
+impl StructAttrs {
+    pub(crate) fn deny_unknown_fields(&self) -> bool {
+        self.deny_unknown_fields
+    }
+
+    pub(crate) fn name(&self, field: &Field) -> Option<String> {
+        if let Some(attr) = get_attr(&field.attrs, "simd_json")
+            .map(field_attrs)
+            .and_then(|a| a.rename)
+        {
+            Some(format!("{}:", simd_json::OwnedValue::from(attr).encode()))
+        } else if let Some(attr) = get_attr(&field.attrs, "serde")
+            .map(field_attrs)
+            .and_then(|a| a.rename)
+        {
+            Some(format!("{}:", simd_json::OwnedValue::from(attr).encode()))
+        } else {
+            field.ident.as_ref().map(|ident| {
+                format!(
+                    "{}:",
+                    simd_json::OwnedValue::from(self.rename_all.apply(&ident.to_string())).encode()
+                )
+            })
+        }
     }
 }