Switch region markers from gd-formatter:disable/enable to fmt: off/on,

refactor the code a little bit

Author: NathanLovato

src/formatter.rs

@@ -54,7 +54,7 @@ struct Formatter {
     tree: Tree,
     original_source: Option<String>,
     indent_string: String,
-    // Original text of each # gd-formatter:disable ... # gd-formatter:enable region,
+    // Original text of each `# fmt: off` ... `# fmt: on` region,
     // indexed by the order they appear in the file. Used to restore regions after formatting.
     disabled_regions: Vec<String>,
 }
@@ -157,23 +157,41 @@ impl Formatter {
     /// pre-applying rules that could be performance-intensive through topiary.
     #[inline(always)]
     fn preprocess(&mut self) -> &mut Self {
-        // Replace # gd-formatter:disable ... # gd-formatter:enable regions with placeholder
-        // comments so they pass through Topiary and post-processing untouched.
         self.extract_disabled_regions();
         self
     }
 
-    /// Scans the content for # gd-formatter:disable / # gd-formatter:enable regions.
-    /// Each complete region (including the marker lines) is stored verbatim in
+    /// Scans the content for `# fmt: off` / `# fmt: on` regions (ignoring whitespace).
+    /// Each complete region (including the marker lines) is stored literally in
     /// self.disabled_regions and replaced with a single placeholder comment of the
-    /// form `# gd-formatter:preserved-region:N`. This prevents Topiary and all
+    /// form `# fmt:preserved-region:N`. This prevents Topiary and all
     /// post-processing steps from touching the content inside those regions.
     fn extract_disabled_regions(&mut self) {
-        const DISABLE_MARKER: &str = "# gd-formatter:disable";
-        const ENABLE_MARKER: &str = "# gd-formatter:enable";
+        enum LineKind {
+            FmtOn,
+            FmtOff,
+            Other,
+        }
 
-        if !self.content.contains(DISABLE_MARKER) {
-            return;
+        /// Checks whether `line` is a `# fmt: off` or `# fmt: on` marker.
+        fn classify_line(line: &str) -> LineKind {
+            if !line.contains('#') {
+                return LineKind::Other;
+            }
+
+            let line = line.trim();
+            let Some(after_hash) = line.strip_prefix('#') else {
+                return LineKind::Other;
+            };
+            let Some(after_fmt) = after_hash.trim_start().strip_prefix("fmt:") else {
+                return LineKind::Other;
+            };
+
+            match after_fmt.trim_start() {
+                "off" => LineKind::FmtOff,
+                "on" => LineKind::FmtOn,
+                _ => LineKind::Other,
+            }
         }
 
         let mut result = String::new();
@@ -183,46 +201,43 @@ impl Formatter {
         // split_inclusive keeps the '\n' attached to each line so we never lose
         // trailing newlines when we reassemble the string.
         for line in self.content.split_inclusive('\n') {
-            let trimmed = line.trim();
-
-            if !in_disabled_region && trimmed == DISABLE_MARKER {
-                // Begin accumulating the disabled region (include the marker line itself).
-                in_disabled_region = true;
-                current_region.push_str(line);
-            } else if in_disabled_region && trimmed == ENABLE_MARKER {
-                // Close the region (include the closing marker line).
-                current_region.push_str(line);
-                in_disabled_region = false;
-                let region_index = self.disabled_regions.len();
-                self.disabled_regions.push(current_region.clone());
-                current_region.clear();
-                // Emit a single placeholder comment so the rest of the pipeline sees
-                // one clean comment node in place of the entire disabled block.
-                result.push_str(&format!(
-                    "# gd-formatter:preserved-region:{}\n",
-                    region_index
-                ));
-            } else if in_disabled_region {
-                current_region.push_str(line);
-            } else {
-                result.push_str(line);
+            match classify_line(line) {
+                LineKind::FmtOff if !in_disabled_region => {
+                    in_disabled_region = true;
+                    current_region.push_str(line);
+                }
+                LineKind::FmtOn if in_disabled_region => {
+                    current_region.push_str(line);
+                    in_disabled_region = false;
+                    let region_index = self.disabled_regions.len();
+                    self.disabled_regions.push(current_region.clone());
+                    current_region.clear();
+                    result.push_str(&format!("# fmt:preserved-region:{}\n", region_index));
+                }
+                _ => {
+                    if in_disabled_region {
+                        current_region.push_str(line);
+                    } else {
+                        result.push_str(line);
+                    }
+                }
             }
         }
 
         // An unclosed disable region (no matching enable marker) is also preserved.
         if in_disabled_region {
             let region_index = self.disabled_regions.len();
             self.disabled_regions.push(current_region);
-            result.push_str(&format!(
-                "# gd-formatter:preserved-region:{}\n",
-                region_index
-            ));
+            result.push_str(&format!("# fmt:preserved-region:{}\n", region_index));
         }
 
         self.content = result;
-        // Re-parse so self.tree matches the new placeholder-containing content before
-        // it is handed to Topiary.
-        self.tree = self.parser.parse(&self.content, None).unwrap();
+
+        // Reparse the tree in case we modified the source code and replaced
+        // some regions with disabled formatting.
+        if !self.disabled_regions.is_empty() {
+            self.tree = self.parser.parse(&self.content, None).unwrap();
+        }
     }
 
     /// Replaces every placeholder comment emitted by extract_disabled_regions() with
@@ -240,7 +255,7 @@ impl Formatter {
             // Strip leading whitespace before checking for the placeholder; Topiary
             // may have adjusted indentation on comment lines.
             let trimmed = line.trim();
-            if let Some(rest) = trimmed.strip_prefix("# gd-formatter:preserved-region:") {
+            if let Some(rest) = trimmed.strip_prefix("# fmt:preserved-region:") {
                 if let Ok(index) = rest.parse::<usize>() {
                     if let Some(original) = self.disabled_regions.get(index) {
                         result.push_str(original);

tests/reorder_code/expected/reorder_disable.gd

@@ -1,14 +1,14 @@
 class_name TestClass
 extends Node
 
-# gd-formatter:disable
+# fmt: off
 var vertices_preserve: PackedVector3Array = [
 	Vector3(-1, 0, -1),
 	Vector3( 1, 0, -1),
 	Vector3( 1, 0,  1),
 	Vector3(-1, 0,  1),
 ]
-# gd-formatter:enable
+# fmt: on
 var vertices_reformat: PackedVector3Array = [
 	Vector3(-1, 0, -1),
 	Vector3(1, 0, -1),

tests/reorder_code/input/reorder_disable.gd

@@ -1,18 +1,18 @@
 class_name TestClass
 extends Node
 
-# gd-formatter:disable
+# fmt: off
 var vertices_preserve: PackedVector3Array = [
 	Vector3(-1, 0, -1),
 	Vector3( 1, 0, -1),
 	Vector3( 1, 0,  1),
 	Vector3(-1, 0,  1),
 ]
-# gd-formatter:enable
+# fmt: on
 
 var vertices_reformat: PackedVector3Array = [
-		Vector3(-1, 0, -1),
-		Vector3( 1, 0, -1),
-		Vector3( 1, 0,  1),
-		Vector3(-1, 0,  1),
+	Vector3(-1, 0, -1),
+	Vector3( 1, 0, -1),
+	Vector3( 1, 0,  1),
+	Vector3(-1, 0,  1),
 ]