fix: ruby treesitter (#1881)

gotbadger · web-flow · commit 0e95665fa0c8 · 2026-01-20T11:44:13.000Z
* fix: ruby node fixes

* fix: more ruby node changes
diff --git a/pkg/languages/ruby/pattern/pattern.go b/pkg/languages/ruby/pattern/pattern.go
@@ -24,7 +24,8 @@ var (
 	unanchoredPatternNodeTypes      = []string{"pair", "keyword_parameter"}
 	allowedPatternQueryTypes        = []string{"identifier", "constant", "_", "call", "simple_symbol"}
 
-	classPatternErrorRegex = regexp.MustCompile(`\Aclass\s*\z`)
+	classPatternErrorRegex      = regexp.MustCompile(`\Aclass\s*\z`)
+	superclassPatternErrorRegex = regexp.MustCompile(`<\s*\z`)
 )
 
 type Pattern struct {
@@ -101,7 +102,30 @@ func (*Pattern) AnonymousParentTypes() []string {
 }
 
 func (*Pattern) IsContainer(node *tree.Node) bool {
-	return slices.Contains(patternMatchNodeContainerTypes, node.Type())
+	if slices.Contains(patternMatchNodeContainerTypes, node.Type()) {
+		return true
+	}
+	// Treat body_statement as a container so pattern variables skip over it
+	// and capture the actual content inside. In the new tree-sitter grammar,
+	// class/module/block bodies are wrapped in body_statement.
+	if node.Type() == "body_statement" {
+		return true
+	}
+	return false
+}
+
+func (*Pattern) IsLeaf(node *tree.Node) bool {
+	// Treat bare method calls (no receiver, no arguments) as leaf nodes.
+	// In the new tree-sitter grammar, `find_by!` is parsed as:
+	//   call(method: identifier)
+	// We want patterns like `find_by!` to match the identifier directly,
+	// not require a full call node structure.
+	if node.Type() == "call" {
+		if node.ChildByFieldName("receiver") == nil && node.ChildByFieldName("arguments") == nil {
+			return true
+		}
+	}
+	return false
 }
 
 func (*Pattern) IsAnchored(node *tree.Node) (bool, bool) {
@@ -211,7 +235,29 @@ func (*Pattern) TranslateContent(fromNodeType, toNodeType, content string) strin
 }
 
 func (*Pattern) IsRoot(node *tree.Node) bool {
-	return !slices.Contains([]string{"program"}, node.Type())
+	// Skip program node
+	if node.Type() == "program" {
+		return false
+	}
+
+	// Skip bare method calls (no receiver, no arguments) and use their
+	// method identifier as the root instead. In the new tree-sitter grammar,
+	// `find_by!` is parsed as call(method: identifier). We want auxiliary
+	// patterns like `find_by!` to compile to an identifier query, not a call query.
+	if node.Type() == "call" {
+		if node.ChildByFieldName("receiver") == nil && node.ChildByFieldName("arguments") == nil {
+			return false
+		}
+	}
+
+	// Skip body_statement nodes and use the actual content inside.
+	// In the new tree-sitter grammar, class/module/block bodies are wrapped
+	// in body_statement. Patterns should match the contents, not the wrapper.
+	if node.Type() == "body_statement" {
+		return false
+	}
+
+	return true
 }
 
 func (*Pattern) FixupVariableDummyValue(input []byte, node *tree.Node, dummyValue string) string {
@@ -221,9 +267,14 @@ func (*Pattern) FixupVariableDummyValue(input []byte, node *tree.Node, dummyValu
 		}
 
 		errorPrefix := input[ancestor.ContentStart.Byte:node.ContentStart.Byte]
+		// Capitalize class name: class $<NAME>
 		if classPatternErrorRegex.Match(errorPrefix) {
 			return strings.ToUpper(string(dummyValue[0])) + dummyValue[1:]
 		}
+		// Capitalize superclass: class Foo < $<PARENT>
+		if superclassPatternErrorRegex.Match(errorPrefix) {
+			return strings.ToUpper(string(dummyValue[0])) + dummyValue[1:]
+		}
 	}
 
 	return dummyValue
