feat(rome_service): auto generate configuration for rules

CONTRIBUTING.md

@@ -97,6 +97,7 @@ It's strongly advised to **run this command before committing new changes**.
 #### `cargo codegen analyzer`
 
 This command will detect linter rules declared in the `analyzers` and `assists` directories in `rome_analyze`, regenerate the index modules `analyzers.rs` and `assists.rs` to import these files, and update the registry builder function in `registry.rs` to include all these rules.
+It will also regenerate the configuration of the rules.
 
 #### `cargo coverage`
 

crates/rome_cli/src/traversal.rs

@@ -226,7 +226,7 @@ fn print_messages_to_console(
                     }
                 }
 
-                if !mode.is_ci() {
+                if !mode.is_ci() && not_printed_diagnostics > 0 {
                     console.log(markup! {
                         <Warn>"The number of diagnostics exceeds the number allowed by Rome."</Warn>
                         <Info>"Diagnostics not shown: "</Info><Emphasis>{not_printed_diagnostics}</Emphasis><Info>"."</Info>

crates/rome_cli/tests/configs.rs

@@ -36,7 +36,14 @@ pub const CONFIG_ALL_FIELDS: &str = r#"{
     "lineWidth": 80
   },
   "linter": {
-    "enabled": true
+    "enabled": true,
+    "globals": ["$"],
+    "rules": {
+        "js": {
+            "noDeadCode": "off",
+            "useSimplifiedLogicExpression": "warn"
+        }
+    }
   },
   "javascript": {
     "formatter": {
@@ -58,3 +65,18 @@ pub const CONFIG_LINTER_DISABLED: &str = r#"{
     "enabled": false
   }
 }"#;
+
+pub const CONFIG_LINTER_WRONG_RULE: &str = r#"{
+  "root": true,
+  "linter": {
+    "enabled": true,
+    "rules": {
+        "js": {
+            "foo_rule": "off"
+        },
+        "jsx": {
+            "what_the_hell": "off"
+        }
+    }
+  }
+}"#;

crates/rome_cli/tests/main.rs

@@ -851,7 +851,9 @@ mod init {
 }
 
 mod configuration {
-    use crate::configs::{CONFIG_ALL_FIELDS, CONFIG_BAD_LINE_WIDTH, CONFIG_ROOT_FALSE};
+    use crate::configs::{
+        CONFIG_ALL_FIELDS, CONFIG_BAD_LINE_WIDTH, CONFIG_LINTER_WRONG_RULE, CONFIG_ROOT_FALSE,
+    };
     use pico_args::Arguments;
     use rome_cli::{run_cli, CliSession};
     use rome_console::BufferConsole;
@@ -929,4 +931,27 @@ mod configuration {
             _ => panic!("expected an error, but found none"),
         }
     }
+
+    #[test]
+    fn incorrect_rule_name() {
+        let mut fs = MemoryFileSystem::default();
+
+        let file_path = Path::new("rome.json");
+        fs.insert(file_path.into(), CONFIG_LINTER_WRONG_RULE.as_bytes());
+
+        let result = run_cli(CliSession {
+            app: App::with_filesystem_and_console(
+                DynRef::Borrowed(&mut fs),
+                DynRef::Owned(Box::new(BufferConsole::default())),
+            ),
+            args: Arguments::from_vec(vec![OsString::from("check"), OsString::from("file.js")]),
+        });
+
+        match result {
+            Err(error) => {
+                assert!(error.to_string().contains("unknown field `foo_rule`"),)
+            }
+            _ => panic!("expected an error, but found none"),
+        }
+    }
 }

crates/rome_service/src/configuration/linter/mod.rs

@@ -0,0 +1,60 @@
+#[rustfmt::skip]
+mod rules;
+
+pub use crate::configuration::linter::rules::Rules;
+use crate::settings::LinterSettings;
+use serde::{Deserialize, Serialize};
+
+#[derive(Deserialize, Serialize, Debug, Eq, PartialEq)]
+#[serde(rename_all = "camelCase", default)]
+pub struct LinterConfiguration {
+    /// if `false`, it disables the feature. `true` by default
+    pub enabled: bool,
+
+    /// A list of global bindings that should be ignored by the analyzers
+    ///
+    /// If defined here, they should not emit diagnostics.
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub globals: Vec<String>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub rules: Option<Rules>,
+}
+
+impl Default for LinterConfiguration {
+    fn default() -> Self {
+        Self {
+            enabled: true,
+            globals: vec![],
+            rules: None,
+        }
+    }
+}
+
+impl From<&LinterConfiguration> for LinterSettings {
+    fn from(conf: &LinterConfiguration) -> Self {
+        Self {
+            enabled: conf.enabled,
+            globals: conf.globals.clone(),
+            rules: conf.rules.clone(),
+        }
+    }
+}
+
+#[derive(Deserialize, Serialize, Debug, Eq, PartialEq, Clone)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub enum RuleConfiguration {
+    Warn,
+    Error,
+    Off,
+}
+impl RuleConfiguration {
+    pub fn is_err(&self) -> bool {
+        matches!(self, Self::Error)
+    }
+}
+impl Default for RuleConfiguration {
+    fn default() -> Self {
+        Self::Error
+    }
+}

crates/rome_service/src/configuration/linter/rules.rs

@@ -0,0 +1,94 @@
+//! Generated file, do not edit by hand, see `xtask/codegen`
+
+use crate::RuleConfiguration;
+use serde::{Deserialize, Serialize};
+#[derive(Deserialize, Serialize, Debug, Eq, PartialEq, Clone)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub struct Rules {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub js: Option<JsRules>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub jsx: Option<JsxRules>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub regex: Option<RegexRules>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ts: Option<TsRules>,
+}
+impl Default for Rules {
+    fn default() -> Self {
+        Self {
+            js: Some(JsRules::default()),
+            jsx: Some(JsxRules::default()),
+            regex: Some(RegexRules::default()),
+            ts: Some(TsRules::default()),
+        }
+    }
+}
+#[derive(Deserialize, Default, Serialize, Debug, Eq, PartialEq, Clone)]
+#[serde(rename_all = "camelCase", default, deny_unknown_fields)]
+pub struct JsRules {
+    #[serde(skip_serializing_if = "RuleConfiguration::is_err")]
+    pub no_arguments: RuleConfiguration,
+    #[serde(skip_serializing_if = "RuleConfiguration::is_err")]
+    pub no_async_promise_executor: RuleConfiguration,
+    #[serde(skip_serializing_if = "RuleConfiguration::is_err")]
+    pub no_catch_assign: RuleConfiguration,
+    #[serde(skip_serializing_if = "RuleConfiguration::is_err")]
+    pub no_compare_neg_zero: RuleConfiguration,
+    #[serde(skip_serializing_if = "RuleConfiguration::is_err")]
+    pub no_dead_code: RuleConfiguration,
+    #[serde(skip_serializing_if = "RuleConfiguration::is_err")]
+    pub no_debugger: RuleConfiguration,
+    #[serde(skip_serializing_if = "RuleConfiguration::is_err")]
+    pub no_delete: RuleConfiguration,
+    #[serde(skip_serializing_if = "RuleConfiguration::is_err")]
+    pub no_double_equals: RuleConfiguration,
+    #[serde(skip_serializing_if = "RuleConfiguration::is_err")]
+    pub no_empty_pattern: RuleConfiguration,
+    #[serde(skip_serializing_if = "RuleConfiguration::is_err")]
+    pub no_label_var: RuleConfiguration,
+    #[serde(skip_serializing_if = "RuleConfiguration::is_err")]
+    pub no_negation_else: RuleConfiguration,
+    #[serde(skip_serializing_if = "RuleConfiguration::is_err")]
+    pub no_sparse_array: RuleConfiguration,
+    #[serde(skip_serializing_if = "RuleConfiguration::is_err")]
+    pub no_unnecessary_continue: RuleConfiguration,
+    #[serde(skip_serializing_if = "RuleConfiguration::is_err")]
+    pub no_unsafe_negation: RuleConfiguration,
+    #[serde(skip_serializing_if = "RuleConfiguration::is_err")]
+    pub no_unused_template_literal: RuleConfiguration,
+    #[serde(skip_serializing_if = "RuleConfiguration::is_err")]
+    pub use_block_statements: RuleConfiguration,
+    #[serde(skip_serializing_if = "RuleConfiguration::is_err")]
+    pub use_simplified_logic_expression: RuleConfiguration,
+    #[serde(skip_serializing_if = "RuleConfiguration::is_err")]
+    pub use_single_case_statement: RuleConfiguration,
+    #[serde(skip_serializing_if = "RuleConfiguration::is_err")]
+    pub use_single_var_declarator: RuleConfiguration,
+    #[serde(skip_serializing_if = "RuleConfiguration::is_err")]
+    pub use_valid_typeof: RuleConfiguration,
+    #[serde(skip_serializing_if = "RuleConfiguration::is_err")]
+    pub use_while: RuleConfiguration,
+}
+#[derive(Deserialize, Default, Serialize, Debug, Eq, PartialEq, Clone)]
+#[serde(rename_all = "camelCase", default, deny_unknown_fields)]
+pub struct JsxRules {
+    #[serde(skip_serializing_if = "RuleConfiguration::is_err")]
+    pub no_comment_text: RuleConfiguration,
+    #[serde(skip_serializing_if = "RuleConfiguration::is_err")]
+    pub no_implicit_boolean: RuleConfiguration,
+    #[serde(skip_serializing_if = "RuleConfiguration::is_err")]
+    pub use_self_closing_elements: RuleConfiguration,
+}
+#[derive(Deserialize, Default, Serialize, Debug, Eq, PartialEq, Clone)]
+#[serde(rename_all = "camelCase", default, deny_unknown_fields)]
+pub struct RegexRules {
+    #[serde(skip_serializing_if = "RuleConfiguration::is_err")]
+    pub no_multiple_spaces_in_regular_expression_literals: RuleConfiguration,
+}
+#[derive(Deserialize, Default, Serialize, Debug, Eq, PartialEq, Clone)]
+#[serde(rename_all = "camelCase", default, deny_unknown_fields)]
+pub struct TsRules {
+    #[serde(skip_serializing_if = "RuleConfiguration::is_err")]
+    pub use_shorthand_array_type: RuleConfiguration,
+}

crates/rome_service/src/configuration/mod.rs

@@ -15,10 +15,13 @@ use std::path::PathBuf;
 
 mod formatter;
 mod javascript;
-mod linter;
+pub mod linter;
+
+pub use linter::{RuleConfiguration, Rules};
 
 /// The configuration that is contained inside the file `rome.json`
 #[derive(Debug, Eq, PartialEq, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
 pub struct Configuration {
     /// One root file should exist. Useful when `extends` comes into play.
     ///

crates/rome_service/src/lib.rs

@@ -13,6 +13,7 @@ pub mod workspace;
 
 pub use crate::configuration::{
     create_config, load_config, Configuration, ConfigurationError, ConfigurationType,
+    RuleConfiguration, Rules,
 };
 pub use crate::file_handlers::JsFormatSettings;
 pub use crate::workspace::Workspace;