hone 0.1.0

data/lib/hone/patterns/map_select_chain.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: array.map { ... }.select { ... } -> array.filter_map { ... }
+    #
+    # Chaining .map and .select creates an intermediate array.
+    # Using .filter_map combines both operations in one pass.
+    #
+    # From sqids-ruby commit aa4e253
+    class MapSelectChain < Base
+      self.pattern_id = :map_select_chain
+      self.optimization_type = :allocation
+
+      def visit_call_node(node)
+        super
+
+        # Look for: .select { } where receiver is .map (with block or symbol arg)
+        return unless node.name == :select && block_attached?(node)
+
+        receiver = node.receiver
+        return unless receiver.is_a?(Prism::CallNode) && receiver.name == :map && block_attached?(receiver)
+
+        add_finding(
+          node,
+          message: "Use `.filter_map { }` instead of `.map { }.select { }` to avoid intermediate array",
+          speedup: "Fewer allocations"
+        )
+      end
+    end
+  end
+end

data/lib/hone/patterns/parallel_assignment.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: Sequential array index assignments -> parallel assignment
+    #
+    # When assigning multiple variables from sequential array indices (0, 1, 2...),
+    # Ruby's parallel assignment syntax is more idiomatic and can be slightly faster
+    # as it avoids multiple array access operations.
+    #
+    # Example:
+    #   # Before
+    #   a = arr[0]
+    #   b = arr[1]
+    #   c = arr[2]
+    #
+    #   # After
+    #   a, b, c = arr
+    #
+    # Impact: Minor performance improvement, but more idiomatic Ruby
+    class ParallelAssignment < Base
+      self.pattern_id = :parallel_assignment
+      self.optimization_type = :cpu
+
+      def visit_statements_node(node)
+        check_sequential_assignments(node.body)
+        super
+      end
+
+      def visit_begin_node(node)
+        check_sequential_assignments(node.statements&.body || [])
+        super
+      end
+
+      private
+
+      def check_sequential_assignments(statements)
+        return if statements.nil? || statements.size < 2
+
+        i = 0
+        while i < statements.size
+          sequence = find_assignment_sequence(statements, i)
+
+          if sequence.size >= 2
+            report_sequence(sequence)
+            i += sequence.size
+          else
+            i += 1
+          end
+        end
+      end
+
+      def find_assignment_sequence(statements, start_index)
+        sequence = []
+        array_name = nil
+        expected_index = 0
+
+        (start_index...statements.size).each do |i|
+          stmt = statements[i]
+          break unless stmt.is_a?(Prism::LocalVariableWriteNode)
+
+          array_access = extract_array_access(stmt.value)
+          break unless array_access
+
+          name, index = array_access
+
+          if sequence.empty?
+            array_name = name
+            expected_index = index
+          end
+
+          break unless name == array_name && index == expected_index
+
+          sequence << stmt
+          expected_index += 1
+        end
+
+        sequence
+      end
+
+      def extract_array_access(node)
+        return nil unless node.is_a?(Prism::CallNode)
+        return nil unless node.name == :[]
+
+        args = node.arguments&.arguments
+        return nil unless args&.size == 1
+
+        index_node = args.first
+        return nil unless index_node.is_a?(Prism::IntegerNode)
+
+        index = index_node.value
+        return nil if index.negative?
+
+        receiver = node.receiver
+        array_name = extract_variable_name(receiver)
+        return nil unless array_name
+
+        [array_name, index]
+      end
+
+      def extract_variable_name(node)
+        case node
+        when Prism::LocalVariableReadNode
+          node.name
+        when Prism::InstanceVariableReadNode
+          node.name
+        when Prism::ClassVariableReadNode
+          node.name
+        when Prism::GlobalVariableReadNode
+          node.name
+        end
+      end
+
+      def report_sequence(sequence)
+        var_names = sequence.map(&:name).join(", ")
+        array_access = sequence.first.value
+        array_name = extract_variable_name(array_access.receiver)
+
+        add_finding(
+          sequence.first,
+          message: "Use parallel assignment `#{var_names} = #{array_name}` instead of sequential array index assignments",
+          speedup: "Minor, but more idiomatic"
+        )
+      end
+    end
+  end
+end

data/lib/hone/patterns/positive_predicate.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: (expr).positive? -> (expr) > 0
+    #
+    # In hot paths, the method call overhead of .positive? can add up.
+    # Direct comparison is faster.
+    #
+    # From sqids-ruby commit 8a74142
+    class PositivePredicate < Base
+      self.pattern_id = :positive_predicate
+      self.optimization_type = :cpu
+
+      def visit_call_node(node)
+        super
+        return unless node.name == :positive? && node.arguments.nil?
+
+        add_finding(
+          node,
+          message: "Use `> 0` instead of `.positive?` in hot paths to avoid method call overhead",
+          speedup: "Minor, but adds up in tight loops"
+        )
+      end
+    end
+  end
+end

data/lib/hone/patterns/range_include.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: range.include?(x) -> range.cover?(x)
+    #
+    # include? iterates the range to check membership.
+    # cover? just checks if value is between bounds (O(1)).
+    #
+    # Note: Semantics differ for non-numeric ranges. cover? checks bounds only,
+    # include? checks actual membership. For numeric ranges they're equivalent.
+    class RangeInclude < Base
+      self.pattern_id = :range_include
+      self.optimization_type = :cpu
+
+      def visit_call_node(node)
+        super
+
+        # Look for: .include?(x) on a range literal
+        return unless node.name == :include?
+        return unless node.arguments&.arguments&.size == 1
+
+        receiver = node.receiver
+        return unless receiver.is_a?(Prism::RangeNode)
+
+        add_finding(
+          node,
+          message: "Use `.cover?` instead of `.include?` on ranges for O(1) bounds check",
+          speedup: "O(n) iteration to O(1) comparison (for numeric ranges)"
+        )
+      end
+    end
+  end
+end

data/lib/hone/patterns/redundant_string_chars.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Detects `str.chars[i]` which should be `str[i]`
+    #
+    # str.chars[n] creates an array of single-character strings, then indexes it.
+    # Direct string indexing is much faster.
+    #
+    # @example Bad
+    #   str.chars[0]
+    #   str.chars.first
+    #   str.chars.last
+    #
+    # @example Good
+    #   str[0]
+    #   str[0]
+    #   str[-1]
+    #
+    class RedundantStringChars < Base
+      self.pattern_id = :redundant_string_chars
+      self.optimization_type = :allocation
+
+      def visit_call_node(node)
+        if chained_chars_index?(node)
+          replacement = suggest_replacement(node)
+          add_finding(
+            node,
+            message: "Use `#{replacement}` instead of `chars[...]` to avoid array allocation",
+            speedup: "Significant - avoids creating array of all characters"
+          )
+        elsif chained_chars_first_last?(node)
+          replacement = suggest_first_last_replacement(node)
+          add_finding(
+            node,
+            message: "Use `#{replacement}` instead of `chars.#{node.name}` to avoid array allocation",
+            speedup: "Significant - avoids creating array of all characters"
+          )
+        end
+
+        super
+      end
+
+      private
+
+      def chained_chars_index?(node)
+        return false unless node.name == :[]
+
+        receiver = node.receiver
+        return false unless receiver.is_a?(Prism::CallNode)
+        return false unless receiver.name == :chars
+
+        true
+      end
+
+      def chained_chars_first_last?(node)
+        return false unless %i[first last].include?(node.name)
+
+        receiver = node.receiver
+        return false unless receiver.is_a?(Prism::CallNode)
+        return false unless receiver.name == :chars
+
+        true
+      end
+
+      def suggest_replacement(node)
+        receiver = node.receiver.receiver
+        receiver_src = receiver ? receiver.slice : "str"
+        args = node.arguments&.arguments&.first
+        index = args ? args.slice : "i"
+        "#{receiver_src}[#{index}]"
+      end
+
+      def suggest_first_last_replacement(node)
+        receiver = node.receiver.receiver
+        receiver_src = receiver ? receiver.slice : "str"
+        index = (node.name == :first) ? "0" : "-1"
+        "#{receiver_src}[#{index}]"
+      end
+    end
+  end
+end

data/lib/hone/patterns/regexp_match.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: str =~ /pattern/ or /pattern/.match(str) for boolean -> str.match?(/pattern/)
+    #
+    # When the result of =~ or .match is only used for truthiness (in if/unless/ternary),
+    # using .match? avoids creating a MatchData object.
+    #
+    # Example:
+    #   # Bad - creates MatchData object
+    #   if str =~ /pattern/
+    #   if /pattern/.match(str)
+    #
+    #   # Good - returns boolean without allocation
+    #   if str.match?(/pattern/)
+    class RegexpMatch < Base
+      self.pattern_id = :regexp_match
+      self.optimization_type = :allocation
+
+      def initialize(file_path)
+        super
+        @in_boolean_context = false
+      end
+
+      # Track boolean contexts: if conditions
+      def visit_if_node(node)
+        visit_in_boolean_context(node.predicate)
+        node.statements&.accept(self)
+        node.subsequent&.accept(self)
+      end
+
+      # Track boolean contexts: unless conditions
+      def visit_unless_node(node)
+        visit_in_boolean_context(node.predicate)
+        node.statements&.accept(self)
+        node.else_clause&.accept(self)
+      end
+
+      # Track boolean contexts: while conditions
+      def visit_while_node(node)
+        visit_in_boolean_context(node.predicate)
+        node.statements&.accept(self)
+      end
+
+      # Track boolean contexts: until conditions
+      def visit_until_node(node)
+        visit_in_boolean_context(node.predicate)
+        node.statements&.accept(self)
+      end
+
+      # Track boolean contexts: ternary operator condition
+      def visit_ternary_node(node)
+        visit_in_boolean_context(node.predicate)
+        node.true_expression&.accept(self)
+        node.false_expression&.accept(self)
+      end
+
+      # Track boolean contexts: && and || operators
+      def visit_and_node(node)
+        visit_in_boolean_context(node.left)
+        visit_in_boolean_context(node.right)
+      end
+
+      def visit_or_node(node)
+        visit_in_boolean_context(node.left)
+        visit_in_boolean_context(node.right)
+      end
+
+      def visit_call_node(node)
+        super
+
+        if @in_boolean_context
+          check_regexp_match(node)
+        end
+      end
+
+      # Detect =~ operator (str =~ /pattern/ or /pattern/ =~ str)
+      def visit_match_last_line_node(node)
+        return unless @in_boolean_context
+
+        add_regexp_finding(node)
+      end
+
+      def visit_match_write_node(node)
+        return unless @in_boolean_context
+
+        add_regexp_finding(node)
+      end
+
+      private
+
+      def visit_in_boolean_context(node)
+        return unless node
+
+        with_context(:@in_boolean_context, true) do
+          node.accept(self)
+        end
+      end
+
+      def check_regexp_match(node)
+        # Check for =~ operator
+        if node.name == :=~
+          add_regexp_finding(node)
+          return
+        end
+
+        # Check for .match(str) without block
+        if node.name == :match && !block_attached?(node)
+          # Verify it has arguments (not just calling match on something)
+          return unless node.arguments&.arguments&.any?
+
+          add_regexp_finding(node)
+        end
+      end
+
+      def add_regexp_finding(node)
+        add_finding(
+          node,
+          message: "Use `.match?` instead of `=~` or `.match` when only checking for a match",
+          speedup: "Avoids creating MatchData object"
+        )
+      end
+    end
+  end
+end

data/lib/hone/patterns/reverse_each.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: array.reverse.each { } -> array.reverse_each { }
+    #
+    # Calling .reverse.each creates an intermediate reversed array.
+    # Using .reverse_each iterates in reverse order without allocation.
+    class ReverseEach < Base
+      self.pattern_id = :reverse_each
+      self.optimization_type = :allocation
+
+      def visit_call_node(node)
+        super
+
+        # Look for: .each { } where receiver is .reverse
+        return unless node.name == :each && block_attached?(node)
+
+        receiver = node.receiver
+        return unless receiver.is_a?(Prism::CallNode) && receiver.name == :reverse
+
+        add_finding(
+          node,
+          message: "Use `.reverse_each { }` instead of `.reverse.each { }` to avoid intermediate array",
+          speedup: "Avoids intermediate array allocation"
+        )
+      end
+    end
+  end
+end

data/lib/hone/patterns/reverse_first.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: array.reverse.first -> array.last
+    #         array.reverse.first(n) -> array.last(n).reverse
+    #
+    # reverse.first reverses the entire array then takes the first element(s).
+    # Using last directly accesses the end of the array without creating an
+    # intermediate reversed array.
+    class ReverseFirst < Base
+      self.pattern_id = :reverse_first
+      self.optimization_type = :allocation
+
+      def visit_call_node(node)
+        super
+
+        # Look for: .first or .first(n) where receiver is .reverse
+        return unless node.name == :first
+
+        receiver = node.receiver
+        return unless receiver.is_a?(Prism::CallNode) && receiver.name == :reverse
+
+        if node.arguments.nil?
+          add_finding(
+            node,
+            message: "Use `.last` instead of `.reverse.first` to avoid reversing entire array",
+            speedup: "Avoids reversing entire array"
+          )
+        else
+          add_finding(
+            node,
+            message: "Use `.last(n).reverse` instead of `.reverse.first(n)` to avoid reversing entire array",
+            speedup: "Avoids reversing entire array"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/hone/patterns/select_count.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: array.select { }.count -> array.count { }
+    #
+    # select { }.count creates a temporary array of matches then counts it.
+    # count { } counts matches directly without intermediate allocation.
+    class SelectCount < Base
+      self.pattern_id = :select_count
+      self.optimization_type = :allocation
+
+      def visit_call_node(node)
+        super
+
+        # Look for: .count/.size/.length (no args) where receiver is .select with block
+        return unless %i[count size length].include?(node.name)
+        return unless node.arguments.nil?
+
+        receiver = node.receiver
+        return unless receiver.is_a?(Prism::CallNode)
+        return unless receiver.name == :select && block_attached?(receiver)
+
+        add_finding(
+          node,
+          message: "Use `.count { }` instead of `.select { }.#{node.name}` to avoid intermediate array",
+          speedup: "Counts directly without allocating intermediate array"
+        )
+      end
+    end
+  end
+end

data/lib/hone/patterns/select_first.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: array.select { }.first -> array.detect { } / array.find { }
+    #
+    # select.first iterates the entire array building a new array, then takes first.
+    # detect/find stops iteration as soon as a match is found.
+    class SelectFirst < Base
+      self.pattern_id = :select_first
+      self.optimization_type = :allocation
+
+      def visit_call_node(node)
+        super
+
+        # Look for: .first where receiver is .select with a block
+        return unless node.name == :first && node.arguments.nil?
+
+        receiver = node.receiver
+        return unless receiver.is_a?(Prism::CallNode)
+        return unless receiver.name == :select && block_attached?(receiver)
+
+        add_finding(
+          node,
+          message: "Use `.detect { }` or `.find { }` instead of `.select { }.first` to stop at first match",
+          speedup: "Avoids iterating entire array and intermediate array allocation"
+        )
+      end
+    end
+  end
+end

data/lib/hone/patterns/select_map.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: array.select { }.map { } -> array.filter_map { }
+    #
+    # select.map creates an intermediate array from select, then maps over it.
+    # filter_map combines both operations in a single pass, avoiding the
+    # intermediate allocation.
+    class SelectMap < Base
+      self.pattern_id = :select_map
+      self.optimization_type = :allocation
+
+      def visit_call_node(node)
+        super
+
+        # Look for: .map { } where receiver is .select { }
+        return unless node.name == :map && block_attached?(node)
+
+        receiver = node.receiver
+        return unless receiver.is_a?(Prism::CallNode)
+        return unless receiver.name == :select && block_attached?(receiver)
+
+        add_finding(
+          node,
+          message: "Use `.filter_map { }` instead of `.select { }.map { }` to avoid intermediate array",
+          speedup: "Avoids intermediate array"
+        )
+      end
+    end
+  end
+end

data/lib/hone/patterns/shuffle_first.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: array.shuffle.first -> array.sample
+    #
+    # shuffle.first shuffles the entire array then takes the first element.
+    # sample directly selects a random element without creating intermediate array.
+    class ShuffleFirst < Base
+      self.pattern_id = :shuffle_first
+      self.optimization_type = :allocation
+
+      def visit_call_node(node)
+        super
+
+        # Look for: .first where receiver is .shuffle
+        return unless node.name == :first && node.arguments.nil?
+
+        receiver = node.receiver
+        return unless receiver.is_a?(Prism::CallNode) && receiver.name == :shuffle
+
+        add_finding(
+          node,
+          message: "Use `.sample` instead of `.shuffle.first` to avoid shuffling entire array",
+          speedup: "Avoids O(n) shuffle and intermediate array allocation"
+        )
+      end
+    end
+  end
+end

data/lib/hone/patterns/slice_with_length.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: str[n, str.length] -> str[n..]
+    #
+    # Endless range syntax avoids the length calculation.
+    #
+    # From sqids-ruby commit 9413b68
+    class SliceWithLength < Base
+      self.pattern_id = :slice_with_length
+      self.optimization_type = :cpu
+
+      def visit_call_node(node)
+        super
+
+        # Look for: receiver[offset, receiver.length] pattern
+        return unless node.name == :[] && node.arguments
+
+        args = node.arguments.arguments
+        return unless args&.length == 2
+
+        first_arg = args[0]
+        second_arg = args[1]
+
+        # Check if second arg is receiver.length or receiver.size
+        return unless second_arg.is_a?(Prism::CallNode)
+        return unless %i[length size].include?(second_arg.name)
+        return unless nodes_match?(node.receiver, second_arg.receiver)
+
+        add_finding(
+          node,
+          message: "Use endless range `[#{first_arg.location.slice}..]` instead of `[#{first_arg.location.slice}, #{second_arg.location.slice}]`",
+          speedup: "Minor, avoids length calculation"
+        )
+      end
+
+      private
+
+      # Simple check if two nodes represent the same variable/expression
+      def nodes_match?(node1, node2)
+        return false unless node1.instance_of?(node2.class)
+
+        node1.location.slice == node2.location.slice
+      end
+    end
+  end
+end