hone 0.1.0

data/lib/hone/patterns/block_to_proc.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: array.map { |x| x.to_s } -> array.map(&:to_s)
+    #
+    # When a block simply calls a single method on its parameter with no
+    # arguments, the Symbol#to_proc shorthand is more idiomatic and slightly
+    # more efficient.
+    #
+    # Examples:
+    #   # Bad: verbose block
+    #   array.map { |x| x.to_s }
+    #   array.select { |item| item.valid? }
+    #   # Good: Symbol#to_proc shorthand
+    #   array.map(&:to_s)
+    #   array.select(&:valid?)
+    class BlockToProc < Base
+      self.pattern_id = :block_to_proc
+      self.optimization_type = :cpu
+
+      # Methods that commonly take blocks and can use Symbol#to_proc
+      APPLICABLE_METHODS = %i[
+        map collect select find_all reject detect find
+        any? all? none? one? sort_by group_by partition
+        max_by min_by minmax_by count take_while drop_while
+        filter filter_map
+      ].freeze
+
+      def visit_call_node(node)
+        super
+
+        return unless APPLICABLE_METHODS.include?(node.name)
+        return unless node.block.is_a?(Prism::BlockNode)
+
+        block = node.block
+        return unless single_param_block?(block)
+        return unless block_body_is_single_method_call?(block)
+
+        param_name = extract_single_param_name(block)
+        method_name = extract_called_method_name(block)
+
+        return unless param_name && method_name
+
+        add_finding(
+          node,
+          message: "Use `.#{node.name}(&:#{method_name})` instead of `.#{node.name} { |#{param_name}| #{param_name}.#{method_name} }` for Symbol#to_proc shorthand",
+          speedup: "Minor, but more idiomatic Ruby"
+        )
+      end
+
+      private
+
+      def single_param_block?(block)
+        parameters = block.parameters
+        return false unless parameters.is_a?(Prism::BlockParametersNode)
+        return false unless parameters.parameters.is_a?(Prism::ParametersNode)
+
+        params = parameters.parameters
+        params.requireds.size == 1 &&
+          params.optionals.empty? &&
+          params.rest.nil? &&
+          params.keywords.empty? &&
+          params.keyword_rest.nil? &&
+          params.block.nil?
+      end
+
+      def block_body_is_single_method_call?(block)
+        body = block.body
+        return false unless body.is_a?(Prism::StatementsNode)
+        return false unless body.body.size == 1
+
+        statement = body.body.first
+        return false unless statement.is_a?(Prism::CallNode)
+
+        # The receiver should be a local variable read matching the block param
+        receiver = statement.receiver
+        return false unless receiver.is_a?(Prism::LocalVariableReadNode)
+
+        # The call should have no arguments
+        return false if statement.arguments && !statement.arguments.arguments.empty?
+
+        # The call should not have its own block
+        return false if statement.block
+
+        true
+      end
+
+      def extract_single_param_name(block)
+        param = block.parameters.parameters.requireds.first
+        case param
+        when Prism::RequiredParameterNode
+          param.name
+        end
+      end
+
+      def extract_called_method_name(block)
+        statement = block.body.body.first
+        receiver = statement.receiver
+
+        # Verify the receiver matches the block parameter
+        param_name = extract_single_param_name(block)
+        return nil unless receiver.name == param_name
+
+        statement.name
+      end
+    end
+  end
+end

data/lib/hone/patterns/bsearch_vs_find.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: sorted_array.find { |x| x >= target } -> sorted_array.bsearch { |x| x >= target }
+    #
+    # When searching sorted data for the first element matching a comparison,
+    # bsearch uses binary search (O(log n)) vs find's linear search (O(n)).
+    #
+    # This pattern is conservative and only reports when it detects:
+    # - find with a block containing >= or > comparison
+    # - The receiver name contains hints like "sorted" or common sorted collection names
+    class BsearchVsFind < Base
+      self.pattern_id = :bsearch_vs_find
+      self.optimization_type = :cpu
+
+      # Names that suggest the array is sorted
+      SORTED_HINTS = %w[sorted ordered ranked].freeze
+
+      def visit_call_node(node)
+        super
+
+        return unless node.name == :find
+        return unless block_attached?(node)
+
+        block = node.block
+        return unless block.is_a?(Prism::BlockNode)
+        return unless comparison_block?(block)
+        return unless likely_sorted_receiver?(node.receiver)
+
+        add_finding(
+          node,
+          message: "Consider `.bsearch { }` instead of `.find { }` for O(log n) search on sorted data",
+          speedup: "O(log n) vs O(n) for sorted data"
+        )
+      end
+
+      private
+
+      # Check if block body contains a >= or > comparison
+      def comparison_block?(block)
+        body = block.body
+        return false unless body.is_a?(Prism::StatementsNode)
+        return false unless body.body.size == 1
+
+        statement = body.body.first
+        comparison_expression?(statement)
+      end
+
+      def comparison_expression?(node)
+        return false unless node.is_a?(Prism::CallNode)
+
+        %i[>= > <= <].include?(node.name)
+      end
+
+      # Conservative check: only flag if receiver name hints at sorted data
+      def likely_sorted_receiver?(receiver)
+        return false unless receiver
+
+        name = extract_receiver_name(receiver)
+        return false unless name
+
+        name_str = name.to_s.downcase
+        SORTED_HINTS.any? { |hint| name_str.include?(hint) }
+      end
+
+      def extract_receiver_name(node)
+        case node
+        when Prism::LocalVariableReadNode
+          node.name
+        when Prism::InstanceVariableReadNode
+          node.name.to_s.delete_prefix("@")
+        when Prism::CallNode
+          # For method calls like foo.bar, use the method name
+          node.name
+        end
+      end
+    end
+  end
+end

data/lib/hone/patterns/chars_map_ord.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: str.chars.map(&:ord) -> str.codepoints
+    #
+    # The .chars.map(&:ord) chain creates an intermediate array of single-char
+    # strings, then maps each to its ordinal. Using .codepoints directly is
+    # faster and allocates less memory.
+    #
+    # From sqids-ruby commit 9413b68
+    class CharsMapOrd < Base
+      self.pattern_id = :chars_map_ord
+      self.optimization_type = :allocation
+
+      def visit_call_node(node)
+        super
+        # Look for: .map(&:ord) where receiver is .chars
+        return unless node.name == :map && block_arg_is_symbol?(node, :ord)
+
+        receiver = node.receiver
+        return unless receiver.is_a?(Prism::CallNode) && receiver.name == :chars
+
+        add_finding(
+          node,
+          message: "Use `.codepoints` instead of `.chars.map(&:ord)` to avoid intermediate array allocation",
+          speedup: "Fewer allocations"
+        )
+      end
+
+      private
+
+      def block_arg_is_symbol?(call_node, sym_name)
+        block_arg = call_node.block
+        return false unless block_arg.is_a?(Prism::BlockArgumentNode)
+
+        expr = block_arg.expression
+        expr.is_a?(Prism::SymbolNode) && expr.value == sym_name.to_s
+      end
+    end
+  end
+end

data/lib/hone/patterns/chars_to_variable.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Approach 1: Simple scope-limited variable tracking
+    #
+    # Detects when .chars is assigned to a variable and then used in ways
+    # that could be done directly on the string.
+    #
+    # @example Bad - allocates array just for indexing
+    #   chars = str.chars
+    #   chars[0]
+    #   chars.length
+    #   chars.each { |c| ... }
+    #
+    # @example Good - direct string operations
+    #   str[0]
+    #   str.length
+    #   str.each_char { |c| ... }
+    #
+    class CharsToVariable < Base
+      self.pattern_id = :chars_to_variable
+      self.optimization_type = :allocation
+
+      def initialize(file_path)
+        super
+        @scope_stack = []
+      end
+
+      # Track method scope
+      def visit_def_node(node)
+        with_scope { super }
+      end
+
+      # Track block scope
+      def visit_block_node(node)
+        with_scope { super }
+      end
+
+      # Track lambda scope
+      def visit_lambda_node(node)
+        with_scope { super }
+      end
+
+      # Track .chars assignments
+      def visit_local_variable_write_node(node)
+        super
+        track_chars_assignment(node)
+      end
+
+      # Check for inefficient usage of tracked variables
+      def visit_call_node(node)
+        super
+        check_inefficient_usage(node)
+      end
+
+      private
+
+      def with_scope
+        @scope_stack.push({})
+        yield
+      ensure
+        @scope_stack.pop
+      end
+
+      def current_scope
+        @scope_stack.last || {}
+      end
+
+      def track_chars_assignment(node)
+        return unless node.value.is_a?(Prism::CallNode)
+        return unless node.value.name == :chars
+        return if node.value.arguments&.arguments&.any? # chars with args is different
+
+        source_receiver = node.value.receiver
+        return unless source_receiver # Need to know what .chars was called on
+
+        current_scope[node.name] = {
+          source_code: source_receiver.slice,
+          assignment_line: node.location.start_line
+        }
+      end
+
+      def check_inefficient_usage(node)
+        return unless node.receiver.is_a?(Prism::LocalVariableReadNode)
+
+        var_name = node.receiver.name
+        info = current_scope[var_name]
+        return unless info
+
+        source = info[:source_code]
+
+        case node.name
+        when :[]
+          add_finding(
+            node,
+            message: "Use `#{source}[...]` directly instead of `.chars` variable indexing",
+            speedup: "Avoids allocating array of all characters"
+          )
+        when :length, :size
+          add_finding(
+            node,
+            message: "Use `#{source}.length` directly instead of `.chars.length`",
+            speedup: "Avoids allocating array of all characters"
+          )
+        when :each
+          return unless block_attached?(node)
+
+          add_finding(
+            node,
+            message: "Use `#{source}.each_char { }` instead of `.chars.each { }`",
+            speedup: "No intermediate array allocation"
+          )
+        when :first
+          add_finding(
+            node,
+            message: "Use `#{source}[0]` instead of `.chars.first`",
+            speedup: "Avoids allocating array of all characters"
+          )
+        when :last
+          add_finding(
+            node,
+            message: "Use `#{source}[-1]` instead of `.chars.last`",
+            speedup: "Avoids allocating array of all characters"
+          )
+        when :include?
+          add_finding(
+            node,
+            message: "Use `#{source}.include?(...)` directly on string",
+            speedup: "String#include? works without array allocation"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/hone/patterns/chars_to_variable_tainted.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Approach 2: Taint tracking version of CharsToVariable
+    #
+    # Same detection as CharsToVariable but using the TaintTrackingBase
+    # infrastructure. This allows comparison of both approaches.
+    #
+    # Advantages over simple approach:
+    # - Handles variable aliasing (x = chars; y = x; y[0])
+    # - Handles instance variables (@chars = str.chars)
+    # - Cleaner separation of concerns
+    # - Easier to extend for other patterns
+    #
+    # @example Detects aliased usage
+    #   chars = str.chars
+    #   x = chars        # Taint propagates to x
+    #   x[0]             # Still flagged!
+    #
+    class CharsToVariableTainted < TaintTrackingBase
+      self.pattern_id = :chars_to_variable_tainted
+      self.optimization_type = :allocation
+
+      protected
+
+      # Define what creates a taint: .chars calls
+      def taint_from_call(call_node)
+        return nil unless call_node.name == :chars
+        return nil if call_node.arguments&.arguments&.any?
+
+        source_receiver = call_node.receiver
+        return nil unless source_receiver
+
+        {
+          type: :chars_array,
+          source: source_receiver,
+          source_code: source_receiver.slice,
+          origin_line: call_node.location.start_line,
+          metadata: {}
+        }
+      end
+
+      # Check for problematic uses of tainted variables
+      def check_tainted_usage(call_node, var_name, taint_info)
+        return unless taint_info.type == :chars_array
+
+        source = taint_info.source_code
+        method_name = call_node.name
+
+        case method_name
+        when :[]
+          report_indexing(call_node, source)
+        when :length, :size
+          report_length(call_node, source)
+        when :each
+          report_each(call_node, source) if block_attached?(call_node)
+        when :first
+          report_first(call_node, source)
+        when :last
+          report_last(call_node, source)
+        when :include?
+          report_include(call_node, source)
+        when :map
+          report_map(call_node, source, var_name) if block_attached?(call_node)
+        when :join
+          # join actually needs the array - mark this usage as "necessary"
+          # In a more sophisticated version, we'd track this and not report
+          # the assignment if there's at least one necessary usage
+          nil
+        when :reverse, :sort, :shuffle, :sample
+          # These operations need the array
+          nil
+        end
+      end
+
+      private
+
+      def report_indexing(node, source)
+        add_finding(
+          node,
+          message: "Use `#{source}[...]` directly instead of `.chars` variable indexing",
+          speedup: "Avoids allocating array of all characters"
+        )
+      end
+
+      def report_length(node, source)
+        add_finding(
+          node,
+          message: "Use `#{source}.length` directly instead of `.chars.length`",
+          speedup: "Avoids allocating array of all characters"
+        )
+      end
+
+      def report_each(node, source)
+        add_finding(
+          node,
+          message: "Use `#{source}.each_char { }` instead of `.chars.each { }`",
+          speedup: "No intermediate array allocation"
+        )
+      end
+
+      def report_first(node, source)
+        add_finding(
+          node,
+          message: "Use `#{source}[0]` instead of `.chars.first`",
+          speedup: "Avoids allocating array of all characters"
+        )
+      end
+
+      def report_last(node, source)
+        add_finding(
+          node,
+          message: "Use `#{source}[-1]` instead of `.chars.last`",
+          speedup: "Avoids allocating array of all characters"
+        )
+      end
+
+      def report_include(node, source)
+        add_finding(
+          node,
+          message: "Use `#{source}.include?(...)` directly on string",
+          speedup: "String#include? works without array allocation"
+        )
+      end
+
+      def report_map(node, source, var_name)
+        add_finding(
+          node,
+          message: "Consider `#{source}.each_char.map { }` instead of `#{var_name}.map { }`",
+          speedup: "Uses lazy enumerator, may reduce allocations"
+        )
+      end
+    end
+  end
+end

data/lib/hone/patterns/constant_regexp.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: /pattern/ inside method -> extract to constant
+    #
+    # Regexp literals are recompiled each time the code is executed.
+    # Extracting to a constant compiles the regexp once at load time.
+    #
+    # Example:
+    #   # Bad - recompiles regexp on each call
+    #   def process(str)
+    #     str.gsub(/\s+/, ' ')
+    #   end
+    #
+    #   # Good - compiled once at load time
+    #   WHITESPACE = /\s+/
+    #   def process(str)
+    #     str.gsub(WHITESPACE, ' ')
+    #   end
+    #
+    # Note: Only flags regexps without interpolation, as interpolated regexps
+    # may need to be dynamic.
+    class ConstantRegexp < Base
+      self.pattern_id = :constant_regexp
+      self.optimization_type = :allocation
+
+      def initialize(file_path)
+        super
+        @in_method = false
+      end
+
+      # Track when we're inside a method definition
+      def visit_def_node(node)
+        with_context(:@in_method, true) { super }
+      end
+
+      # Detect static regexp literals inside methods
+      def visit_regular_expression_node(node)
+        super
+
+        return unless @in_method
+
+        # Skip if the regexp is very short/simple - the overhead is minimal
+        # and extracting trivially small regexps hurts readability
+        content = node.content
+        return if content.length < 3
+
+        add_finding(
+          node,
+          message: "Consider extracting regexp `/#{escape_for_message(content)}/` to a constant",
+          speedup: "Avoids recompiling regexp on each call"
+        )
+      end
+
+      # Skip interpolated regexps as they may need to be dynamic
+      def visit_interpolated_regular_expression_node(node)
+        # Don't call super - we intentionally don't flag interpolated regexps
+        # as they often need to be dynamic
+      end
+
+      private
+
+      def escape_for_message(content)
+        # Truncate long regexps and escape for display
+        if content.length > 20
+          content[0..17] + "..."
+        else
+          content
+        end
+      end
+    end
+  end
+end

data/lib/hone/patterns/count_vs_size.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: array.count (no block) -> array.size or array.length
+    #
+    # When `count` is called without a block on an Array, it's slower than
+    # `size`/`length` because count is designed for enumerables and does more work.
+    # `.size` and `.length` are O(1) operations for Arrays as they simply return
+    # the cached length, while `.count` may iterate.
+    class CountVsSize < Base
+      self.pattern_id = :count_vs_size
+      self.optimization_type = :cpu
+
+      def visit_call_node(node)
+        super
+        # Look for: receiver.count with no arguments and no block
+        return unless node.name == :count && no_arguments?(node) && node.block.nil?
+
+        add_finding(
+          node,
+          message: "Use `.size` or `.length` instead of `.count` when counting all elements",
+          speedup: "Minor, but `.size` is O(1) for Arrays vs `.count` which may iterate"
+        )
+      end
+
+      private
+
+      # Check if the node has no arguments
+      def no_arguments?(node)
+        node.arguments.nil? || node.arguments.arguments.empty?
+      end
+    end
+  end
+end

data/lib/hone/patterns/divmod.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: [n / d, n % d] -> n.divmod(d)
+    #
+    # When you need both quotient and remainder, divmod computes them
+    # in a single operation instead of performing division twice.
+    class Divmod < Base
+      self.pattern_id = :divmod
+      self.optimization_type = :cpu
+
+      def visit_array_node(node)
+        super
+
+        elements = node.elements
+        return unless elements.size == 2
+
+        first = elements[0]
+        second = elements[1]
+
+        return unless division_operation?(first) && modulo_operation?(second)
+        return unless same_operands?(first, second)
+
+        add_finding(
+          node,
+          message: "Use `.divmod` instead of `[n / d, n % d]` for single operation",
+          speedup: "Single operation instead of two"
+        )
+      end
+
+      private
+
+      def division_operation?(node)
+        return false unless node.is_a?(Prism::CallNode)
+
+        node.name == :/
+      end
+
+      def modulo_operation?(node)
+        return false unless node.is_a?(Prism::CallNode)
+
+        node.name == :%
+      end
+
+      def same_operands?(div_node, mod_node)
+        # Both should have receiver (dividend) and one argument (divisor)
+        return false unless div_node.receiver && mod_node.receiver
+        return false unless div_node.arguments&.arguments&.size == 1
+        return false unless mod_node.arguments&.arguments&.size == 1
+
+        # Compare receivers (dividend)
+        return false unless nodes_equivalent?(div_node.receiver, mod_node.receiver)
+
+        # Compare arguments (divisor)
+        div_arg = div_node.arguments.arguments.first
+        mod_arg = mod_node.arguments.arguments.first
+        nodes_equivalent?(div_arg, mod_arg)
+      end
+
+      # Simple equivalence check for common node types
+      def nodes_equivalent?(node1, node2)
+        return false unless node1.instance_of?(node2.class)
+
+        case node1
+        when Prism::LocalVariableReadNode
+          node1.name == node2.name
+        when Prism::InstanceVariableReadNode
+          node1.name == node2.name
+        when Prism::ClassVariableReadNode
+          node1.name == node2.name
+        when Prism::GlobalVariableReadNode
+          node1.name == node2.name
+        when Prism::IntegerNode
+          node1.value == node2.value
+        when Prism::CallNode
+          # For method calls, check name and receiver
+          return false unless node1.name == node2.name
+
+          if node1.receiver && node2.receiver
+            nodes_equivalent?(node1.receiver, node2.receiver)
+          else
+            node1.receiver.nil? && node2.receiver.nil?
+          end
+        else
+          # For other node types, compare the source directly
+          node1.location.slice == node2.location.slice
+        end
+      end
+    end
+  end
+end