feat(rome_cli): Add a new option --config to set the path to rome.json

crates/rome_cli/src/commands/help.rs

@@ -37,6 +37,7 @@ const CHECK: Markup = markup! {
     "<Dim>"--apply"</Dim>"                       Apply safe fixes
     "<Dim>"--apply-unsafe"</Dim>"                Apply safe and unsafe fixes
     "<Dim>"--max-diagnostics"</Dim>"             Cap the amount of diagnostics displayed (default: 20)
+    "<Dim>"--config"</Dim>"                      Set the filesystem path to the directory of the rome.json configuration file
     "<Dim>"--verbose"</Dim>"                     Print additional verbose advices on diagnostics
 "
 };
@@ -65,6 +66,7 @@ const CI: Markup = markup! {
     "<Dim>"--formatter-enabled"</Dim>"                      Allow to enable or disable the formatter check. (default: true)
     "<Dim>"--linter-enabled"</Dim>"                         Allow to enable or disable the linter check. (default: true)
     "<Dim>"--max-diagnostics"</Dim>"                        Cap the amount of diagnostics displayed (default: 50)
+    "<Dim>"--config"</Dim>"                                 Set the filesystem path to the directory of the rome.json configuration file
     "<Dim>"--verbose"</Dim>"                                Print additional verbose advices on diagnostics"
     {FORMAT_OPTIONS}
 };
@@ -81,6 +83,7 @@ const FORMAT: Markup = markup! {
     "<Dim>"--write"</Dim>"                                  Edit the files in place (beware!) instead of printing the diff to the console
     "<Dim>"--skip-errors"</Dim>"                            Skip over files containing syntax errors instead of emitting an error diagnostic.
     "<Dim>"--max-diagnostics"</Dim>"                        Cap the amount of diagnostics displayed (default: 50)
+    "<Dim>"--config"</Dim>"                                 Set the filesystem path to the directory of the rome.json configuration file
     "<Dim>"--verbose"</Dim>"                                Print additional verbose advices on diagnostics"
     {FORMAT_OPTIONS}
    ""<Dim>"--stdin-file-path <string>"</Dim>"               A file name with its extension to pass when reading from standard in, e.g. echo 'let a;' | rome format --stdin-file-path file.js

crates/rome_cli/src/commands/rage.rs

@@ -163,7 +163,7 @@ impl Display for RageConfiguration<'_, '_> {
     fn fmt(&self, fmt: &mut Formatter) -> io::Result<()> {
         Section("Rome Configuration").fmt(fmt)?;
 
-        match load_config(self.0, None) {
+        match load_config(self.0, None, false) {
             Ok(None) => KeyValuePair("Status", markup!(<Dim>"unset"</Dim>)).fmt(fmt)?,
             Ok(Some(configuration)) => {
                 markup! (

crates/rome_cli/src/configuration.rs

@@ -1,21 +1,30 @@
+use std::path::PathBuf;
+
 use rome_service::{load_config, Configuration};
 
 use crate::{CliDiagnostic, CliSession};
 
 /// Load the configuration for this session of the CLI, merging the content of
 /// the `rome.json` file if it exists on disk with common command line options
 pub(crate) fn load_configuration(session: &mut CliSession) -> Result<Configuration, CliDiagnostic> {
-    let mut configuration = load_config(&session.app.fs, None)?.unwrap_or_default();
+    let config_path: Option<PathBuf> = session
+        .args
+        .opt_value_from_str("--config")
+        .map_err(|source| CliDiagnostic::parse_error("--config", source))?;
+
+    let is_config_path = config_path.is_some();
+
+    let mut config = load_config(&session.app.fs, config_path, is_config_path)?.unwrap_or_default();
 
     let files_max_size = session
         .args
         .opt_value_from_str("--files-max-size")
         .map_err(|source| CliDiagnostic::parse_error("--files-max-size", source))?;
 
     if let Some(files_max_size) = files_max_size {
-        let files = configuration.files.get_or_insert_with(Default::default);
+        let files = config.files.get_or_insert_with(Default::default);
         files.max_size = Some(files_max_size);
     }
 
-    Ok(configuration)
+    Ok(config)
 }

crates/rome_cli/tests/commands/format.rs

@@ -44,6 +44,15 @@ const APPLY_TRAILING_COMMA_AFTER: &str = r#"const a = [
 ];
 "#;
 
+const DEFAULT_CONFIGURATION_BEFORE: &str = r#"function f() {
+    return { a, b }
+  }"#;
+
+const DEFAULT_CONFIGURATION_AFTER: &str = "function f() {
+      return { a, b };
+}
+";
+
 const CUSTOM_CONFIGURATION_BEFORE: &str = r#"function f() {
   return { a, b }
 }"#;
@@ -236,6 +245,87 @@ fn lint_warning() {
     ));
 }
 
+#[test]
+fn custom_config_file_path() {
+    let mut fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    let config_path = Path::new("/test/rome.json");
+    fs.insert(config_path.into(), CONFIG_FORMAT.as_bytes());
+
+    let file_path = Path::new("file.js");
+    fs.insert(file_path.into(), DEFAULT_CONFIGURATION_BEFORE.as_bytes());
+
+    let mut config_path = PathBuf::from(config_path);
+    config_path.pop();
+
+    let result = run_cli(
+        DynRef::Borrowed(&mut fs),
+        &mut console,
+        Arguments::from_vec(vec![
+            OsString::from("format"),
+            OsString::from("--config"),
+            OsString::from(config_path),
+            OsString::from("--write"),
+            file_path.as_os_str().into(),
+        ]),
+    );
+
+    assert!(result.is_ok(), "run_cli returned {result:?}");
+
+    let mut file = fs
+        .open(file_path)
+        .expect("formatting target file was removed by the CLI");
+
+    let mut content = String::new();
+    file.read_to_string(&mut content)
+        .expect("failed to read file from memory FS");
+
+    assert_eq!(content, DEFAULT_CONFIGURATION_AFTER);
+
+    drop(file);
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "custom_config_file_path",
+        fs,
+        console,
+        result,
+    ));
+}
+
+// Should throw an error when an invalid configuration path is specified
+#[test]
+fn invalid_config_file_path() {
+    let mut fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    let config_path = Path::new("/test");
+    let file_path = Path::new("file.js");
+    fs.insert(file_path.into(), *b"content");
+
+    let result = run_cli(
+        DynRef::Borrowed(&mut fs),
+        &mut console,
+        Arguments::from_vec(vec![
+            OsString::from("format"),
+            OsString::from("--config"),
+            OsString::from(config_path),
+            OsString::from("--write"),
+            file_path.as_os_str().into(),
+        ]),
+    );
+
+    assert!(result.is_err(), "run_cli returned {result:?}");
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "invalid_config_file_path",
+        fs,
+        console,
+        result,
+    ));
+}
+
 #[test]
 fn applies_custom_configuration() {
     let mut fs = MemoryFileSystem::default();

crates/rome_cli/tests/snapshots/main_commands_format/custom_config_file_path.snap

@@ -0,0 +1,35 @@
+---
+source: crates/rome_cli/tests/snap_test.rs
+assertion_line: 335
+expression: content
+---
+## `/test/rome.json`
+
+```json
+{
+  "formatter": {
+    "enabled": true,
+    "lineWidth": 160,
+    "indentStyle": "space",
+    "indentSize": 6
+  }
+}
+
+```
+
+## `file.js`
+
+```js
+function f() {
+      return { a, b };
+}
+
+```
+
+# Emitted Messages
+
+```block
+Formatted 1 file(s) in <TIME>
+```
+
+

crates/rome_cli/tests/snapshots/main_commands_format/invalid_config_file_path.snap

@@ -0,0 +1,23 @@
+---
+source: crates/rome_cli/tests/snap_test.rs
+assertion_line: 335
+expression: content
+---
+## `file.js`
+
+```js
+content
+```
+
+# Termination Message
+
+```block
+/test/rome.json internalError/fs ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Rome couldn't read the following file, maybe for permissions reasons or it doesn't exists: /test/rome.json
+  
+
+
+```
+
+

crates/rome_lsp/src/session.rs

@@ -366,7 +366,7 @@ impl Session {
     pub(crate) async fn load_workspace_settings(&self) {
         let base_path = self.base_path();
 
-        let status = match load_config(&self.fs, base_path) {
+        let status = match load_config(&self.fs, base_path, false) {
             Ok(Some(configuration)) => {
                 info!("Loaded workspace settings: {configuration:#?}");
 

crates/rome_service/src/configuration/mod.rs

@@ -128,50 +128,51 @@ impl FilesConfiguration {
 pub fn load_config(
     file_system: &DynRef<dyn FileSystem>,
     base_path: Option<PathBuf>,
+    show_error: bool,
 ) -> Result<Option<Configuration>, WorkspaceError> {
     let config_name = file_system.config_name();
-    let configuration_path = if let Some(base_path) = base_path {
+    let config_path = if let Some(ref base_path) = base_path {
         base_path.join(config_name)
     } else {
         PathBuf::from(config_name)
     };
     info!(
-        "Attempting to load the configuration file at path {:?}",
-        configuration_path
+        "Attempting to read the configuration file from {:?}",
+        config_path
     );
     let options = OpenOptions::default().read(true);
-    let file = file_system.open_with_options(&configuration_path, options);
+    let file = file_system.open_with_options(&config_path, options);
     match file {
         Ok(mut file) => {
             let mut buffer = String::new();
             file.read_to_string(&mut buffer).map_err(|_| {
-                WorkspaceError::cant_read_file(format!("{}", configuration_path.display()))
+                WorkspaceError::cant_read_file(format!("{}", config_path.display()))
             })?;
 
-            let configuration: Configuration = serde_json::from_str(&buffer).map_err(|err| {
+            let config: Configuration = serde_json::from_str(&buffer).map_err(|err| {
                 WorkspaceError::Configuration(ConfigurationDiagnostic::new_deserialization_error(
                     err.to_string(),
                     from_serde_error_to_range(&err, &buffer),
                 ))
             })?;
 
-            Ok(Some(configuration))
+            Ok(Some(config))
         }
         Err(err) => {
-            // We throw an error only when the error is found.
-            // In case we don't fine the file, we swallow the error and we continue; not having
-            // a file should not be a cause of error (for now)
-            if err.kind() != ErrorKind::NotFound {
+            // We skip the error when the configuration file is not found
+            // and the base path is not explicitly set; not having a configuration
+            // file is not a cause of error
+            if show_error || err.kind() != ErrorKind::NotFound {
                 return Err(WorkspaceError::cant_read_file(format!(
                     "{}",
-                    configuration_path.display()
+                    config_path.display()
                 )));
             }
             error!(
-                "Could not find the file configuration at {:?}",
-                configuration_path.display()
+                "Could not read the configuration file from {:?}, reason:\n {}",
+                config_path.display(),
+                err
             );
-            error!("Reason: {:?}", err);
             Ok(None)
         }
     }

website/src/pages/cli.mdx

@@ -59,6 +59,12 @@ Set the formatting mode for markup: `off` prints everything as plain text,
 `force` forces the formatting of markup using ANSI even if the console output
 is determined to be incompatible
 
+### `--config`
+
+Set the filesystem path to the directory of the rome.json configuration file.
+This is optional. Rome will try to read a rome.json configuration file from the 
+current working directory by default.
+
 ### `--use-server`
 
 Connect to a running instance of the Rome daemon server