refactor(cli): do not emit warnings for protected ignored files (biom…

…ejs#1552)

CHANGELOG.md

@@ -14,11 +14,26 @@ Read our [guidelines for writing a good changelog entry](https://github.com/biom
 
 ### CLI
 
+### Bug fixes
+
 - Fix [#1512](https://github.com/biomejs/biome/issues/1512) by skipping verbose diagnostics from the count. Contributed by @ematipico
-- Don't handle CSS files, the formatter isn't ready yet. Contributed by @ematipico
+
+- Don't emit verbose warnings when a protected file is ignored.
+
+  Some files, such as `package.json` and `tsconfig.json`, are [protected](https://biomejs.dev/guides/how-biome-works/#protected-files).
+  Biome emits a verbose warning when it encounters a protected file.
+
+  Previously, Biome emitted this verbose warning even if the file was ignored by the configuration.
+  Now, it doesn't emit verbose warnings for protected files that are ignored.
+
+  Contributed by @Conaclos
+
 - The file `biome.json` can't be ignored anymore. Contributed by @ematipico
+
 - Fix [#1541](https://github.com/biomejs/biome/issues/1541) where the content of protected files wasn't returned to `stdout`. Contributed by @ematipico
 
+- Don't handle CSS files, the formatter isn't ready yet. Contributed by @ematipico
+
 ### Configuration
 
 #### Bug fixes

crates/biome_cli/tests/cases/protected_files.rs

@@ -126,6 +126,7 @@ fn not_process_file_from_cli() {
         result,
     ));
 }
+
 #[test]
 fn not_process_file_from_cli_verbose() {
     let mut fs = MemoryFileSystem::default();
@@ -158,6 +159,88 @@ fn not_process_file_from_cli_verbose() {
     ));
 }
 
+#[test]
+fn not_process_ignored_file_from_cli_verbose() {
+    let mut fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    let file_path = Path::new("package.json");
+    fs.insert(file_path.into(), r#"{ "name": "test" }"#.as_bytes());
+
+    let file_path = Path::new("other.json");
+    fs.insert(file_path.into(), r#"{}"#.as_bytes());
+
+    let file_path1 = Path::new("biome.json");
+    fs.insert(
+        file_path1.into(),
+        r#"{ "files": { "ignore": ["package.json"] } }"#.as_bytes(),
+    );
+
+    let result = run_cli(
+        DynRef::Borrowed(&mut fs),
+        &mut console,
+        Args::from(
+            [
+                ("format"),
+                "--verbose",
+                file_path.as_os_str().to_str().unwrap(),
+            ]
+            .as_slice(),
+        ),
+    );
+
+    assert!(result.is_err(), "run_cli returned {result:?}");
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "not_process_ignored_file_from_cli_verbose",
+        fs,
+        console,
+        result,
+    ));
+}
+
+#[test]
+fn not_process_file_linter_disabled_from_cli_verbose() {
+    let mut fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    let file_path = Path::new("package.json");
+    fs.insert(file_path.into(), r#"{ "name": "test" }"#.as_bytes());
+
+    let file_path = Path::new("other.json");
+    fs.insert(file_path.into(), r#"{}"#.as_bytes());
+
+    let file_path1 = Path::new("biome.json");
+    fs.insert(
+        file_path1.into(),
+        r#"{ "linter": { "enabled": false } }"#.as_bytes(),
+    );
+
+    let result = run_cli(
+        DynRef::Borrowed(&mut fs),
+        &mut console,
+        Args::from(
+            [
+                ("format"),
+                "--verbose",
+                file_path.as_os_str().to_str().unwrap(),
+            ]
+            .as_slice(),
+        ),
+    );
+
+    assert!(result.is_err(), "run_cli returned {result:?}");
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "not_process_file_linter_disabled_from_cli_verbose",
+        fs,
+        console,
+        result,
+    ));
+}
+
 #[test]
 fn should_return_the_content_of_protected_files_via_stdin() {
     let mut fs = MemoryFileSystem::default();

crates/biome_cli/tests/snapshots/main_cases_protected_files/not_process_file_linter_disabled_from_cli_verbose.snap

@@ -0,0 +1,52 @@
+---
+source: crates/biome_cli/tests/snap_test.rs
+expression: content
+---
+## `biome.json`
+
+```json
+{ "linter": { "enabled": false } }
+```
+
+## `other.json`
+
+```json
+{}
+```
+
+## `package.json`
+
+```json
+{ "name": "test" }
+```
+
+# Termination Message
+
+```block
+format ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Some errors were emitted while running checks.
+  
+
+
+```
+
+# Emitted Messages
+
+```block
+other.json format ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i Formatter would have printed the following content:
+  
+    1   │ - {}
+      1 │ + {}
+      2 │ + 
+  
+
+```
+
+```block
+Compared 1 file(s) in <TIME>
+```
+
+

crates/biome_cli/tests/snapshots/main_cases_protected_files/not_process_ignored_file_from_cli_verbose.snap

@@ -0,0 +1,52 @@
+---
+source: crates/biome_cli/tests/snap_test.rs
+expression: content
+---
+## `biome.json`
+
+```json
+{ "files": { "ignore": ["package.json"] } }
+```
+
+## `other.json`
+
+```json
+{}
+```
+
+## `package.json`
+
+```json
+{ "name": "test" }
+```
+
+# Termination Message
+
+```block
+format ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Some errors were emitted while running checks.
+  
+
+
+```
+
+# Emitted Messages
+
+```block
+other.json format ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i Formatter would have printed the following content:
+  
+    1   │ - {}
+      1 │ + {}
+      2 │ + 
+  
+
+```
+
+```block
+Compared 1 file(s) in <TIME>
+```
+
+

crates/biome_service/src/workspace.rs

@@ -95,29 +95,38 @@ pub struct FileFeaturesResult {
 }
 
 impl FileFeaturesResult {
-    /// Files that should not be processed no matter the cases
-    pub(crate) const FILES_TO_NOT_PROCESS: &'static [&'static str; 12] = &[
-        "package.json",
-        "package-lock.json",
-        "npm-shrinkwrap.json",
-        "yarn.lock",
+    /// Sorted array of files that should not be processed no matter the cases.
+    /// These files are handled by other tools.
+    const PROTECTED_FILES: &'static [&'static str; 11] = &[
+        // Composer
         "composer.json",
         "composer.lock",
-        "typescript.json",
-        "tsconfig.json",
-        "jsconfig.json",
+        // Deno
         "deno.json",
         "deno.jsonc",
-        // TODO: remove this when are able to handle nested .gitignore files
-        ".gitignore",
+        // TSC
+        "jsconfig.json",
+        // NPM
+        "npm-shrinkwrap.json",
+        "package-lock.json",
+        "package.json",
+        // TSC
+        "tsconfig.json",
+        "typescript.json",
+        // Yarn
+        "yarn.lock",
     ];
 
-    /// Checks whether this file can be processed
-    fn can_process(&self, path: &Path) -> bool {
+    /// Checks whether this file is protected.
+    /// A protected file is handled by a specific tool and should be ignored.
+    pub(crate) fn is_protected_file(path: &Path) -> bool {
         path.file_name()
             .and_then(OsStr::to_str)
-            .map(|file_name| !FileFeaturesResult::FILES_TO_NOT_PROCESS.contains(&file_name))
-            .unwrap_or_default()
+            .is_some_and(|file_name| {
+                FileFeaturesResult::PROTECTED_FILES
+                    .binary_search(&file_name)
+                    .is_ok()
+            })
     }
 
     /// By default, all features are not supported by a file.
@@ -156,48 +165,44 @@ impl FileFeaturesResult {
         language: &Language,
         path: &Path,
     ) -> Self {
-        if self.can_process(path) {
-            let formatter_disabled =
-                if let Some(disabled) = settings.override_settings.formatter_disabled(path) {
-                    disabled
-                } else if language.is_javascript_like() {
-                    !settings.formatter().enabled || settings.javascript_formatter_disabled()
-                } else if language.is_json_like() {
-                    !settings.formatter().enabled || settings.json_formatter_disabled()
-                } else if language.is_css_like() {
-                    !can_format_css_yet()
-                        || !settings.formatter().enabled
-                        || settings.css_formatter_disabled()
-                } else {
-                    !settings.formatter().enabled
-                };
-            if formatter_disabled {
-                self.features_supported
-                    .insert(FeatureName::Format, SupportKind::FeatureNotEnabled);
-            }
-            // linter
-            if let Some(disabled) = settings.override_settings.linter_disabled(path) {
-                if disabled {
-                    self.features_supported
-                        .insert(FeatureName::Lint, SupportKind::FeatureNotEnabled);
-                }
-            } else if !settings.linter().enabled {
+        let formatter_disabled =
+            if let Some(disabled) = settings.override_settings.formatter_disabled(path) {
+                disabled
+            } else if language.is_javascript_like() {
+                !settings.formatter().enabled || settings.javascript_formatter_disabled()
+            } else if language.is_json_like() {
+                !settings.formatter().enabled || settings.json_formatter_disabled()
+            } else if language.is_css_like() {
+                !can_format_css_yet()
+                    || !settings.formatter().enabled
+                    || settings.css_formatter_disabled()
+            } else {
+                !settings.formatter().enabled
+            };
+        if formatter_disabled {
+            self.features_supported
+                .insert(FeatureName::Format, SupportKind::FeatureNotEnabled);
+        }
+        // linter
+        if let Some(disabled) = settings.override_settings.linter_disabled(path) {
+            if disabled {
                 self.features_supported
                     .insert(FeatureName::Lint, SupportKind::FeatureNotEnabled);
             }
+        } else if !settings.linter().enabled {
+            self.features_supported
+                .insert(FeatureName::Lint, SupportKind::FeatureNotEnabled);
+        }
 
-            // organize imports
-            if let Some(disabled) = settings.override_settings.organize_imports_disabled(path) {
-                if disabled {
-                    self.features_supported
-                        .insert(FeatureName::OrganizeImports, SupportKind::FeatureNotEnabled);
-                }
-            } else if !settings.organize_imports().enabled {
+        // organize imports
+        if let Some(disabled) = settings.override_settings.organize_imports_disabled(path) {
+            if disabled {
                 self.features_supported
                     .insert(FeatureName::OrganizeImports, SupportKind::FeatureNotEnabled);
             }
-        } else {
-            self.features_supported = HashMap::from(FileFeaturesResult::WORKSPACE_FEATURES);
+        } else if !settings.organize_imports().enabled {
+            self.features_supported
+                .insert(FeatureName::OrganizeImports, SupportKind::FeatureNotEnabled);
         }
 
         debug!(
@@ -283,6 +288,20 @@ impl FileFeaturesResult {
             .values()
             .all(|support_kind| support_kind.is_not_enabled())
     }
+
+    /// The file is not processed if for every enabled feature
+    /// the file is either protected, not supported, ignored.
+    pub fn is_not_processed(&self) -> bool {
+        self.features_supported.values().all(|support_kind| {
+            matches!(
+                support_kind,
+                SupportKind::FeatureNotEnabled
+                    | SupportKind::FileNotSupported
+                    | SupportKind::Ignored
+                    | SupportKind::Protected
+            )
+        })
+    }
 }
 
 impl SupportsFeatureResult {
@@ -859,3 +878,10 @@ impl<'app, W: Workspace + ?Sized> Drop for FileGuard<'app, W> {
             .ok();
     }
 }
+
+#[test]
+fn test_order() {
+    for items in FileFeaturesResult::PROTECTED_FILES.windows(2) {
+        assert!(items[0] < items[1], "{} < {}", items[0], items[1]);
+    }
+}