Add schemars feature (#4305)

crates/ruff/Cargo.toml

@@ -56,7 +56,7 @@ result-like = { version = "0.4.6" }
 rustc-hash = { workspace = true }
 rustpython-common = { workspace = true }
 rustpython-parser = { workspace = true }
-schemars = { workspace = true }
+schemars = { workspace = true, optional = true }
 semver = { version = "1.0.16" }
 serde = { workspace = true }
 serde_json = { workspace = true }
@@ -80,5 +80,6 @@ colored = { workspace = true, features = ["no-color"] }
 
 [features]
 default = []
+schemars = ["dep:schemars"]
 logical_lines = []
 jupyter_notebook = []

crates/ruff/src/rule_selector.rs

@@ -1,9 +1,5 @@
 use std::str::FromStr;
 
-use itertools::Itertools;
-use schemars::_serde_json::Value;
-use schemars::schema::{InstanceType, Schema, SchemaObject};
-use schemars::JsonSchema;
 use serde::de::{self, Visitor};
 use serde::{Deserialize, Serialize};
 use strum::IntoEnumIterator;
@@ -198,59 +194,71 @@ pub(crate) const fn prefix_to_selector(prefix: RuleCodePrefix) -> RuleSelector {
     }
 }
 
-impl JsonSchema for RuleSelector {
-    fn schema_name() -> String {
-        "RuleSelector".to_string()
-    }
+#[cfg(feature = "schemars")]
+mod schema {
+    use crate::registry::RuleNamespace;
+    use crate::rule_selector::{Linter, Rule, RuleCodePrefix};
+    use crate::RuleSelector;
+    use itertools::Itertools;
+    use schemars::_serde_json::Value;
+    use schemars::schema::{InstanceType, Schema, SchemaObject};
+    use schemars::JsonSchema;
+    use strum::IntoEnumIterator;
 
-    fn json_schema(_gen: &mut schemars::gen::SchemaGenerator) -> Schema {
-        Schema::Object(SchemaObject {
-            instance_type: Some(InstanceType::String.into()),
-            enum_values: Some(
-                [
-                    // Include the non-standard "ALL" selector.
-                    "ALL".to_string(),
-                    // Include the legacy "C" and "T" selectors.
-                    "C".to_string(),
-                    "T".to_string(),
-                    // Include some common redirect targets for those legacy selectors.
-                    "C9".to_string(),
-                    "T1".to_string(),
-                    "T2".to_string(),
-                ]
-                .into_iter()
-                .chain(
-                    RuleCodePrefix::iter()
-                        .filter(|p| {
-                            // Once logical lines are active by default, please remove this.
-                            // This is here because generate-all output otherwise depends on
-                            // the feature sets which makes the test running with
-                            // `--all-features` fail
-                            !Rule::from_code(&format!(
-                                "{}{}",
-                                p.linter().common_prefix(),
-                                p.short_code()
-                            ))
-                            .unwrap()
-                            .lint_source()
-                            .is_logical_lines()
-                        })
-                        .map(|p| {
-                            let prefix = p.linter().common_prefix();
-                            let code = p.short_code();
-                            format!("{prefix}{code}")
-                        })
-                        .chain(Linter::iter().filter_map(|l| {
-                            let prefix = l.common_prefix();
-                            (!prefix.is_empty()).then(|| prefix.to_string())
-                        })),
-                )
-                .sorted()
-                .map(Value::String)
-                .collect(),
-            ),
-            ..SchemaObject::default()
-        })
+    impl JsonSchema for RuleSelector {
+        fn schema_name() -> String {
+            "RuleSelector".to_string()
+        }
+
+        fn json_schema(_gen: &mut schemars::gen::SchemaGenerator) -> Schema {
+            Schema::Object(SchemaObject {
+                instance_type: Some(InstanceType::String.into()),
+                enum_values: Some(
+                    [
+                        // Include the non-standard "ALL" selector.
+                        "ALL".to_string(),
+                        // Include the legacy "C" and "T" selectors.
+                        "C".to_string(),
+                        "T".to_string(),
+                        // Include some common redirect targets for those legacy selectors.
+                        "C9".to_string(),
+                        "T1".to_string(),
+                        "T2".to_string(),
+                    ]
+                    .into_iter()
+                    .chain(
+                        RuleCodePrefix::iter()
+                            .filter(|p| {
+                                // Once logical lines are active by default, please remove this.
+                                // This is here because generate-all output otherwise depends on
+                                // the feature sets which makes the test running with
+                                // `--all-features` fail
+                                !Rule::from_code(&format!(
+                                    "{}{}",
+                                    p.linter().common_prefix(),
+                                    p.short_code()
+                                ))
+                                .unwrap()
+                                .lint_source()
+                                .is_logical_lines()
+                            })
+                            .map(|p| {
+                                let prefix = p.linter().common_prefix();
+                                let code = p.short_code();
+                                format!("{prefix}{code}")
+                            })
+                            .chain(Linter::iter().filter_map(|l| {
+                                let prefix = l.common_prefix();
+                                (!prefix.is_empty()).then(|| prefix.to_string())
+                            })),
+                    )
+                    .sorted()
+                    .map(Value::String)
+                    .collect(),
+                ),
+                ..SchemaObject::default()
+            })
+        }
     }
 }
 

crates/ruff/src/rules/flake8_annotations/settings.rs

@@ -1,19 +1,17 @@
 //! Settings for the `flake-annotations` plugin.
 
-use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
 use ruff_macros::CacheKey;
 use ruff_macros::ConfigurationOptions;
 
-#[derive(
-    Debug, PartialEq, Eq, Default, Serialize, Deserialize, ConfigurationOptions, JsonSchema,
-)]
+#[derive(Debug, PartialEq, Eq, Default, Serialize, Deserialize, ConfigurationOptions)]
 #[serde(
     deny_unknown_fields,
     rename_all = "kebab-case",
     rename = "Flake8AnnotationsOptions"
 )]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Options {
     #[option(
         default = "false",

crates/ruff/src/rules/flake8_bandit/settings.rs

@@ -1,6 +1,5 @@
 //! Settings for the `flake8-bandit` plugin.
 
-use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
 use ruff_macros::{CacheKey, ConfigurationOptions};
@@ -11,14 +10,13 @@ fn default_tmp_dirs() -> Vec<String> {
         .to_vec()
 }
 
-#[derive(
-    Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions, JsonSchema,
-)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions)]
 #[serde(
     deny_unknown_fields,
     rename_all = "kebab-case",
     rename = "Flake8BanditOptions"
 )]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Options {
     #[option(
         default = "[\"/tmp\", \"/var/tmp\", \"/dev/shm\"]",

crates/ruff/src/rules/flake8_bugbear/settings.rs

@@ -1,18 +1,16 @@
 //! Settings for the `flake8-bugbear` plugin.
 
-use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
 use ruff_macros::{CacheKey, ConfigurationOptions};
 
-#[derive(
-    Debug, PartialEq, Eq, Default, Serialize, Deserialize, ConfigurationOptions, JsonSchema,
-)]
+#[derive(Debug, PartialEq, Eq, Default, Serialize, Deserialize, ConfigurationOptions)]
 #[serde(
     deny_unknown_fields,
     rename_all = "kebab-case",
     rename = "Flake8BugbearOptions"
 )]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Options {
     #[option(
         default = r#"[]"#,

crates/ruff/src/rules/flake8_builtins/settings.rs

@@ -1,18 +1,16 @@
 //! Settings for the `flake8-builtins` plugin.
 
-use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
 use ruff_macros::{CacheKey, ConfigurationOptions};
 
-#[derive(
-    Debug, PartialEq, Eq, Default, Serialize, Deserialize, ConfigurationOptions, JsonSchema,
-)]
+#[derive(Debug, PartialEq, Eq, Default, Serialize, Deserialize, ConfigurationOptions)]
 #[serde(
     deny_unknown_fields,
     rename_all = "kebab-case",
     rename = "Flake8BuiltinsOptions"
 )]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Options {
     #[option(
         default = r#"[]"#,

crates/ruff/src/rules/flake8_comprehensions/settings.rs

@@ -1,18 +1,16 @@
 //! Settings for the `flake8-comprehensions` plugin.
 
-use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
 use ruff_macros::{CacheKey, ConfigurationOptions};
 
-#[derive(
-    Debug, PartialEq, Eq, Default, Serialize, Deserialize, ConfigurationOptions, JsonSchema,
-)]
+#[derive(Debug, PartialEq, Eq, Default, Serialize, Deserialize, ConfigurationOptions)]
 #[serde(
     deny_unknown_fields,
     rename_all = "kebab-case",
     rename = "Flake8ComprehensionsOptions"
 )]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Options {
     #[option(
         default = "false",

crates/ruff/src/rules/flake8_errmsg/settings.rs

@@ -1,18 +1,16 @@
 //! Settings for the `flake8-errmsg` plugin.
 
-use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
 use ruff_macros::{CacheKey, ConfigurationOptions};
 
-#[derive(
-    Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions, JsonSchema,
-)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions)]
 #[serde(
     deny_unknown_fields,
     rename_all = "kebab-case",
     rename = "Flake8ErrMsgOptions"
 )]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Options {
     #[option(default = "0", value_type = "int", example = "max-string-length = 20")]
     /// Maximum string length for string literals in exception messages.

crates/ruff/src/rules/flake8_gettext/settings.rs

@@ -1,16 +1,14 @@
-use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
 use ruff_macros::{CacheKey, ConfigurationOptions};
 
-#[derive(
-    Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions, JsonSchema,
-)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions)]
 #[serde(
     deny_unknown_fields,
     rename_all = "kebab-case",
     rename = "Flake8GetTextOptions"
 )]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Options {
     #[option(
         default = r#"["_", "gettext", "ngettext"]"#,

crates/ruff/src/rules/flake8_implicit_str_concat/settings.rs

@@ -1,18 +1,16 @@
 //! Settings for the `flake8-implicit-str-concat` plugin.
 
-use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
 use ruff_macros::{CacheKey, ConfigurationOptions};
 
-#[derive(
-    Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions, JsonSchema,
-)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions)]
 #[serde(
     deny_unknown_fields,
     rename_all = "kebab-case",
     rename = "Flake8ImplicitStrConcatOptions"
 )]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Options {
     #[option(
         default = r#"true"#,

crates/ruff/src/rules/flake8_import_conventions/settings.rs

@@ -1,7 +1,6 @@
 //! Settings for import conventions.
 
 use rustc_hash::{FxHashMap, FxHashSet};
-use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
 use ruff_macros::{CacheKey, ConfigurationOptions};
@@ -21,14 +20,13 @@ const CONVENTIONAL_ALIASES: &[(&str, &str)] = &[
     ("pyarrow", "pa"),
 ];
 
-#[derive(
-    Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions, JsonSchema,
-)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions)]
 #[serde(
     deny_unknown_fields,
     rename_all = "kebab-case",
     rename = "Flake8ImportConventionsOptions"
 )]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Options {
     #[option(
         default = r#"{"altair": "alt", "matplotlib": "mpl", "matplotlib.pyplot": "plt", "numpy": "np", "pandas": "pd", "seaborn": "sns", "tensorflow": "tf", "holoviews": "hv", "panel": "pn", "plotly.express": "px", "polars": "pl", "pyarrow": "pa"}"#,

crates/ruff/src/rules/flake8_pytest_style/settings.rs

@@ -1,6 +1,5 @@
 //! Settings for the `flake8-pytest-style` plugin.
 
-use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
 use ruff_macros::{CacheKey, ConfigurationOptions};
@@ -21,14 +20,13 @@ fn default_broad_exceptions() -> Vec<String> {
     .to_vec()
 }
 
-#[derive(
-    Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions, JsonSchema,
-)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions)]
 #[serde(
     deny_unknown_fields,
     rename_all = "kebab-case",
     rename = "Flake8PytestStyleOptions"
 )]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Options {
     #[option(
         default = "true",

crates/ruff/src/rules/flake8_pytest_style/types.rs

@@ -1,11 +1,9 @@
+use ruff_macros::CacheKey;
+use serde::{Deserialize, Serialize};
 use std::fmt::{Display, Formatter};
 
-use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
-
-use ruff_macros::CacheKey;
-
-#[derive(Clone, Copy, Debug, CacheKey, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Copy, Debug, CacheKey, PartialEq, Eq, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum ParametrizeNameType {
     #[serde(rename = "csv")]
     Csv,
@@ -31,7 +29,8 @@ impl Display for ParametrizeNameType {
     }
 }
 
-#[derive(Clone, Copy, Debug, CacheKey, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Copy, Debug, CacheKey, PartialEq, Eq, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum ParametrizeValuesType {
     #[serde(rename = "tuple")]
     Tuple,
@@ -54,7 +53,8 @@ impl Display for ParametrizeValuesType {
     }
 }
 
-#[derive(Clone, Copy, Debug, CacheKey, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Copy, Debug, CacheKey, PartialEq, Eq, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum ParametrizeValuesRowType {
     #[serde(rename = "tuple")]
     Tuple,

crates/ruff/src/rules/flake8_quotes/settings.rs

@@ -1,12 +1,12 @@
 //! Settings for the `flake8-quotes` plugin.
 
-use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
 use ruff_macros::{CacheKey, ConfigurationOptions};
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, CacheKey, JsonSchema)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, CacheKey)]
 #[serde(deny_unknown_fields, rename_all = "kebab-case")]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum Quote {
     /// Use single quotes.
     Single,
@@ -20,14 +20,13 @@ impl Default for Quote {
     }
 }
 
-#[derive(
-    Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions, JsonSchema,
-)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions)]
 #[serde(
     deny_unknown_fields,
     rename_all = "kebab-case",
     rename = "Flake8QuotesOptions"
 )]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Options {
     #[option(
         default = r#""double""#,

crates/ruff/src/rules/flake8_self/settings.rs

@@ -1,6 +1,5 @@
 //! Settings for the `flake8-self` plugin.
 
-use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
 use ruff_macros::{CacheKey, ConfigurationOptions};
@@ -9,14 +8,13 @@ use ruff_macros::{CacheKey, ConfigurationOptions};
 // prevent conflicts with field names.
 const IGNORE_NAMES: [&str; 5] = ["_make", "_asdict", "_replace", "_fields", "_field_defaults"];
 
-#[derive(
-    Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions, JsonSchema,
-)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions)]
 #[serde(
     deny_unknown_fields,
     rename_all = "kebab-case",
     rename = "Flake8SelfOptions"
 )]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Options {
     #[option(
         default = r#"["_make", "_asdict", "_replace", "_fields", "_field_defaults"]"#,

crates/ruff/src/rules/flake8_tidy_imports/banned_api.rs

@@ -1,6 +1,5 @@
 use rustc_hash::FxHashMap;
 use rustpython_parser::ast::{Expr, Located};
-use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
 use crate::checkers::ast::Checker;
@@ -10,8 +9,9 @@ use ruff_python_ast::call_path::from_qualified_name;
 
 pub type Settings = FxHashMap<String, ApiBan>;
 
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, CacheKey, JsonSchema)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, CacheKey)]
 #[serde(deny_unknown_fields, rename_all = "kebab-case")]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct ApiBan {
     /// The message to display when the API is used.
     pub msg: String,

crates/ruff/src/rules/flake8_tidy_imports/options.rs

@@ -1,7 +1,6 @@
 //! Settings for the `flake8-tidy-imports` plugin.
 
 use rustc_hash::FxHashMap;
-use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
 use ruff_macros::ConfigurationOptions;
@@ -10,14 +9,13 @@ use super::banned_api::ApiBan;
 use super::relative_imports::Strictness;
 use super::Settings;
 
-#[derive(
-    Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions, JsonSchema,
-)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions)]
 #[serde(
     deny_unknown_fields,
     rename_all = "kebab-case",
     rename = "Flake8TidyImportsOptions"
 )]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Options {
     #[option(
         default = r#""parents""#,

crates/ruff/src/rules/flake8_tidy_imports/relative_imports.rs

@@ -1,5 +1,4 @@
 use rustpython_parser::ast::{Stmt, StmtKind};
-use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
 use ruff_diagnostics::{AutofixKind, Diagnostic, Edit, Fix, Violation};
@@ -13,10 +12,9 @@ use crate::registry::AsRule;
 
 pub type Settings = Strictness;
 
-#[derive(
-    Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, CacheKey, JsonSchema, Default,
-)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, CacheKey, Default)]
 #[serde(deny_unknown_fields, rename_all = "kebab-case")]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum Strictness {
     /// Ban imports that extend into the parent module or beyond.
     #[default]

crates/ruff/src/rules/flake8_type_checking/settings.rs

@@ -1,18 +1,16 @@
 //! Settings for the `flake8-type-checking` plugin.
 
-use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
 use ruff_macros::{CacheKey, ConfigurationOptions};
 
-#[derive(
-    Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions, JsonSchema,
-)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions)]
 #[serde(
     deny_unknown_fields,
     rename_all = "kebab-case",
     rename = "Flake8TypeCheckingOptions"
 )]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Options {
     #[option(
         default = "false",

crates/ruff/src/rules/flake8_unused_arguments/settings.rs

@@ -1,18 +1,16 @@
 //! Settings for the `flake8-unused-arguments` plugin.
 
-use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
 use ruff_macros::{CacheKey, ConfigurationOptions};
 
-#[derive(
-    Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions, JsonSchema,
-)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions)]
 #[serde(
     deny_unknown_fields,
     rename_all = "kebab-case",
     rename = "Flake8UnusedArgumentsOptions"
 )]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Options {
     #[option(
         default = "false",

crates/ruff/src/rules/isort/categorize.rs

@@ -4,7 +4,6 @@ use std::{fs, iter};
 
 use log::debug;
 use rustc_hash::FxHashMap;
-use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use strum_macros::EnumIter;
 
@@ -27,11 +26,11 @@ use super::types::{ImportBlock, Importable};
     Hash,
     Serialize,
     Deserialize,
-    JsonSchema,
     CacheKey,
     EnumIter,
 )]
 #[serde(deny_unknown_fields, rename_all = "kebab-case")]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum ImportType {
     Future,
     StandardLibrary,
@@ -40,10 +39,9 @@ pub enum ImportType {
     LocalFolder,
 }
 
-#[derive(
-    Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash, Serialize, Deserialize, JsonSchema, CacheKey,
-)]
+#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash, Serialize, Deserialize, CacheKey)]
 #[serde(untagged)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum ImportSection {
     Known(ImportType),
     UserDefined(String),

crates/ruff/src/rules/isort/settings.rs

@@ -4,7 +4,6 @@ use std::collections::BTreeSet;
 use std::hash::BuildHasherDefault;
 
 use rustc_hash::{FxHashMap, FxHashSet};
-use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use strum::IntoEnumIterator;
 
@@ -16,8 +15,9 @@ use crate::warn_user_once;
 
 use super::categorize::ImportSection;
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, CacheKey, JsonSchema)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, CacheKey)]
 #[serde(deny_unknown_fields, rename_all = "kebab-case")]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum RelativeImportsOrder {
     /// Place "closer" imports (fewer `.` characters, most local) before
     /// "further" imports (more `.` characters, least local).
@@ -33,14 +33,13 @@ impl Default for RelativeImportsOrder {
     }
 }
 
-#[derive(
-    Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions, JsonSchema,
-)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions)]
 #[serde(
     deny_unknown_fields,
     rename_all = "kebab-case",
     rename = "IsortOptions"
 )]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Options {
     #[option(
         default = r#"false"#,

crates/ruff/src/rules/mccabe/settings.rs

@@ -1,18 +1,15 @@
 //! Settings for the `mccabe` plugin.
 
-use schemars::JsonSchema;
+use ruff_macros::{CacheKey, ConfigurationOptions};
 use serde::{Deserialize, Serialize};
 
-use ruff_macros::{CacheKey, ConfigurationOptions};
-
-#[derive(
-    Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions, JsonSchema,
-)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions)]
 #[serde(
     deny_unknown_fields,
     rename_all = "kebab-case",
     rename = "McCabeOptions"
 )]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Options {
     #[option(
         default = "10",

crates/ruff/src/rules/pep8_naming/settings.rs

@@ -1,9 +1,7 @@
 //! Settings for the `pep8-naming` plugin.
 
-use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
-
 use ruff_macros::{CacheKey, ConfigurationOptions};
+use serde::{Deserialize, Serialize};
 
 const IGNORE_NAMES: [&str; 12] = [
     "setUp",
@@ -20,14 +18,13 @@ const IGNORE_NAMES: [&str; 12] = [
     "maxDiff",
 ];
 
-#[derive(
-    Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions, JsonSchema,
-)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions)]
 #[serde(
     deny_unknown_fields,
     rename_all = "kebab-case",
     rename = "Pep8NamingOptions"
 )]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Options {
     #[option(
         default = r#"["setUp", "tearDown", "setUpClass", "tearDownClass", "setUpModule", "tearDownModule", "asyncSetUp", "asyncTearDown", "setUpTestData", "failureException", "longMessage", "maxDiff"]"#,

crates/ruff/src/rules/pycodestyle/settings.rs

@@ -1,14 +1,11 @@
 //! Settings for the `pycodestyle` plugin.
 
-use schemars::JsonSchema;
+use ruff_macros::{CacheKey, ConfigurationOptions};
 use serde::{Deserialize, Serialize};
 
-use ruff_macros::{CacheKey, ConfigurationOptions};
-
-#[derive(
-    Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions, JsonSchema,
-)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions)]
 #[serde(deny_unknown_fields, rename_all = "kebab-case", rename = "Pycodestyle")]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Options {
     #[option(
         default = "None",

crates/ruff/src/rules/pydocstyle/settings.rs

@@ -1,16 +1,13 @@
 //! Settings for the `pydocstyle` plugin.
 
+use crate::registry::Rule;
+use ruff_macros::{CacheKey, ConfigurationOptions};
+use serde::{Deserialize, Serialize};
 use std::collections::BTreeSet;
 
-use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
-
-use ruff_macros::{CacheKey, ConfigurationOptions};
-
-use crate::registry::Rule;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, JsonSchema, CacheKey)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, CacheKey)]
 #[serde(deny_unknown_fields, rename_all = "kebab-case")]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum Convention {
     /// Use Google-style docstrings.
     Google,
@@ -71,10 +68,9 @@ impl Convention {
     }
 }
 
-#[derive(
-    Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions, JsonSchema,
-)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions)]
 #[serde(deny_unknown_fields, rename_all = "kebab-case", rename = "Pydocstyle")]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Options {
     #[option(
         default = r#"None"#,

crates/ruff/src/rules/pylint/settings.rs

@@ -1,14 +1,13 @@
 //! Settings for the `pylint` plugin.
 
 use anyhow::anyhow;
+use ruff_macros::{CacheKey, ConfigurationOptions};
 use rustpython_parser::ast::Constant;
-use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
-use ruff_macros::{CacheKey, ConfigurationOptions};
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, CacheKey, JsonSchema)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, CacheKey)]
 #[serde(deny_unknown_fields, rename_all = "kebab-case")]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum ConstantType {
     Bytes,
     Complex,
@@ -36,14 +35,13 @@ impl TryFrom<&Constant> for ConstantType {
     }
 }
 
-#[derive(
-    Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions, JsonSchema,
-)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions)]
 #[serde(
     deny_unknown_fields,
     rename_all = "kebab-case",
     rename = "PylintOptions"
 )]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Options {
     #[option(
         default = r#"["str", "bytes"]"#,

crates/ruff/src/rules/pyupgrade/settings.rs

@@ -1,18 +1,15 @@
 //! Settings for the `pyupgrade` plugin.
 
-use schemars::JsonSchema;
+use ruff_macros::{CacheKey, ConfigurationOptions};
 use serde::{Deserialize, Serialize};
 
-use ruff_macros::{CacheKey, ConfigurationOptions};
-
-#[derive(
-    Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions, JsonSchema,
-)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions)]
 #[serde(
     deny_unknown_fields,
     rename_all = "kebab-case",
     rename = "PyUpgradeOptions"
 )]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Options {
     #[option(
         default = r#"false"#,

crates/ruff/src/settings/options.rs

@@ -1,10 +1,5 @@
 //! Options that the user can provide via pyproject.toml.
 
-use ruff_macros::ConfigurationOptions;
-use rustc_hash::FxHashMap;
-use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
-
 use crate::rule_selector::RuleSelector;
 use crate::rules::{
     flake8_annotations, flake8_bandit, flake8_bugbear, flake8_builtins, flake8_comprehensions,
@@ -14,11 +9,13 @@ use crate::rules::{
     pyupgrade,
 };
 use crate::settings::types::{PythonVersion, SerializationFormat, Version};
+use ruff_macros::ConfigurationOptions;
+use rustc_hash::FxHashMap;
+use serde::{Deserialize, Serialize};
 
-#[derive(
-    Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions, JsonSchema,
-)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions)]
 #[serde(deny_unknown_fields, rename_all = "kebab-case")]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Options {
     #[option(
         default = r#"[]"#,
@@ -164,7 +161,7 @@ pub struct Options {
     ///
     /// This option has been **deprecated** in favor of `ignore`
     /// since its usage is now interchangeable with `ignore`.
-    #[schemars(skip)]
+    #[cfg_attr(feature = "schemars", schemars(skip))]
     pub extend_ignore: Option<Vec<RuleSelector>>,
     #[option(
         default = "[]",

crates/ruff/src/settings/types.rs

@@ -1,14 +1,12 @@
+use anyhow::{bail, Result};
+use globset::{Glob, GlobSet, GlobSetBuilder};
+use pep440_rs::{Version as Pep440Version, VersionSpecifiers};
+use serde::{de, Deserialize, Deserializer, Serialize};
 use std::hash::{Hash, Hasher};
 use std::ops::Deref;
 use std::path::{Path, PathBuf};
 use std::str::FromStr;
 use std::string::ToString;
-
-use anyhow::{bail, Result};
-use globset::{Glob, GlobSet, GlobSetBuilder};
-use pep440_rs::{Version as Pep440Version, VersionSpecifiers};
-use schemars::JsonSchema;
-use serde::{de, Deserialize, Deserializer, Serialize};
 use strum::IntoEnumIterator;
 use strum_macros::EnumIter;
 
@@ -20,21 +18,11 @@ use crate::registry::RuleSet;
 use crate::rule_selector::RuleSelector;
 
 #[derive(
-    Clone,
-    Copy,
-    Debug,
-    PartialOrd,
-    Ord,
-    PartialEq,
-    Eq,
-    Serialize,
-    Deserialize,
-    JsonSchema,
-    CacheKey,
-    EnumIter,
+    Clone, Copy, Debug, PartialOrd, Ord, PartialEq, Eq, Serialize, Deserialize, CacheKey, EnumIter,
 )]
 #[cfg_attr(feature = "clap", derive(clap::ValueEnum))]
 #[serde(rename_all = "lowercase")]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum PythonVersion {
     Py37,
     Py38,
@@ -218,9 +206,10 @@ impl FromStr for PatternPrefixPair {
     }
 }
 
-#[derive(Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Debug, JsonSchema, Hash)]
+#[derive(Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Debug, Hash)]
 #[cfg_attr(feature = "clap", derive(clap::ValueEnum))]
 #[serde(rename_all = "kebab-case")]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum SerializationFormat {
     Text,
     Json,
@@ -238,8 +227,9 @@ impl Default for SerializationFormat {
     }
 }
 
-#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Hash)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Hash)]
 #[serde(try_from = "String")]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Version(String);
 
 impl TryFrom<String> for Version {

crates/ruff_dev/Cargo.toml

@@ -6,7 +6,7 @@ edition = { workspace = true }
 rust-version = { workspace = true }
 
 [dependencies]
-ruff = { path = "../ruff" }
+ruff = { path = "../ruff", features = ["schemars"] }
 ruff_cli = { path = "../ruff_cli" }
 ruff_diagnostics = { path = "../ruff_diagnostics" }
 

crates/ruff_python_ast/Cargo.toml

@@ -9,7 +9,7 @@ rust-version = { workspace = true }
 
 [dependencies]
 ruff_rustpython = { path = "../ruff_rustpython" }
-ruff_text_size = { workspace = true, features = ["serde"] }
+ruff_text_size = { workspace = true }
 
 anyhow = { workspace = true }
 bitflags = { workspace = true }
@@ -26,3 +26,6 @@ rustpython-common = { workspace = true }
 rustpython-parser = { workspace = true }
 serde = { workspace = true, optional = true }
 smallvec = { workspace = true }
+
+[features]
+serde = ["dep:serde", "ruff_text_size/serde"]