Merge branch 'GREsau:master' into better-map-support

Author: stegaBOB

.github/workflows/ci.yml

@@ -23,7 +23,7 @@ jobs:
             allow_failure: true
       fail-fast: false
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - name: Downgrade packages for MSRV
         if: matrix.rust == '1.74.0'
         run: |
@@ -45,3 +45,32 @@ jobs:
         run: cargo test --verbose --all-features --no-fail-fast
         continue-on-error: ${{ matrix.allow_failure }}
         working-directory: ./schemars_derive
+      - name: Check with latest dependency versions
+        if: matrix.rust != '1.74.0'
+        run: |
+          cargo update
+          cargo check --all-features --verbose --example main
+      - name: Check with minimal dependency versions
+        run: |
+          # Ignore dev-dependencies because they're irrelevant for consumers of schemars
+          # Modified workaround from https://github.com/SpriteOvO/spdlog-rs/blob/09b1f25ad7654a5535eea1497bd70382fb0c16ae/.github/workflows/ci.yml#L110-L112
+          sed -i 's/\[dev-dependencies]/[package.metadata.workaround-avoid-dev-deps]/g' ./schemars/Cargo.toml ./schemars_derive/Cargo.toml
+          cargo +nightly generate-lockfile -Z direct-minimal-versions
+          cargo check --all-features --verbose --example main
+
+  clippy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - uses: dtolnay/rust-toolchain@clippy
+      - run: cargo clippy --all-targets -- -D warnings
+      - run: cargo clippy --all-targets --all-features -- -D warnings
+
+  semver-checks:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - name: Check semver
+        uses: obi1kenobi/cargo-semver-checks-action@v2
+        with:
+          release-type: minor

CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## [1.1.0] - 2025-11-05
+
+### Added
+
+- Public functions that have no side-effects are now marked with [`#[must_use]`](https://doc.rust-lang.org/reference/attributes/diagnostics.html#the-must_use-attribute) so that they report a lint warning when the returned value is unused, as this likely indicates a mistake.
+
+### Fixed
+
+- Improve accuracy of schemas for flattened enums, in particular: unit variants of externally-tagged enums, and enums wrapped in `Option<>`. (https://github.com/GREsau/schemars/issues/464 / https://github.com/GREsau/schemars/pull/483)
+
+## [1.0.5] - 2025-11-02
+
+### Fixed
+
+- Fix `schema.pointer_mut()` to resolve URI fragment identifiers like `#/$defs/foo`, matching current behaviour of `schema.pointer()` (https://github.com/GREsau/schemars/issues/478 / https://github.com/GREsau/schemars/pull/479)
+
+## [1.0.4] - 2025-07-06
+
+### Fixed
+
+- Fix `JsonSchema` impl on [atomic](https://doc.rust-lang.org/std/sync/atomic/) types being ignored on non-nightly compilers due to a buggy `cfg` check (https://github.com/GREsau/schemars/issues/453)
+- Fix compatibility with minimal dependency versions, e.g. old(-ish) versions of `syn` (https://github.com/GREsau/schemars/issues/450)
+- Fix derive for empty tuple variants (https://github.com/GREsau/schemars/issues/455)
+
 ## [1.0.3] - 2025-06-28
 
 ### Fixed

Cargo.lock

@@ -290,5 +290,5 @@ For example, to implement `JsonSchema` on types from `chrono`, enable it as a fe
 
 ```toml
 [dependencies]
-schemars = { version = "0.9.0", features = ["chrono04"] }
+schemars = { version = "1.0", features = ["chrono04"] }
 ```

README.md

@@ -215,7 +215,7 @@ Serde docs: [container](https://serde.rs/container-attrs.html#transparent)
 
 </h3>
 
-Where-clause for the JsonSchema impl. This replaces any trait bounds inferred by schemars. Schemars does **not** use trait bounds from `#[serde(bound)]` attributes.
+Where-clause for the `JsonSchema` impl. This replaces any trait bounds inferred by schemars. Schemars does **not** use trait bounds from `#[serde(bound)]` attributes.
 
 Serde docs: [container](https://serde.rs/container-attrs.html#bound)
 

docs/_includes/attributes.md

@@ -1,4 +1,4 @@
-# Deriving JsonSchema
+# Deriving `JsonSchema`
 
 The most important trait in Schemars is `JsonSchema`, and the most important function of that trait is `json_schema(...)` which returns a JSON schema describing the type. Implementing this manually on many types would be slow and error-prone, so Schemars includes a derive macro which can implement that trait for you. Any derived implementation of `JsonSchema` should create a schema that describes the JSON representation of the type if it were to be serialized by serde_json.
 

docs/_includes/deriving.md

@@ -5,7 +5,7 @@ nav_order: 3
 summary: "Deriving JsonSchema on types that use #[schemars] attributes to customise serialization behaviour."
 ---
 
-# Using Serde Attributes
+# Using Schemars Attributes
 
 `#[serde(...)]` attributes can be overriden (or replaced) with `#[schemars(...)]` attributes, which behave identically. You may find this useful if you want to change the generated schema without affecting Serde's behaviour, or if you're just not using Serde.
 

docs/examples/3-schemars_attrs.md

@@ -3,7 +3,7 @@ name = "schemars"
 description = "Generate JSON Schemas from Rust code"
 homepage = "https://graham.cool/schemars/"
 repository = "https://github.com/GREsau/schemars"
-version = "1.0.3"
+version = "1.1.0"
 authors = ["Graham Esau <gesau@hotmail.co.uk>"]
 edition = "2021"
 license = "MIT"
@@ -13,10 +13,10 @@ categories = ["encoding", "no-std"]
 rust-version = "1.74"
 
 [dependencies]
-schemars_derive = { version = "=1.0.3", optional = true, path = "../schemars_derive" }
-serde = { version = "1.0", default-features = false, features = ["alloc"]}
+schemars_derive = { version = "=1.1.0", optional = true, path = "../schemars_derive" }
+serde = { version = "1.0.194", default-features = false, features = ["alloc"]}
 serde_json = { version =  "1.0.127", default-features = false, features = ["alloc"] }
-dyn-clone = "1.0"
+dyn-clone = "1.0.17"
 ref-cast = "1.0.22"
 
 # optional dependencies
@@ -25,9 +25,9 @@ bigdecimal04 = { version = "0.4", default-features = false, optional = true, pac
 bytes1 = { version = "1.0", default-features = false, optional = true, package = "bytes" }
 chrono04 = { version = "0.4.39", default-features = false, optional = true, package = "chrono" }
 either1 = { version = "1.3", default-features = false, optional = true, package = "either" }
-indexmap2 = { version = "2.0", default-features = false, optional = true, package = "indexmap" }
+indexmap2 = { version = "2.2.3", default-features = false, optional = true, package = "indexmap" }
 jiff02 = { version = "0.2", default-features = false, optional = true, package = "jiff" }
-rust_decimal1 = { version = "1", default-features = false, optional = true, package = "rust_decimal" }
+rust_decimal1 = { version = "1.13", default-features = false, optional = true, package = "rust_decimal" }
 semver1 = { version = "1.0.9", default-features = false, optional = true, package = "semver" }
 smallvec1 = { version = "1.0", default-features = false, optional = true, package = "smallvec" }
 smol_str02 = { version = "0.2.1", default-features = false, optional = true, package = "smol_str" }

schemars/Cargo.toml

@@ -46,22 +46,103 @@ pub fn json_schema_for_internally_tagged_enum_newtype_variant<T: ?Sized + JsonSc
     generator.subschema_for::<T>()
 }
 
-// Helper for generating schemas for flattened `Option` fields.
+// Helper for generating schemas for flattened enums and `Option` fields.
 pub fn json_schema_for_flatten<T: ?Sized + JsonSchema>(
     generator: &mut SchemaGenerator,
     required: bool,
 ) -> Schema {
-    let mut schema = T::_schemars_private_non_optional_json_schema(generator);
+    /// Non-generic inner function to reduce monomorphization overhead
+    fn inner(mut schema: Schema, is_optional: bool) -> Schema {
+        // Special handling for externally-tagged enums with unit variants.
+        // Unit variants are normally serialized as strings, but when flattened, are serialized
+        // as objects like `{ "VariantName": null }`
+        if let Some(unit_variants) = remove_unit_variants(&mut schema) {
+            if let Value::Array(one_of) = schema
+                .ensure_object()
+                .entry("oneOf")
+                .or_insert(Value::Array(Vec::new()))
+            {
+                one_of.extend(
+                    unit_variants
+                        .iter()
+                        .filter_map(Value::as_str)
+                        .map(|variant| {
+                            json!({
+                                "type": "object",
+                                "properties": {
+                                    variant: {
+                                        "type": "null"
+                                    }
+                                },
+                                "required": [variant],
+                            })
+                        }),
+                );
+            }
+        }
+
+        if is_optional {
+            schema.remove("required");
+
+            // Handle `Option<>` of externally/internally/adjacently-tagged enums
+            if let Some(one_of) = schema.remove("oneOf") {
+                // We can't just add `{}` to the existing `oneOf`, because its items must be
+                // mutually-exclusive, and `{}` matches everything.
+                flatten(
+                    &mut schema,
+                    json_schema!({
+                        "anyOf": [
+                            { "oneOf": one_of },
+                            {}
+                        ]
+                    }),
+                );
+            }
+
+            // Handle `Option<>` of untagged enums
+            if let Some(Value::Array(any_of)) = schema.get_mut("anyOf") {
+                let empty_object = Value::Object(Map::new());
+                if !any_of.contains(&empty_object) {
+                    any_of.push(empty_object);
+                }
+            }
+        }
 
-    if T::_schemars_private_is_option() && !required {
-        schema.remove("required");
+        // Always allow aditional/unevaluated properties, because the outer struct determines
+        // whether it denies unknown fields.
+        AllowUnknownProperties::default().transform(&mut schema);
+
+        schema
     }
 
-    // Always allow aditional/unevaluated properties, because the outer struct determines
-    // whether it denies unknown fields.
-    AllowUnknownProperties::default().transform(&mut schema);
+    fn remove_unit_variants(schema: &mut Schema) -> Option<Vec<Value>> {
+        // For enums that only have unit variants, all variants are in `enum`
+        if schema.get("type").and_then(Value::as_str) == Some("string") {
+            // Remove both `"enum": [...]`...
+            if let Some(Value::Array(a)) = schema.remove("enum") {
+                // ...and `"type": "string"`, since the variants are not serialized as strings
+                schema.remove("type");
+                return Some(a);
+            }
+        }
+
+        // For enums that have unit and other variants, unit variants are in the first `oneOf` item
+        let one_of = schema.get_mut("oneOf")?.as_array_mut()?;
+        let first = <&mut Schema>::try_from(one_of.get_mut(0)?).ok()?;
+        if first.get("type").and_then(Value::as_str) == Some("string") {
+            if let Some(Value::Array(a)) = first.remove("enum") {
+                one_of.remove(0);
+                return Some(a);
+            }
+        }
+
+        None
+    }
 
-    schema
+    inner(
+        T::_schemars_private_non_optional_json_schema(generator),
+        T::_schemars_private_is_option() && !required,
+    )
 }
 
 #[derive(Default)]
@@ -116,6 +197,7 @@ impl<T: Serialize> MaybeSerializeWrapper<T> {
 }
 
 /// Create a schema for a unit enum variant
+#[must_use]
 pub fn new_unit_enum_variant(variant: &str) -> Schema {
     json_schema!({
         "type": "string",
@@ -143,6 +225,7 @@ macro_rules! _schemars_maybe_schema_id {
 pub struct MaybeJsonSchemaWrapper<T: ?Sized>(core::marker::PhantomData<T>);
 
 pub trait NoJsonSchema {
+    #[must_use]
     fn maybe_schema_id() -> Cow<'static, str> {
         Cow::Borrowed(core::any::type_name::<Self>())
     }
@@ -151,13 +234,15 @@ pub trait NoJsonSchema {
 impl<T: ?Sized> NoJsonSchema for T {}
 
 impl<T: JsonSchema + ?Sized> MaybeJsonSchemaWrapper<T> {
+    #[must_use]
     pub fn maybe_schema_id() -> Cow<'static, str> {
         T::schema_id()
     }
 }
 
 /// Create a schema for an externally tagged enum variant
 #[allow(clippy::needless_pass_by_value)]
+#[must_use]
 pub fn new_externally_tagged_enum_variant(variant: &str, sub_schema: Schema) -> Schema {
     // TODO: this can be optimised by inserting the `sub_schema` as a `Value` rather than
     // using the `json_schema!` macro which borrows and serializes the sub_schema

schemars/src/_private/mod.rs

@@ -1,3 +1,4 @@
+#[must_use]
 pub const fn get_title_and_description(doc: &str) -> (&str, &str) {
     let doc_bytes = trim_ascii(doc.as_bytes());