Remove usages of gen identifier (#323)

`gen` is a reserved keyword in rust 2024, making it very awkward to use as a module/variable name.

docs/1.1-attributes.md

@@ -267,7 +267,7 @@ Validator docs: [required](https://github.com/Keats/validator#required) / [requi
 
 </h3>
 
-Set on a variant or field to generate this field's schema using the given function. This function must be callable as `fn(&mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema`.
+Set on a variant or field to generate this field's schema using the given function. This function must be callable as `fn(&mut schemars::SchemaGenerator) -> schemars::schema::Schema`.
 
 <h3 id="title-description">
 

docs/2-implementing.md

@@ -60,10 +60,10 @@ The default implementation of this function returns `Self::schema_name()`.
 ## json_schema
 
 ```rust
-fn json_schema(gen: &mut gen::SchemaGenerator) -> Schema;
+fn json_schema(generator: &mut SchemaGenerator) -> Schema;
 ```
 
-This function creates the JSON schema itself. The `gen` argument can be used to check the schema generation settings, or to get schemas for other types. If you do need schemas for other types, you should call the `gen.subschema_for::<T>()` method instead of `<T>::json_schema(gen)`, as `subschema_for` can add `T`'s schema to the root schema's `$defs` so that it does not need to be duplicated when used more than once.
+This function creates the JSON schema itself. The `generator` argument can be used to check the schema generation settings, or to get schemas for other types. If you do need schemas for other types, you should call the `generator.subschema_for::<T>()` method instead of `<T>::json_schema(generator)`, as `subschema_for` can add `T`'s schema to the root schema's `$defs` so that it does not need to be duplicated when used more than once.
 
 `json_schema` should not return a `$ref` schema.
 

docs/3-generating.md

@@ -6,7 +6,7 @@ permalink: /generating/
 
 # Generating Schemas
 
-The easiest way to generate a schema for a type that implements is to use the [`schema_for!` macro](https://docs.rs/schemars/latest/schemars/macro.schema_for.html), like so:
+The easiest way to generate a schema for a type that implements is to use the [`schema_for!` macro](https://docs.rs/schemars/1.0.0--latest/schemars/macro.schema_for.html), like so:
 
 ```rust
 let my_schema = schema_for!(MyStruct);
@@ -14,10 +14,10 @@ let my_schema = schema_for!(MyStruct);
 
 This will create a schema that conforms to [JSON Schema 2020-12](https://json-schema.org/specification-links#2020-12), but this is liable to change in a future version of Schemars if support for other JSON Schema versions is added.
 
-If you want more control over how the schema is generated, you can use the [`gen` module](https://docs.rs/schemars/latest/schemars/gen/). There are two main types in this module:
+If you want more control over how the schema is generated, you can use the [`generate` module](https://docs.rs/schemars/1.0.0--latest/schemars/generate/). There are two main types in this module:
 
-- [`SchemaSettings`](https://docs.rs/schemars/latest/schemars/gen/struct.SchemaSettings.html), which defines what JSON Schema features should be used when generating schemas (for example, how `Option`s should be represented).
-- [`SchemaGenerator`](https://docs.rs/schemars/latest/schemars/gen/struct.SchemaGenerator.html), which manages the generation of a schema document.
+- [`SchemaSettings`](https://docs.rs/schemars/1.0.0--latest/schemars/generate/struct.SchemaSettings.html), which defines what JSON Schema features should be used when generating schemas (for example, how `Option`s should be represented).
+- [`SchemaGenerator`](https://docs.rs/schemars/1.0.0--latest/schemars/generate/struct.SchemaGenerator.html), which manages the generation of a schema document.
 
 For example, to generate a schema that conforms to [JSON Schema Draft 7](https://json-schema.org/specification-links.html#draft-7):
 
@@ -30,7 +30,7 @@ See the API documentation for more info on how to use those types for custom sch
 
 ## Schema from Example Value
 
-If you want a schema for a type that can't/doesn't implement `JsonSchema`, but does implement `serde::Serialize`, then you can generate a JSON schema from a value of that type using the [`schema_for_value!` macro](https://docs.rs/schemars/latest/schemars/macro.schema_for_value.html). However, this schema will generally be less precise than if the type implemented `JsonSchema` - particularly when it involves enums, since schemars will not make any assumptions about the structure of an enum based on a single variant.
+If you want a schema for a type that can't/doesn't implement `JsonSchema`, but does implement `serde::Serialize`, then you can generate a JSON schema from a value of that type using the [`schema_for_value!` macro](https://docs.rs/schemars/1.0.0--latest/schemars/macro.schema_for_value.html). However, this schema will generally be less precise than if the type implemented `JsonSchema` - particularly when it involves enums, since schemars will not make any assumptions about the structure of an enum based on a single variant.
 
 ```rust
 let value = MyStruct { foo = 123 };

docs/_includes/examples/custom_serialization.rs

@@ -19,8 +19,8 @@ pub struct MyStruct {
     pub bool_normal: bool,
 }
 
-fn make_custom_schema(gen: &mut SchemaGenerator) -> Schema {
-    let mut schema = String::json_schema(gen);
+fn make_custom_schema(generator: &mut SchemaGenerator) -> Schema {
+    let mut schema = String::json_schema(generator);
     schema
         .ensure_object()
         .insert("format".into(), "boolean".into());

docs/_includes/examples/custom_settings.rs

@@ -1,4 +1,4 @@
-use schemars::{gen::SchemaSettings, JsonSchema};
+use schemars::{generate::SchemaSettings, JsonSchema};
 
 #[derive(JsonSchema)]
 pub struct MyStruct {
@@ -18,7 +18,7 @@ fn main() {
         s.option_nullable = true;
         s.option_add_null_type = false;
     });
-    let gen = settings.into_generator();
-    let schema = gen.into_root_schema_for::<MyStruct>();
+    let generator = settings.into_generator();
+    let schema = generator.into_root_schema_for::<MyStruct>();
     println!("{}", serde_json::to_string_pretty(&schema).unwrap());
 }

docs/examples/4-custom_settings.md

@@ -7,6 +7,6 @@ summary: Generating a schema using custom settings which changes how Option<T> i
 
 # Custom Schema Settings
 
-The `gen` module allows you to customise how schemas are generated. For example, the default behaviour for `Option<T>` is to include `null` in the schema's `type`s, but we can instead add a `nullable` property to its schema:
+The `generate` module allows you to customise how schemas are generated. For example, the default behaviour for `Option<T>` is to include `null` in the schema's `type`s, but we can instead add a `nullable` property to its schema:
 
 {% include example.md name="custom_settings" %}

docs/index.md

@@ -7,7 +7,7 @@ nav_order: 1
 
 Schemars is a library to generate JSON Schema documents from Rust data structures.
 
-This is built on Rust's trait system - any type which implements the [`JsonSchema`](https://docs.rs/schemars/latest/schemars/trait.JsonSchema.html) trait can have a JSON Schema generated describing that type. Schemars implements this on many standard library types, and provides a derive macro to automatically implement it on custom types.
+This is built on Rust's trait system - any type which implements the [`JsonSchema`](https://docs.rs/schemars/1.0.0--latest/schemars/trait.JsonSchema.html) trait can have a JSON Schema generated describing that type. Schemars implements this on many standard library types, and provides a derive macro to automatically implement it on custom types.
 
 One of the main aims of this library is compatibility with [Serde](https://github.com/serde-rs/serde). Any generated schema _should_ match how [serde_json](https://github.com/serde-rs/json) would serialize/deserialize to/from JSON. To support this, Schemars will check for any `#[serde(...)]` attributes on types that derive `JsonSchema`, and adjust the generated schema accordingly.