[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

swesmith/bug_gen/adapters/ruby.py

@@ -119,7 +119,9 @@ 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):
+        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)

swesmith/bug_gen/procedural/ruby/base.py

@@ -45,8 +45,11 @@ def walk(n):
     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:])
+        new_bytes = (
+            code_bytes[: node.start_byte]
+            + replacement.encode("utf8")
+            + code_bytes[node.end_byte :]
+        )
         return new_bytes.decode("utf8")
 
     def _remove_matching_nodes(
@@ -74,7 +77,9 @@ def collect(n):
 
         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:]
+            source_bytes = (
+                source_bytes[: node.start_byte] + source_bytes[node.end_byte :]
+            )
 
         modified_code = source_bytes.decode("utf8")
 

swesmith/bug_gen/procedural/ruby/control_flow.py

@@ -67,8 +67,12 @@ def collect(n):
                 continue
 
             # Extract the text of the actual statement content
-            then_content = source_bytes[then_stmts[0].start_byte:then_stmts[-1].end_byte]
-            else_content = source_bytes[else_stmts[0].start_byte:else_stmts[-1].end_byte]
+            then_content = source_bytes[
+                then_stmts[0].start_byte : then_stmts[-1].end_byte
+            ]
+            else_content = source_bytes[
+                else_stmts[0].start_byte : else_stmts[-1].end_byte
+            ]
 
             # Determine indentation for each branch by looking at the first
             # non-whitespace content position
@@ -78,7 +82,7 @@ def get_indent(node_list):
                 line_start = source_bytes.rfind(b"\n", 0, start)
                 if line_start == -1:
                     return b""
-                return source_bytes[line_start + 1:start]
+                return source_bytes[line_start + 1 : start]
 
             then_indent = get_indent(then_stmts)
             else_indent = get_indent(else_stmts)
@@ -91,7 +95,7 @@ def reindent(content, from_indent, to_indent):
                     if i == 0:
                         result.append(line)
                     elif line.startswith(from_indent):
-                        result.append(to_indent + line[len(from_indent):])
+                        result.append(to_indent + line[len(from_indent) :])
                     else:
                         result.append(line)
                 return b"\n".join(result)
@@ -101,14 +105,14 @@ def reindent(content, from_indent, to_indent):
 
             # Replace else body first (later in file), then then body
             source_bytes = (
-                source_bytes[:else_stmts[0].start_byte]
+                source_bytes[: else_stmts[0].start_byte]
                 + new_else
-                + source_bytes[else_stmts[-1].end_byte:]
+                + source_bytes[else_stmts[-1].end_byte :]
             )
             source_bytes = (
-                source_bytes[:then_stmts[0].start_byte]
+                source_bytes[: then_stmts[0].start_byte]
                 + new_then
-                + source_bytes[then_stmts[-1].end_byte:]
+                + source_bytes[then_stmts[-1].end_byte :]
             )
 
         return source_bytes.decode("utf8")
@@ -147,9 +151,9 @@ def collect(n):
                     if child.type == "body_statement":
                         # Collect top-level statements (skip comments)
                         statements = [
-                            c for c in child.children
-                            if c.type not in ("comment",)
-                            and c.start_byte != c.end_byte
+                            c
+                            for c in child.children
+                            if c.type not in ("comment",) and c.start_byte != c.end_byte
                         ]
                         if len(statements) >= 2:
                             modifications.append(statements)
@@ -171,9 +175,7 @@ def collect(n):
                 if len(statements) >= 2:
                     indices[0], indices[1] = indices[1], indices[0]
 
-            texts = [
-                source_bytes[s.start_byte:s.end_byte] for s in statements
-            ]
+            texts = [source_bytes[s.start_byte : s.end_byte] for s in statements]
             shuffled = [texts[i] for i in indices]
 
             first_start = statements[0].start_byte
@@ -186,9 +188,7 @@ def collect(n):
             new_content = (b"\n" + indent).join(shuffled)
 
             source_bytes = (
-                source_bytes[:first_start]
-                + new_content
-                + source_bytes[last_end:]
+                source_bytes[:first_start] + new_content + source_bytes[last_end:]
             )
 
         return source_bytes.decode("utf8")

swesmith/bug_gen/procedural/ruby/nil_introduction.py

@@ -4,7 +4,9 @@
 
 
 class SafeNavigationRemovalModifier(RubyProceduralModifier):
-    explanation: str = "A safe navigation operator (&.) has been removed, allowing nil to propagate."
+    explanation: str = (
+        "A safe navigation operator (&.) has been removed, allowing nil to propagate."
+    )
     name: str = "func_pm_ruby_safe_nav_removal"
     conditions: list = [CodeProperty.IS_FUNCTION, CodeProperty.HAS_FUNCTION_CALL]
 
@@ -21,7 +23,9 @@ def modify(self, code_entity: CodeEntity) -> BugRewrite:
         candidates = []
         for call in calls:
             for child in call.children:
-                if child.type == "&." or (hasattr(child, 'text') and child.text == b"&."):
+                if child.type == "&." or (
+                    hasattr(child, "text") and child.text == b"&."
+                ):
                     candidates.append(child)
 
         if not candidates:
@@ -42,7 +46,9 @@ def modify(self, code_entity: CodeEntity) -> BugRewrite:
 
 
 class OrDefaultRemovalModifier(RubyProceduralModifier):
-    explanation: str = "A fallback default (|| value) has been removed, allowing nil to propagate."
+    explanation: str = (
+        "A fallback default (|| value) has been removed, allowing nil to propagate."
+    )
     name: str = "func_pm_ruby_or_default_removal"
     conditions: list = [CodeProperty.IS_FUNCTION, CodeProperty.HAS_BINARY_OP]
 
@@ -58,7 +64,7 @@ def modify(self, code_entity: CodeEntity) -> BugRewrite:
         candidates = []
         for node in binaries:
             for child in node.children:
-                if hasattr(child, 'text') and child.text in (b"||", b"or"):
+                if hasattr(child, "text") and child.text in (b"||", b"or"):
                     candidates.append(node)
                     break
 
@@ -68,7 +74,9 @@ def modify(self, code_entity: CodeEntity) -> BugRewrite:
         target = self.rand.choice(candidates)
         # Replace with just the left operand
         left = target.children[0]
-        left_text = code_entity.src_code.encode("utf8")[left.start_byte:left.end_byte].decode("utf8")
+        left_text = code_entity.src_code.encode("utf8")[
+            left.start_byte : left.end_byte
+        ].decode("utf8")
 
         modified_code = self.replace_node(code_entity.src_code, target, left_text)
 
@@ -122,7 +130,9 @@ def modify(self, code_entity: CodeEntity) -> BugRewrite:
 
         call, receiver = self.rand.choice(candidates)
         src_bytes = code_entity.src_code.encode("utf8")
-        receiver_text = src_bytes[receiver.start_byte:receiver.end_byte].decode("utf8")
+        receiver_text = src_bytes[receiver.start_byte : receiver.end_byte].decode(
+            "utf8"
+        )
         modified_code = self.replace_node(code_entity.src_code, call, receiver_text)
 
         valid = self.validate_syntax(code_entity.src_code, modified_code)
@@ -140,7 +150,9 @@ def modify(self, code_entity: CodeEntity) -> BugRewrite:
 
 
 class BangMethodStripModifier(RubyProceduralModifier):
-    explanation: str = "A bang method (!) has been replaced with its non-raising variant."
+    explanation: str = (
+        "A bang method (!) has been replaced with its non-raising variant."
+    )
     name: str = "func_pm_ruby_bang_method_strip"
     conditions: list = [CodeProperty.IS_FUNCTION, CodeProperty.HAS_FUNCTION_CALL]
 
@@ -180,7 +192,9 @@ def modify(self, code_entity: CodeEntity) -> BugRewrite:
 
 
 class OrEqualsRemovalModifier(RubyProceduralModifier):
-    explanation: str = "A memoization operator (||=) has been replaced with plain assignment."
+    explanation: str = (
+        "A memoization operator (||=) has been replaced with plain assignment."
+    )
     name: str = "func_pm_ruby_or_equals_removal"
     conditions: list = [CodeProperty.IS_FUNCTION, CodeProperty.HAS_ASSIGNMENT]
 
@@ -196,7 +210,7 @@ def modify(self, code_entity: CodeEntity) -> BugRewrite:
         candidates = []
         for node in op_assigns:
             for child in node.children:
-                if hasattr(child, 'text') and child.text == b"||=":
+                if hasattr(child, "text") and child.text == b"||=":
                     candidates.append(child)
 
         if not candidates:

swesmith/bug_gen/procedural/ruby/operations.py

@@ -30,7 +30,14 @@
 LOGICAL_OPS = ["&&", "||"]
 KEYWORD_LOGICAL_OPS = ["and", "or"]
 
-ALL_BINARY_OPS = set(ARITHMETIC_OPS + BITWISE_OPS + COMPARISON_OPS + LOGICAL_OPS + KEYWORD_LOGICAL_OPS + ["**"])
+ALL_BINARY_OPS = set(
+    ARITHMETIC_OPS
+    + BITWISE_OPS
+    + COMPARISON_OPS
+    + LOGICAL_OPS
+    + KEYWORD_LOGICAL_OPS
+    + ["**"]
+)
 
 
 def _find_operator_child(node):
@@ -74,11 +81,13 @@ def collect(n):
             return None
 
         source_bytes = code_entity.src_code.encode("utf8")
-        for op_node, new_op in sorted(modifications, key=lambda x: x[0].start_byte, reverse=True):
+        for op_node, new_op in sorted(
+            modifications, key=lambda x: x[0].start_byte, reverse=True
+        ):
             source_bytes = (
-                source_bytes[:op_node.start_byte]
+                source_bytes[: op_node.start_byte]
                 + new_op.encode("utf8")
-                + source_bytes[op_node.end_byte:]
+                + source_bytes[op_node.end_byte :]
             )
 
         modified_code = source_bytes.decode("utf8")
@@ -137,11 +146,13 @@ def collect(n):
             return None
 
         source_bytes = code_entity.src_code.encode("utf8")
-        for op_node, new_op in sorted(modifications, key=lambda x: x[0].start_byte, reverse=True):
+        for op_node, new_op in sorted(
+            modifications, key=lambda x: x[0].start_byte, reverse=True
+        ):
             source_bytes = (
-                source_bytes[:op_node.start_byte]
+                source_bytes[: op_node.start_byte]
                 + new_op.encode("utf8")
-                + source_bytes[op_node.end_byte:]
+                + source_bytes[op_node.end_byte :]
             )
 
         modified_code = source_bytes.decode("utf8")
@@ -199,15 +210,15 @@ def collect(n):
         for expr, left, op, right in sorted(
             modifications, key=lambda x: x[0].start_byte, reverse=True
         ):
-            left_text = source_bytes[left.start_byte:left.end_byte]
-            op_text = source_bytes[op.start_byte:op.end_byte]
-            right_text = source_bytes[right.start_byte:right.end_byte]
+            left_text = source_bytes[left.start_byte : left.end_byte]
+            op_text = source_bytes[op.start_byte : op.end_byte]
+            right_text = source_bytes[right.start_byte : right.end_byte]
 
             new_expr = right_text + b" " + op_text + b" " + left_text
             source_bytes = (
-                source_bytes[:expr.start_byte]
+                source_bytes[: expr.start_byte]
                 + new_expr
-                + source_bytes[expr.end_byte:]
+                + source_bytes[expr.end_byte :]
             )
 
         modified_code = source_bytes.decode("utf8")
@@ -273,11 +284,13 @@ def collect(n):
         for expr, replacement in sorted(
             modifications, key=lambda x: x[0].start_byte, reverse=True
         ):
-            replacement_text = source_bytes[replacement.start_byte:replacement.end_byte]
+            replacement_text = source_bytes[
+                replacement.start_byte : replacement.end_byte
+            ]
             source_bytes = (
-                source_bytes[:expr.start_byte]
+                source_bytes[: expr.start_byte]
                 + replacement_text
-                + source_bytes[expr.end_byte:]
+                + source_bytes[expr.end_byte :]
             )
 
         modified_code = source_bytes.decode("utf8")
@@ -337,9 +350,9 @@ def collect(n):
             modifications, key=lambda x: x[0].start_byte, reverse=True
         ):
             source_bytes = (
-                source_bytes[:const_node.start_byte]
+                source_bytes[: const_node.start_byte]
                 + new_value.encode("utf8")
-                + source_bytes[const_node.end_byte:]
+                + source_bytes[const_node.end_byte :]
             )
 
         modified_code = source_bytes.decode("utf8")

swesmith/bug_gen/procedural/ruby/ruby_specific.py

@@ -26,7 +26,7 @@ def modify(self, code_entity: CodeEntity) -> BugRewrite:
             text = node.text.decode("utf8")
             # Strip leading : to get the name
             name = text[1:]
-            if re.match(r'^[a-zA-Z_]\w*[?!]?$', name):
+            if re.match(r"^[a-zA-Z_]\w*[?!]?$", name):
                 candidates.append(("symbol_to_string", node, name))
 
         # Find simple strings ("foo") — no interpolation, alphanumeric
@@ -36,7 +36,7 @@ def modify(self, code_entity: CodeEntity) -> BugRewrite:
             content_nodes = [c for c in node.children if c.type == "string_content"]
             if len(content_nodes) == 1:
                 content = content_nodes[0].text.decode("utf8")
-                if re.match(r'^[a-zA-Z_]\w*[?!]?$', content):
+                if re.match(r"^[a-zA-Z_]\w*[?!]?$", content):
                     candidates.append(("string_to_symbol", node, content))
 
         if not candidates:
@@ -77,7 +77,8 @@ def modify(self, code_entity: CodeEntity) -> BugRewrite:
         # Collect two types of candidates
         block_params = self.find_nodes(tree.root_node, "block_parameters")
         yield_nodes = [
-            n for n in self.find_nodes(tree.root_node, "yield")
+            n
+            for n in self.find_nodes(tree.root_node, "yield")
             if any(c.type == "argument_list" for c in n.children)
         ]
 

swesmith/profiles/ruby.py

@@ -73,10 +73,15 @@ def parse_log_ruby_test(log: str) -> dict[str, str]:
             current_class = stripped[:-1]
             continue
         # test-unit verbose: "  test_name:   .: (0.001234)"
-        if current_class and ".: (" in stripped or "F: (" in stripped or "E: (" in stripped:
+        if (
+            current_class
+            and ".: (" in stripped
+            or "F: (" in stripped
+            or "E: (" in stripped
+        ):
             match = re.match(r"^(\S+):\s+([.FE]):\s+\(", stripped)
             if match:
-                test_name = f"{current_class}#{ match.group(1)}"
+                test_name = f"{current_class}#{match.group(1)}"
                 status_char = match.group(2)
                 if status_char == ".":
                     test_status_map[test_name] = TestStatus.PASSED.value