Support Ruby procedural modifications

scripts/bug_gen_modal.py

@@ -133,6 +133,7 @@ def custom_exception_handler(loop, context):
     "typescript": "TypeScriptProfile",
     "golang": "GoProfile",
     "go": "GoProfile",
+    "ruby": "RubyProfile",
     "rust": "RustProfile",
     "java": "JavaProfile",
     "c": "CProfile",

swesmith/bug_gen/adapters/ruby.py

@@ -1,4 +1,4 @@
-from swesmith.constants import TODO_REWRITE, CodeEntity
+from swesmith.constants import TODO_REWRITE, CodeEntity, CodeProperty
 from tree_sitter import Language, Parser, Query, QueryCursor
 import tree_sitter_ruby as tsr
 import warnings
@@ -100,6 +100,63 @@ def walk(node) -> int:
 
         return 1 + walk(self.node)
 
+    def _analyze_properties(self):
+        """Analyze Ruby code properties."""
+        node = self.node
+        if node.type in ["method", "singleton_method"]:
+            self._tags.add(CodeProperty.IS_FUNCTION)
+        self._walk_for_properties(node)
+
+    def _walk_for_properties(self, n):
+        """Walk the AST and analyze properties."""
+        self._check_control_flow(n)
+        self._check_operations(n)
+        self._check_expressions(n)
+        for child in n.children:
+            self._walk_for_properties(child)
+
+    def _check_control_flow(self, n):
+        """Check for control flow patterns."""
+        if n.type in ["if", "unless", "if_modifier", "unless_modifier"]:
+            self._tags.add(CodeProperty.HAS_IF)
+        if n.type in ["if", "unless"] and any(
+            c.type in ["else", "elsif"] for c in n.children
+        ):
+            self._tags.add(CodeProperty.HAS_IF_ELSE)
+        if n.type in ["while", "until", "for", "while_modifier", "until_modifier"]:
+            self._tags.add(CodeProperty.HAS_LOOP)
+        if n.type in ["rescue", "ensure"]:
+            self._tags.add(CodeProperty.HAS_EXCEPTION)
+
+    def _check_operations(self, n):
+        """Check for various operations."""
+        if n.type in ["element_reference", "element_assignment"]:
+            self._tags.add(CodeProperty.HAS_LIST_INDEXING)
+        if n.type == "call":
+            self._tags.add(CodeProperty.HAS_FUNCTION_CALL)
+        if n.type == "return":
+            self._tags.add(CodeProperty.HAS_RETURN)
+        if n.type in ["assignment", "operator_assignment"]:
+            self._tags.add(CodeProperty.HAS_ASSIGNMENT)
+        if n.type in ["lambda", "block", "do_block"]:
+            self._tags.add(CodeProperty.HAS_LAMBDA)
+
+    def _check_expressions(self, n):
+        """Check expression patterns."""
+        if n.type == "binary":
+            self._tags.add(CodeProperty.HAS_BINARY_OP)
+            for child in n.children:
+                if hasattr(child, "text"):
+                    text = child.text.decode("utf-8")
+                    if text in ["&&", "||", "and", "or"]:
+                        self._tags.add(CodeProperty.HAS_BOOL_OP)
+                    elif text in ["<", ">", "<=", ">="]:
+                        self._tags.add(CodeProperty.HAS_OFF_BY_ONE)
+        if n.type == "unary":
+            self._tags.add(CodeProperty.HAS_UNARY_OP)
+        if n.type == "conditional":  # Ruby ternary: cond ? a : b
+            self._tags.add(CodeProperty.HAS_TERNARY)
+
 
 def get_entities_from_file_rb(
     entities: list[RubyEntity],

swesmith/bug_gen/procedural/__init__.py

@@ -12,6 +12,7 @@
 from swesmith.bug_gen.procedural.java import MODIFIERS_JAVA
 from swesmith.bug_gen.procedural.javascript import MODIFIERS_JAVASCRIPT
 from swesmith.bug_gen.procedural.python import MODIFIERS_PYTHON
+from swesmith.bug_gen.procedural.ruby import MODIFIERS_RUBY
 from swesmith.bug_gen.procedural.rust import MODIFIERS_RUST
 from swesmith.bug_gen.procedural.typescript import MODIFIERS_TYPESCRIPT
 
@@ -25,6 +26,7 @@
     ".hpp": MODIFIERS_CPP,
     ".js": MODIFIERS_JAVASCRIPT,
     ".py": MODIFIERS_PYTHON,
+    ".rb": MODIFIERS_RUBY,
     ".rs": MODIFIERS_RUST,
     ".ts": MODIFIERS_TYPESCRIPT,
     ".tsx": MODIFIERS_TYPESCRIPT,

swesmith/bug_gen/procedural/ruby/__init__.py

@@ -0,0 +1,57 @@
+from swesmith.bug_gen.procedural.base import ProceduralModifier
+from swesmith.bug_gen.procedural.ruby.control_flow import (
+    ControlIfElseInvertModifier,
+    ControlShuffleLinesModifier,
+    GuardClauseInvertModifier,
+)
+from swesmith.bug_gen.procedural.ruby.nil_introduction import (
+    BangMethodStripModifier,
+    NilGuardRemovalModifier,
+    OrDefaultRemovalModifier,
+    OrEqualsRemovalModifier,
+    PresenceStripModifier,
+    SafeNavigationRemovalModifier,
+)
+from swesmith.bug_gen.procedural.ruby.operations import (
+    OperationBreakChainsModifier,
+    OperationChangeConstantsModifier,
+    OperationChangeModifier,
+    OperationFlipOperatorModifier,
+    OperationSwapOperandsModifier,
+)
+from swesmith.bug_gen.procedural.ruby.remove import (
+    RemoveAssignModifier,
+    RemoveConditionalModifier,
+    RemoveLoopModifier,
+    RemoveRescueEnsureModifier,
+)
+from swesmith.bug_gen.procedural.ruby.ruby_specific import (
+    BlockMutationModifier,
+    SymbolStringSwapModifier,
+)
+
+MODIFIERS_RUBY: list[ProceduralModifier] = [
+    # Standard modifiers (CommonPMs)
+    ControlIfElseInvertModifier(likelihood=0.75),
+    ControlShuffleLinesModifier(likelihood=0.75),
+    OperationChangeModifier(likelihood=0.4),
+    OperationFlipOperatorModifier(likelihood=0.4),
+    OperationSwapOperandsModifier(likelihood=0.4),
+    OperationBreakChainsModifier(likelihood=0.3),
+    OperationChangeConstantsModifier(likelihood=0.4),
+    RemoveAssignModifier(likelihood=0.25),
+    RemoveConditionalModifier(likelihood=0.25),
+    RemoveLoopModifier(likelihood=0.25),
+    # Ruby-specific
+    GuardClauseInvertModifier(likelihood=0.6),
+    RemoveRescueEnsureModifier(likelihood=0.4),
+    BlockMutationModifier(likelihood=0.4),
+    SymbolStringSwapModifier(likelihood=0.5),
+    # Nil introduction
+    SafeNavigationRemovalModifier(likelihood=0.5),
+    OrDefaultRemovalModifier(likelihood=0.4),
+    PresenceStripModifier(likelihood=0.5),
+    BangMethodStripModifier(likelihood=0.4),
+    OrEqualsRemovalModifier(likelihood=0.4),
+    NilGuardRemovalModifier(likelihood=0.5),
+]

swesmith/bug_gen/procedural/ruby/base.py

@@ -0,0 +1,108 @@
+from abc import ABC
+
+import tree_sitter_ruby as tsruby
+from tree_sitter import Language, Parser
+
+from swesmith.bug_gen.procedural.base import ProceduralModifier
+from swesmith.constants import BugRewrite, CodeEntity
+
+RUBY_LANGUAGE = Language(tsruby.language())
+
+
+class RubyProceduralModifier(ProceduralModifier, ABC):
+    """Base class for Ruby-specific procedural modifications."""
+
+    @staticmethod
+    def validate_syntax(original: str, modified: str) -> bool | None:
+        """Return True if valid, False if errors, None if unchanged."""
+        if original == modified:
+            return None
+        parser = Parser(RUBY_LANGUAGE)
+        tree = parser.parse(bytes(modified, "utf8"))
+
+        def has_errors(node):
+            if node.type in ("ERROR", "MISSING"):
+                return True
+            return any(has_errors(c) for c in node.children)
+
+        return not has_errors(tree.root_node)
+
+    @staticmethod
+    def find_nodes(node, *types) -> list:
+        """Recursively find all AST nodes matching any of the given types.
+
+        Note: tree-sitter Ruby reuses the type name for both compound
+        statement nodes and their keyword tokens (e.g. ``while`` appears
+        as both the loop node and its keyword child). Callers searching
+        for compound statements like ``while``, ``if``, ``rescue`` etc.
+        should filter out leaf nodes (``n.children == 0``) to avoid
+        matching bare keywords.
+        """
+        results = []
+
+        def walk(n):
+            if n.type in types:
+                results.append(n)
+            for child in n.children:
+                walk(child)
+
+        walk(node)
+        return results
+
+    @staticmethod
+    def replace_node(code: str, node, replacement: str) -> str:
+        """Replace a tree-sitter node's text via byte offsets."""
+        code_bytes = code.encode("utf8")
+        new_bytes = (
+            code_bytes[: node.start_byte]
+            + replacement.encode("utf8")
+            + code_bytes[node.end_byte :]
+        )
+        return new_bytes.decode("utf8")
+
+    def _remove_matching_nodes(
+        self, code_entity: CodeEntity, *node_types: str, validate: bool = False
+    ) -> BugRewrite | None:
+        """Remove AST nodes matching the given types from the source code."""
+        if not self.flip():
+            return None
+
+        parser = Parser(RUBY_LANGUAGE)
+        tree = parser.parse(bytes(code_entity.src_code, "utf8"))
+
+        removals = []
+
+        def collect(n):
+            # Keyword tokens (e.g. `while` inside while_modifier) are leaf
+            # nodes in tree-sitter; compound statements always have children.
+            if n.type in node_types and n.children and self.flip():
+                removals.append(n)
+                return  # skip children to avoid stale byte offsets on nested removals
+            for child in n.children:
+                collect(child)
+
+        collect(tree.root_node)
+
+        if not removals:
+            return None
+
+        source_bytes = code_entity.src_code.encode("utf8")
+        for node in sorted(removals, key=lambda x: x.start_byte, reverse=True):
+            source_bytes = (
+                source_bytes[: node.start_byte] + source_bytes[node.end_byte :]
+            )
+
+        modified_code = source_bytes.decode("utf8")
+
+        if validate:
+            valid = self.validate_syntax(code_entity.src_code, modified_code)
+            if not valid:
+                return None
+        elif modified_code == code_entity.src_code:
+            return None
+
+        return BugRewrite(
+            rewrite=modified_code,
+            explanation=self.explanation,
+            strategy=self.name,
+        )