rfmt 1.7.0 → 2.0.0.beta1

data/ext/rfmt/src/parser/prism_adapter.rs

@@ -1,3 +1,8 @@
+//! Test support only: no production caller since the phase 7 legacy-path
+//! deletion. Deserializes the frozen golden JSON fixtures under
+//! tests/fixtures/parity/ so native_parity.rs can pin NativeAdapter's output
+//! against future ruby-prism crate bumps.
+
 use crate::ast::{Comment, CommentPosition, CommentType, FormattingInfo, Location, Node, NodeType};
 use crate::error::{Result, RfmtError};
 use crate::parser::RubyParser;

data/ext/rfmt/src/validation.rs

@@ -0,0 +1,69 @@
+//! Output guard: never return syntactically invalid Ruby to the caller.
+//! Moved here from lib/rfmt.rb's validate_output! at the phase-6 switchover.
+
+use crate::error::{Result, RfmtError};
+
+pub fn validate_output(formatted: &str) -> Result<()> {
+    let bytes = formatted.as_bytes();
+    let parse_result = ruby_prism::parse(bytes);
+
+    let Some(error) = parse_result.errors().next() else {
+        return Ok(());
+    };
+
+    let line = 1 + bytes[..error.location().start_offset()]
+        .iter()
+        .filter(|&&b| b == b'\n')
+        .count();
+    Err(RfmtError::ValidationError(format!(
+        "Formatter produced syntactically invalid output (this is a bug in rfmt, not in your code): {} at line {}",
+        error.message(),
+        line
+    )))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn accepts_valid_ruby() {
+        assert!(validate_output("x = 1\n").is_ok());
+    }
+
+    #[test]
+    fn rejects_invalid_ruby_with_validation_error() {
+        let err = validate_output("def broken(\n").unwrap_err();
+
+        match err {
+            RfmtError::ValidationError(message) => {
+                assert!(
+                    message.starts_with(
+                        "Formatter produced syntactically invalid output (this is a bug in rfmt, not in your code): "
+                    ),
+                    "unexpected message: {message}"
+                );
+                assert!(
+                    message.contains(" at line 1"),
+                    "unexpected message: {message}"
+                );
+            }
+            other => panic!("expected ValidationError, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn reports_the_line_of_the_first_error() {
+        let err = validate_output("x = 1\ny = 2\ndef broken(\n").unwrap_err();
+
+        match err {
+            RfmtError::ValidationError(message) => {
+                assert!(
+                    message.contains(" at line 3"),
+                    "unexpected message: {message}"
+                );
+            }
+            other => panic!("expected ValidationError, got {other:?}"),
+        }
+    }
+}

data/ext/rfmt/tests/fixtures/parity/comments_mixed.rb

@@ -0,0 +1,9 @@
+# leading comment
+x = 1 # trailing comment
+
+=begin
+embdoc line one
+line two
+=end
+y = 2
+# final comment

data/ext/rfmt/tests/fixtures/parity/constructs.rb

@@ -0,0 +1,50 @@
+expected = :ready
+
+case payload
+in [Integer => first, *rest]
+  first + rest.sum
+in { status: String => status, code: 200 | 201 }
+  status
+in ^expected
+  :pinned
+else
+  :unmatched
+end
+
+begin
+  risky!
+rescue KeyError => e
+  recover(e)
+rescue StandardError
+  retry_count += 1
+  retry if retry_count < 3
+else
+  celebrate
+ensure
+  cleanup
+end
+
+counters = Hash.new(0)
+counters[:hits] ||= 0
+counters[:hits] += 1
+@cache &&= @cache.compact
+$verbose ||= false
+CONFIG = { a: 3r, b: 3.14r, c: 2i, d: 2ri }
+
+class << self
+  def singleton_helper = :ok
+end
+
+alias aka singleton_helper
+alias $err $stderr
+undef :aka
+
+flip = items.select { |l| (l == first)..(l == last) }
+
+lines = ->(input) { input.each_line.to_a }
+x, *middle, z = lines.call(<<~TXT)
+  alpha
+  beta
+  gamma
+TXT
+puts x, middle, z

data/ext/rfmt/tests/fixtures/parity/embdoc.rb

@@ -0,0 +1,12 @@
+=begin
+Block documentation spanning
+multiple lines.
+=end
+value = 42
+
+=begin
+Another embedded document right before a method.
+=end
+def answer
+  value
+end

data/ext/rfmt/tests/fixtures/parity/heredoc_assign.rb

@@ -0,0 +1,15 @@
+sql = <<~SQL
+  SELECT *
+  FROM users
+  WHERE active = true
+SQL
+
+body = <<-TEXT
+  indented terminator keeps its column
+  TEXT
+
+plain = <<HTML
+<p>no squiggly</p>
+HTML
+
+after = sql.length + body.length

data/ext/rfmt/tests/fixtures/parity/heredoc_call_args.rb

@@ -0,0 +1,17 @@
+result = execute(<<~SQL, timeout: 5)
+  SELECT id
+  FROM events
+SQL
+
+logger.info(prefix, <<~MSG)
+  first line
+  second line
+MSG
+
+wrap(inner(<<~ONE), <<~TWO)
+  one body
+ONE
+  two body
+TWO
+
+puts result

data/ext/rfmt/tests/fixtures/parity/metadata_classes.rb

@@ -0,0 +1,30 @@
+class Foo::Bar < Baz::Qux
+  def change
+    x = compute(1)
+    @count = x
+  end
+end
+
+class AddUsers < ActiveRecord::Migration[8.1]
+  def change
+    create_table :users
+  end
+end
+
+class Simple < Base
+end
+
+class Plain
+end
+
+module Alpha::Beta
+end
+
+module Gamma
+end
+
+class ::TopScoped < ::Deep::Nested::Base
+end
+
+module Alpha::Beta::Gamma
+end

data/ext/rfmt/tests/fixtures/parity/metadata_conditionals.rb

@@ -0,0 +1,14 @@
+result = flag ? 1 : 2
+
+if flag
+  a = 1
+else
+  a = 2
+end
+
+unless flag
+  b = 3
+end
+
+c = 4 if flag
+d = 5 unless flag

data/ext/rfmt/tests/fixtures/parity/metadata_defs.rb

@@ -0,0 +1,33 @@
+def !@
+  true
+end
+
+def +@
+  self
+end
+
+def []=(key, value)
+  store(key, value)
+end
+
+def self.build(name)
+  new(name)
+end
+
+obj = Object.new
+
+def obj.run
+  1
+end
+
+def bare arg
+  arg
+end
+
+def none
+  0
+end
+
+def empty_parens()
+  nil
+end

data/ext/rfmt/tests/fixtures/parity/multibyte.rb

@@ -0,0 +1,14 @@
+greeting = "こんにちは、世界"
+farewell = 'さようなら'; short = "あ"
+
+def label(polite: false)
+  polite ? "です" : "だ"
+end
+
+mixed = "emoji 🎉 と 日本語"
+message = <<~TEXT
+  一行目の本文
+  二行目の本文
+TEXT
+
+combined = "#{greeting} #{mixed}".freeze

data/ext/rfmt/tests/fixtures/parity/numeric.rb

@@ -0,0 +1,6 @@
+a = 3r
+b = 3.14r
+c = 2i
+d = 2ri
+e = 6.02e2i
+f = a + b * c - d / e

data/ext/rfmt/tests/fixtures/parity/plain.rb

@@ -0,0 +1,31 @@
+class Greeter
+  attr_reader :name
+
+  def initialize(name)
+    @name = name
+  end
+
+  def greet(loud: false)
+    message = "hello, #{name}"
+    if loud
+      message.upcase
+    else
+      message
+    end
+  end
+end
+
+module Registry
+  DEFAULT = Greeter.new("world")
+
+  def self.lookup(key)
+    entries.fetch(key) { DEFAULT }
+  end
+end
+
+items = [1, 2.5, :three, nil, true]
+totals = { "sum" => items.compact.size, count: items.length }
+items.each_with_index do |item, index|
+  puts "#{index}: #{item}" unless item.nil?
+end
+result = Registry.lookup(:default)&.greet(loud: totals[:count] > 3)

data/ext/rfmt/tests/native_parity.rs

@@ -0,0 +1,245 @@
+//! Parity tests for the native ruby-prism converter.
+//!
+//! Each fixture under tests/fixtures/parity/ exists as a .rb source and the
+//! frozen golden JSON the (now deleted) Ruby PrismBridge produced for it.
+//! The .rb goes through NativeAdapter, the .json through the test-support
+//! PrismAdapter, and the trees must agree on node types, all six location
+//! fields, children, formatting.multiline, metadata, and comments. This pins
+//! NativeAdapter's output shape against future ruby-prism crate bumps; only
+//! `bundle exec ruby scripts/gen_parity_fixtures.rb` may regenerate the JSON.
+
+use rfmt::ast::{Location, Node};
+use rfmt::parser::{NativeAdapter, PrismAdapter, RubyParser};
+use std::collections::HashMap;
+use std::fs;
+use std::path::{Path, PathBuf};
+
+/// Keys the bridge still emits but nothing downstream reads; the native
+/// converter intentionally drops them, so they are stripped from the JSON
+/// side before the exact metadata comparison.
+const DEAD_METADATA_KEYS: [&str; 4] = ["parameters_count", "message", "content", "value"];
+
+fn fixtures_dir() -> PathBuf {
+    Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures/parity")
+}
+
+fn push_diff<T: std::fmt::Debug + PartialEq>(
+    diffs: &mut Vec<String>,
+    path: &str,
+    field: &str,
+    json: &T,
+    native: &T,
+) {
+    if json != native {
+        diffs.push(format!(
+            "{}.{}: json={:?} native={:?}",
+            path, field, json, native
+        ));
+    }
+}
+
+fn live_metadata(metadata: &HashMap<String, String>) -> HashMap<String, String> {
+    metadata
+        .iter()
+        .filter(|(key, _)| !DEAD_METADATA_KEYS.contains(&key.as_str()))
+        .map(|(key, value)| (key.clone(), value.clone()))
+        .collect()
+}
+
+fn compare_locations(path: &str, json: &Location, native: &Location, diffs: &mut Vec<String>) {
+    push_diff(
+        diffs,
+        path,
+        "start_line",
+        &json.start_line,
+        &native.start_line,
+    );
+    push_diff(
+        diffs,
+        path,
+        "start_column",
+        &json.start_column,
+        &native.start_column,
+    );
+    push_diff(diffs, path, "end_line", &json.end_line, &native.end_line);
+    push_diff(
+        diffs,
+        path,
+        "end_column",
+        &json.end_column,
+        &native.end_column,
+    );
+    push_diff(
+        diffs,
+        path,
+        "start_offset",
+        &json.start_offset,
+        &native.start_offset,
+    );
+    push_diff(
+        diffs,
+        path,
+        "end_offset",
+        &json.end_offset,
+        &native.end_offset,
+    );
+}
+
+fn compare_nodes(path: &str, json: &Node, native: &Node, diffs: &mut Vec<String>) {
+    push_diff(diffs, path, "node_type", &json.node_type, &native.node_type);
+
+    compare_locations(
+        &format!("{}.location", path),
+        &json.location,
+        &native.location,
+        diffs,
+    );
+
+    push_diff(
+        diffs,
+        path,
+        "formatting.multiline",
+        &json.formatting.multiline,
+        &native.formatting.multiline,
+    );
+
+    let json_metadata = live_metadata(&json.metadata);
+    push_diff(diffs, path, "metadata", &json_metadata, &native.metadata);
+
+    push_diff(
+        diffs,
+        path,
+        "comments.len",
+        &json.comments.len(),
+        &native.comments.len(),
+    );
+    for (i, (jc, nc)) in json.comments.iter().zip(native.comments.iter()).enumerate() {
+        let cpath = format!("{}.comments[{}]", path, i);
+        push_diff(diffs, &cpath, "text", &jc.text, &nc.text);
+        push_diff(
+            diffs,
+            &cpath,
+            "comment_type",
+            &jc.comment_type,
+            &nc.comment_type,
+        );
+        push_diff(diffs, &cpath, "position", &jc.position, &nc.position);
+        compare_locations(
+            &format!("{}.location", cpath),
+            &jc.location,
+            &nc.location,
+            diffs,
+        );
+    }
+
+    push_diff(
+        diffs,
+        path,
+        "children.len",
+        &json.children.len(),
+        &native.children.len(),
+    );
+    for (i, (jc, nc)) in json.children.iter().zip(native.children.iter()).enumerate() {
+        compare_nodes(&format!("{}.children[{}]", path, i), jc, nc, diffs);
+    }
+}
+
+#[test]
+fn native_conversion_matches_ruby_bridge() {
+    let dir = fixtures_dir();
+    let mut names: Vec<PathBuf> = fs::read_dir(&dir)
+        .expect("fixtures dir missing; add fixtures under tests/fixtures/parity")
+        .map(|e| e.unwrap().path())
+        .filter(|p| p.extension().is_some_and(|ext| ext == "rb"))
+        .collect();
+    names.sort();
+    assert!(
+        names.len() >= 11,
+        "expected the full parity fixture set, found {:?}",
+        names
+    );
+
+    let mut failures = Vec::new();
+    for rb_path in &names {
+        let name = rb_path.file_stem().unwrap().to_string_lossy().into_owned();
+        let source = fs::read_to_string(rb_path).unwrap();
+        let json = fs::read_to_string(rb_path.with_extension("json")).unwrap_or_else(|_| {
+            panic!(
+                "{}.json missing; run `bundle exec ruby scripts/gen_parity_fixtures.rb`",
+                name
+            )
+        });
+
+        let json_tree = PrismAdapter::new().parse(&json).expect("bridge JSON parse");
+        let native_tree = NativeAdapter::new().parse(&source).expect("native parse");
+
+        let mut diffs = Vec::new();
+        compare_nodes("root", &json_tree, &native_tree, &mut diffs);
+        if !diffs.is_empty() {
+            failures.push(format!("[{}]\n{}", name, diffs.join("\n")));
+        }
+    }
+
+    assert!(failures.is_empty(), "\n{}", failures.join("\n\n"));
+}
+
+#[test]
+fn comparator_detects_a_mutated_tree() {
+    let source = fs::read_to_string(fixtures_dir().join("plain.rb")).unwrap();
+    let reference = NativeAdapter::new().parse(&source).unwrap();
+    let mut mutated = reference.clone();
+    let first = mutated.children.first_mut().expect("fixture has children");
+    first.location.end_line += 1;
+
+    let mut diffs = Vec::new();
+    compare_nodes("root", &reference, &mutated, &mut diffs);
+    assert_eq!(diffs.len(), 1, "{diffs:?}");
+    assert!(
+        diffs[0].starts_with("root.children[0].location.end_line: "),
+        "{diffs:?}"
+    );
+}
+
+#[test]
+fn comparator_detects_a_mutated_metadata_value() {
+    let reference = NativeAdapter::new()
+        .parse("def foo(a)\n  a\nend\n")
+        .unwrap();
+    let mut mutated = reference.clone();
+    let def = mutated.children.first_mut().expect("def child");
+    assert_eq!(def.metadata.get("name").map(String::as_str), Some("foo"));
+    def.metadata.insert("name".to_string(), "bar".to_string());
+
+    let mut diffs = Vec::new();
+    compare_nodes("root", &reference, &mutated, &mut diffs);
+    assert_eq!(diffs.len(), 1, "{diffs:?}");
+    assert!(
+        diffs[0].starts_with("root.children[0].metadata: "),
+        "{diffs:?}"
+    );
+}
+
+#[test]
+fn comparator_detects_a_mutated_comment() {
+    let reference = NativeAdapter::new().parse("# hello\nx = 1\n").unwrap();
+    let mut mutated = reference.clone();
+    let comment = mutated.comments.first_mut().expect("root comment");
+    assert_eq!(comment.text, "# hello");
+    comment.text = "# tampered".to_string();
+
+    let mut diffs = Vec::new();
+    compare_nodes("root", &reference, &mutated, &mut diffs);
+    assert_eq!(diffs.len(), 1, "{diffs:?}");
+    assert!(diffs[0].starts_with("root.comments[0].text: "), "{diffs:?}");
+}
+
+#[test]
+fn native_adapter_reports_parse_errors_with_position() {
+    let err = NativeAdapter::new()
+        .parse("x = 1\ndef broken(")
+        .unwrap_err();
+    let message = err.to_string();
+    assert!(message.contains("Parse error"), "{}", message);
+    // Same line:column shape the Ruby bridge raises (line 2, byte column)
+    assert!(message.contains("2:"), "{}", message);
+}

data/ext/rfmt/tests/ruby_prism_smoke.rs

@@ -0,0 +1,66 @@
+//! Spike gate for the ruby-prism migration (#110 Phase 3): proves the crate
+//! parses with the byte-offset and comment semantics the formatter relies on.
+
+#[test]
+fn parses_heredoc_comments_and_safe_navigation() {
+    let source = r#"result = fetch&.body
+sql = <<~SQL
+  SELECT 1
+SQL
+# leading comment
+value = compute(sql) # trailing comment
+"#;
+
+    let result = ruby_prism::parse(source.as_bytes());
+
+    assert!(result.errors().next().is_none());
+    assert_eq!(result.comments().count(), 2);
+
+    let comment_offsets: Vec<(usize, usize)> = result
+        .comments()
+        .map(|c| {
+            let loc = c.location();
+            (loc.start_offset(), loc.end_offset())
+        })
+        .collect();
+    let leading = &source[comment_offsets[0].0..comment_offsets[0].1];
+    let trailing = &source[comment_offsets[1].0..comment_offsets[1].1];
+    assert_eq!(leading, "# leading comment");
+    assert_eq!(trailing, "# trailing comment");
+
+    let program = result.node();
+    let program = program.as_program_node().expect("program node");
+    let statements = program.statements();
+    assert_eq!(statements.body().iter().count(), 3);
+
+    let first = statements.body().iter().next().expect("first statement");
+    let loc = first.location();
+    assert_eq!(
+        &source[loc.start_offset()..loc.end_offset()],
+        "result = fetch&.body"
+    );
+}
+
+#[test]
+fn reports_errors_for_invalid_source() {
+    let result = ruby_prism::parse(b"def broken(");
+    assert!(result.errors().next().is_some());
+}
+
+#[test]
+fn multibyte_source_keeps_byte_offsets() {
+    let source = "x = \"あいう\"\ny = 1\n";
+    let result = ruby_prism::parse(source.as_bytes());
+    assert!(result.errors().next().is_none());
+
+    let program = result.node();
+    let program = program.as_program_node().expect("program node");
+    let second = program
+        .statements()
+        .body()
+        .iter()
+        .nth(1)
+        .expect("second statement");
+    let loc = second.location();
+    assert_eq!(&source[loc.start_offset()..loc.end_offset()], "y = 1");
+}