Add support for excluding files and folders

Close #299

Author: NathanLovato

CHANGELOG.md

@@ -2,6 +2,12 @@
 
 This file documents the changes made to the formatter with each release.
 
+## Unreleased 0.24.0
+
+### Added
+
+- You can not exclude files and folders using the `--exclude/-x` flag or `gdscript_formatter_exclude` in your editorconfig files (#299)
+
 ## Release 0.23.0 (2026-07-24)
 
 ### Added

README.md

@@ -85,6 +85,8 @@ To see other possible options, run `gdscript-formatter --help`.
 
 You can also configure the formatter with an [EditorConfig](https://editorconfig.org/) file at the root of your project. This is a good way to share the same formatting settings with your whole team. The formatter supports the standard keys `indent_style`, `indent_size`, `max_line_length`, `insert_final_newline`, and `trim_trailing_whitespace`, plus custom keys prefixed with `gdscript_formatter_`. See the [GDScript Formatter docs](https://www.gdquest.com/library/gdscript_formatter/) for the complete list. Note that command line flags override `.editorconfig` values.
 
+To exclude files or directories, pass `--exclude` (or `-x`) one or more times, for example `gdscript-formatter . -x addons`. You can also exclude files matched by an EditorConfig section with `gdscript_formatter_exclude = true`.
+
 Use `--quote-style preserve/single/double` to automatically normalize the string quote style. You can also set the style in your `.editorconfig` file using the key `gdscript_formatter_quote_style`. The default value, `preserve`, leaves existing quotes unchanged.
 
 The Godot add-on also reads `gdscript_formatter_format_on_save` from the `.editorconfig` file. This key only affects the add-on and enables or disables format on save for the whole project and overrides each user's add-on setting. For example:

src/cli.rs

@@ -20,6 +20,7 @@ const HELP_FORMATTER: &str = "\
 
 	Options:
 	  -c, --check                                Check if files are formatted, exit 1 if not
+	  -x, --exclude <PATH>                       Exclude one file or directory (you can repeat this option multiple times)
 	      --verify-structure                     Verify formatted output has the same structure as the input
 	      --stdout                               Write to stdout instead of overwriting files
 	      --use-spaces                           Use spaces instead of tabs for indentation
@@ -47,6 +48,7 @@ Arguments:
   <FILES>...                 GDScript files or directories to lint
 
 Options:
+  -x, --exclude <PATH>         Exclude a file or directory (may be repeated)
       --disable <RULES>       Disable specific rules (comma-separated)
       --max-line-length <NUM>  Maximum line length allowed (default: 100)
       --list-rules            List all available linting rules
@@ -59,6 +61,8 @@ Options:
 pub struct CliArguments {
     /// List of input file paths or directories to process.
     pub input_file_paths: Vec<PathBuf>,
+    /// Files or directories to skip during discovery.
+    pub excluded_paths: Vec<PathBuf>,
     /// Which command to run.
     pub command: Command,
 }
@@ -124,6 +128,7 @@ pub fn parse_args() -> CliArguments {
     let mut active_command = ActiveCommand::Format;
 
     let mut input_file_paths: Vec<PathBuf> = Vec::new();
+    let mut excluded_paths: Vec<PathBuf> = Vec::new();
     let mut format_do_print_to_stdout = false;
     let mut format_do_check_formatted_only = false;
     let mut format_use_spaces: Option<bool> = None;
@@ -179,6 +184,15 @@ pub fn parse_args() -> CliArguments {
             let (flag_name, assigned_value) = split_flag_and_value(flag_without_prefix);
             match active_command {
                 ActiveCommand::Format => match flag_name {
+                    "exclude" => {
+                        let value = consume_flag_value(
+                            assigned_value,
+                            &argument_list,
+                            &mut current_argument_index,
+                            "--exclude",
+                        );
+                        excluded_paths.push(PathBuf::from(value));
+                    }
                     "stdout" => {
                         require_no_value(assigned_value, "--stdout");
                         format_do_print_to_stdout = true;
@@ -288,6 +302,15 @@ pub fn parse_args() -> CliArguments {
                     )),
                 },
                 ActiveCommand::Lint => match flag_name {
+                    "exclude" => {
+                        let value = consume_flag_value(
+                            assigned_value,
+                            &argument_list,
+                            &mut current_argument_index,
+                            "--exclude",
+                        );
+                        excluded_paths.push(PathBuf::from(value));
+                    }
                     "disable" => {
                         let value = consume_flag_value(
                             assigned_value,
@@ -328,6 +351,17 @@ pub fn parse_args() -> CliArguments {
             }
         } else if current_argument.starts_with('-') && current_argument.len() > 1 {
             let short_flags = &current_argument[1..];
+            if short_flags == "x" {
+                let value = consume_flag_value(
+                    None,
+                    &argument_list,
+                    &mut current_argument_index,
+                    "-x/--exclude",
+                );
+                excluded_paths.push(PathBuf::from(value));
+                current_argument_index += 1;
+                continue;
+            }
             for flag_char in short_flags.chars() {
                 match flag_char {
                     'c' => {
@@ -357,6 +391,7 @@ pub fn parse_args() -> CliArguments {
     match active_command {
         ActiveCommand::Format => CliArguments {
             input_file_paths,
+            excluded_paths,
             command: Command::Format {
                 do_print_to_stdout: format_do_print_to_stdout,
                 do_check_formatted_only: format_do_check_formatted_only,
@@ -372,6 +407,7 @@ pub fn parse_args() -> CliArguments {
         },
         ActiveCommand::Lint => CliArguments {
             input_file_paths,
+            excluded_paths,
             command: Command::Lint {
                 disabled_linter_rules: lint_disabled_rules,
                 max_line_length: lint_max_line_length,

src/editorconfig.rs

@@ -16,6 +16,17 @@ fn load_editorconfig_properties(editorconfig_file_path: &Path) -> Option<Propert
     Some(properties)
 }
 
+/// Returns whether the matching EditorConfig settings exclude this file.
+pub fn is_excluded_by_editorconfig(editorconfig_file_path: &Path) -> bool {
+    let Some(properties) = load_editorconfig_properties(editorconfig_file_path) else {
+        return false;
+    };
+    properties
+        .get_raw_for_key("gdscript_formatter_exclude")
+        .into_option()
+        .is_some_and(|value| value == "true")
+}
+
 fn get_max_line_length_from_properties(properties: &Properties) -> Option<usize> {
     match properties.get::<MaxLineLen>() {
         Ok(MaxLineLen::Value(max_line_length)) if max_line_length > 0 => Some(max_line_length),

src/main.rs

@@ -95,7 +95,10 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             max_line_length: max_line_length.unwrap_or(100),
         };
 
-        let input_gdscript_files = find_gdscript_files(&parsed_cli_args.input_file_paths)?;
+        let input_gdscript_files = find_gdscript_files(
+            &parsed_cli_args.input_file_paths,
+            &parsed_cli_args.excluded_paths,
+        )?;
         return run_linter(
             &input_gdscript_files,
             linter_config,
@@ -180,7 +183,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     } else {
         parsed_cli_args.input_file_paths
     };
-    let input_gdscript_files = find_gdscript_files(&input_paths)?;
+    let input_gdscript_files = find_gdscript_files(&input_paths, &parsed_cli_args.excluded_paths)?;
 
     let total_files = input_gdscript_files.len();
 
@@ -414,6 +417,7 @@ fn format_chunk(
 
 fn find_gdscript_files(
     input_paths: &[PathBuf],
+    excluded_paths: &[PathBuf],
 ) -> Result<Vec<PathBuf>, Box<dyn std::error::Error>> {
     let mut gdscript_file_paths = Vec::new();
     let mut paths_to_check: Vec<PathBuf> = Vec::with_capacity(input_paths.len());
@@ -422,6 +426,9 @@ fn find_gdscript_files(
     }
 
     while let Some(current_path) = paths_to_check.pop() {
+        if is_path_excluded(&current_path, excluded_paths) {
+            continue;
+        }
         if current_path.is_dir() {
             let entries = fs::read_dir(&current_path).map_err(|error| {
                 format!(
@@ -442,13 +449,22 @@ fn find_gdscript_files(
                     paths_to_check.push(entry.path());
                 } else if let Some(extension) = entry.path().extension() {
                     if extension == "gd" {
-                        gdscript_file_paths.push(entry.path());
+                        let file_path = entry.path();
+                        if !is_path_excluded(&file_path, excluded_paths)
+                            && !gdscript_formatter::editorconfig::is_excluded_by_editorconfig(
+                                &file_path,
+                            )
+                        {
+                            gdscript_file_paths.push(file_path);
+                        }
                     }
                 }
             }
         } else if let Some(extension) = current_path.extension() {
             if extension == "gd" {
-                gdscript_file_paths.push(current_path);
+                if !gdscript_formatter::editorconfig::is_excluded_by_editorconfig(&current_path) {
+                    gdscript_file_paths.push(current_path);
+                }
             }
         }
     }
@@ -466,6 +482,23 @@ fn find_gdscript_files(
     Ok(gdscript_file_paths)
 }
 
+fn is_path_excluded(path: &Path, excluded_paths: &[PathBuf]) -> bool {
+    let current_directory = env::current_dir().expect("Failed to get current directory");
+    let absolute_path = if path.is_absolute() {
+        path.to_path_buf()
+    } else {
+        current_directory.join(path)
+    };
+    excluded_paths.iter().any(|exclude_path| {
+        let absolute_exclude_path = if exclude_path.is_absolute() {
+            exclude_path.clone()
+        } else {
+            current_directory.join(exclude_path)
+        };
+        absolute_path.starts_with(absolute_exclude_path)
+    })
+}
+
 fn compare_output_index(
     left: &Result<FormatterOutput, String>,
     right: &Result<FormatterOutput, String>,