Merge branch 'main' into fix-logging

Author: shadr

CHANGELOG.md

@@ -2,6 +2,28 @@
 
 This file documents the changes made to the formatter with each release. This project uses [semantic versioning](https://semver.org/spec/v2.0.0.html).
 
+## Release 0.9.0 (2025-09-25)
+
+This release focuses on performance improvements and adds support for formatting multiple files at once.
+
+### Added
+
+- Support for formatting multiple files at once
+- Multi-threading when formatting multiple files for better performance
+
+### Changed
+
+- Improved performance on long GDScript files by 5 to 10%
+- Don't parse code multiple times when using `--safe` flag
+- Reuse parser instances and trees to reduce memory allocations
+- Updated dependencies to latest versions
+- Updated Zed editor configuration instructions
+
+### Fixed
+
+- Fixed commas ending up dangling on separate lines in some cases (after lambdas in function calls, arrays, and dictionaries)
+- Don't modify original syntax tree for safety checks
+
 ## Release 0.8.1 (2025-09-23)
 
 ### Changed

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "gdscript-formatter"
-version = "0.8.1"
+version = "0.9.0"
 edition = "2024"
 description = "A GDScript code formatter using Topiary and Tree-sitter"
 license = "MIT"
@@ -13,6 +13,7 @@ topiary-core = { git = "https://github.com/tweag/topiary", rev = "5081ccef9245fe
 tree-sitter-gdscript  = { git = "https://github.com/NathanLovato/tree-sitter-gdscript.git", branch = "gdquest/GDScript-formatter" }
 regex = "1.11"
 tree-sitter = "0.25.10"
+rayon = "1.11.0"
 
 [dev-dependencies]
 test_each_file = "0.3.5"

Cargo.toml

@@ -5,9 +5,22 @@ use std::{
 };
 
 use clap::{CommandFactory, Parser};
+use rayon::prelude::*;
 
 use gdscript_formatter::{FormatterConfig, formatter::format_gdscript_with_config};
 
+/// This struct is used to hold all the information about the result when
+/// formatting a single file. Now that we use parallel processing, we need to
+/// keep track of the original index to order the files in the output when
+/// printing results.
+#[derive(Debug, Clone)]
+struct FormatterOutput {
+    index: usize,
+    file_path: PathBuf,
+    formatted_content: String,
+    is_formatted: bool,
+}
+
 #[derive(Parser)]
 #[clap(
     about = "A GDScript code formatter using Topiary and Tree-sitter",
@@ -122,37 +135,84 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     }
 
     let total_files = input_gdscript_files.len();
-    let mut all_formatted = true;
 
-    for (index, file_path) in input_gdscript_files.iter().enumerate() {
-        let file_number = index + 1;
-        terminal_clear_line();
-        eprint!("\rFormatting file {}/{}", file_number, total_files);
-        io::stdout().flush().unwrap();
-
-        let input_content = fs::read_to_string(file_path)
-            .map_err(|error| format!("Failed to read file {}: {}", file_path.display(), error))?;
+    eprint!(
+        "Formatting {} file{}...",
+        total_files,
+        if total_files == 1 { "" } else { "s" }
+    );
+    io::stdout().flush().unwrap();
+
+    // We use the rayon library to automatically process files in parallel for
+    // us. The formatter runs largely single threaded so this speeds things up a
+    // lot on multi-core CPUs
+    let outputs: Vec<Result<FormatterOutput, String>> = input_gdscript_files
+        .par_iter()
+        .enumerate()
+        .map(|(index, file_path)| {
+            let input_content = fs::read_to_string(file_path).map_err(|error| {
+                format!("Failed to read file {}: {}", file_path.display(), error)
+            })?;
+
+            let formatted_content =
+                format_gdscript_with_config(&input_content, &config).map_err(|error| {
+                    format!("Failed to format file {}: {}", file_path.display(), error)
+                })?;
+
+            let is_formatted = input_content == formatted_content;
+
+            Ok(FormatterOutput {
+                index,
+                file_path: (*file_path).clone(),
+                formatted_content,
+                is_formatted,
+            })
+        })
+        .collect();
 
-        let formatted_content = format_gdscript_with_config(&input_content, &config)?;
+    // Restore the original order of the input files based on their initial index
+    let mut sorted_outputs: Vec<_> = outputs.into_iter().collect();
+    sorted_outputs.sort_by_key(|output| {
+        match output {
+            Ok(output) => output.index,
+            // Sort errors at the end in no particular order
+            Err(_) => usize::MAX,
+        }
+    });
 
-        if args.check {
-            if input_content != formatted_content {
-                all_formatted = false;
+    // If true, all input files were already formatted (used for check mode)
+    let mut all_formatted = true;
+    for output in sorted_outputs {
+        match output {
+            Ok(output) => {
+                if args.check {
+                    if !output.is_formatted {
+                        all_formatted = false;
+                    }
+                } else if args.stdout {
+                    // Clear the progress message before printing formatted files to stdout
+                    terminal_clear_line();
+                    // A little bit hacky, but because terminals by default output both stdout and stderr
+                    // we need to return carriage to the start to print formatted output from the start of the line
+                    eprint!("\r");
+                    // If there are multiple input files we still allow stdout but we print a separator
+                    if total_files > 1 {
+                        println!("#--file:{}", output.file_path.display());
+                    }
+                    print!("{}", output.formatted_content);
+                } else {
+                    fs::write(&output.file_path, output.formatted_content).map_err(|e| {
+                        format!(
+                            "Failed to write to file {}: {}",
+                            output.file_path.display(),
+                            e
+                        )
+                    })?;
+                }
             }
-        } else if args.stdout {
-            // Clear the current line before printing formatted files to stdout, to erase the "Formatting file ..." message
-            terminal_clear_line();
-            // A little bit hacky, but because terminals by default output both stdout and stderr
-            // we need to return carriage to the start to print formatted output from the start of the line
-            eprint!("\r");
-            // If there are multiple input files we still allow stdout but we print a separator
-            if total_files > 1 {
-                println!("#--file:{}", file_path.display());
+            Err(error_msg) => {
+                return Err(error_msg.into());
             }
-            print!("{}", formatted_content);
-        } else {
-            fs::write(file_path, formatted_content)
-                .map_err(|e| format!("Failed to write to file {}: {}", file_path.display(), e))?;
         }
     }