hone 0.1.0

data/lib/hone/patterns/sort_by_first.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: array.sort_by { }.first -> array.min_by { }
+    #
+    # sort_by { block }.first sorts the entire array then takes the first element.
+    # min_by { block } directly finds the minimum without creating intermediate array.
+    class SortByFirst < Base
+      self.pattern_id = :sort_by_first
+      self.optimization_type = :allocation
+
+      def visit_call_node(node)
+        super
+
+        # Look for: .first where receiver is .sort_by { block }
+        return unless node.name == :first && node.arguments.nil?
+
+        receiver = node.receiver
+        return unless receiver.is_a?(Prism::CallNode) && receiver.name == :sort_by
+        return unless block_attached?(receiver)
+
+        add_finding(
+          node,
+          message: "Use `.min_by { }` instead of `.sort_by { }.first` to avoid sorting entire array",
+          speedup: "Avoids sorting entire array"
+        )
+      end
+    end
+  end
+end

data/lib/hone/patterns/sort_by_last.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: array.sort_by { }.last -> array.max_by { }
+    #
+    # sort_by { block }.last sorts the entire array then takes the last element.
+    # max_by { block } directly finds the maximum without creating intermediate array.
+    class SortByLast < Base
+      self.pattern_id = :sort_by_last
+      self.optimization_type = :allocation
+
+      def visit_call_node(node)
+        super
+
+        # Look for: .last where receiver is .sort_by { block }
+        return unless node.name == :last && node.arguments.nil?
+
+        receiver = node.receiver
+        return unless receiver.is_a?(Prism::CallNode) && receiver.name == :sort_by
+        return unless block_attached?(receiver)
+
+        add_finding(
+          node,
+          message: "Use `.max_by { }` instead of `.sort_by { }.last` to avoid sorting entire array",
+          speedup: "Avoids sorting entire array"
+        )
+      end
+    end
+  end
+end

data/lib/hone/patterns/sort_first.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: array.sort.first -> array.min, array.sort.last -> array.max
+    #
+    # sort.first/last sorts the entire array O(n log n) then takes one element.
+    # min/max finds the element in a single O(n) pass without sorting.
+    class SortFirst < Base
+      self.pattern_id = :sort_first
+      self.optimization_type = :allocation
+
+      def visit_call_node(node)
+        super
+
+        return unless %i[first last].include?(node.name) && node.arguments.nil?
+
+        receiver = node.receiver
+        return unless receiver.is_a?(Prism::CallNode)
+
+        case [receiver.name, node.name]
+        when [:sort, :first]
+          add_finding(
+            node,
+            message: "Use `.min` instead of `.sort.first` to find minimum in O(n) without sorting",
+            speedup: "O(n log n) sort to O(n) single pass, no intermediate array"
+          )
+        when [:sort, :last]
+          add_finding(
+            node,
+            message: "Use `.max` instead of `.sort.last` to find maximum in O(n) without sorting",
+            speedup: "O(n log n) sort to O(n) single pass, no intermediate array"
+          )
+        when [:sort_by, :first]
+          return unless block_attached?(receiver)
+          add_finding(
+            node,
+            message: "Use `.min_by { }` instead of `.sort_by { }.first` to find minimum in O(n)",
+            speedup: "O(n log n) sort to O(n) single pass, no intermediate array"
+          )
+        when [:sort_by, :last]
+          return unless block_attached?(receiver)
+          add_finding(
+            node,
+            message: "Use `.max_by { }` instead of `.sort_by { }.last` to find maximum in O(n)",
+            speedup: "O(n log n) sort to O(n) single pass, no intermediate array"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/hone/patterns/sort_last.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: array.sort.last -> array.max
+    #
+    # sort.last sorts the entire array then takes the last element.
+    # max directly finds the maximum without creating intermediate array.
+    class SortLast < Base
+      self.pattern_id = :sort_last
+      self.optimization_type = :allocation
+
+      def visit_call_node(node)
+        super
+
+        # Look for: .last or .last(n) where receiver is .sort
+        return unless node.name == :last
+
+        receiver = node.receiver
+        return unless receiver.is_a?(Prism::CallNode) && receiver.name == :sort
+
+        add_finding(
+          node,
+          message: "Use `.max` instead of `.sort.last` to avoid sorting entire array",
+          speedup: "Avoids sorting entire array"
+        )
+      end
+    end
+  end
+end

data/lib/hone/patterns/sort_reverse.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: array.sort.reverse -> array.sort { |a, b| b <=> a }
+    #
+    # Calling .sort.reverse creates an intermediate sorted array, then
+    # reverses it. Sorting with a descending comparator avoids the
+    # intermediate array allocation.
+    #
+    # Example:
+    #   # Bad - creates intermediate array
+    #   array.sort.reverse
+    #
+    #   # Good - sorts in descending order directly
+    #   array.sort { |a, b| b <=> a }
+    #
+    # Note: For sort_by, use: array.sort_by { |x| -x.value } for numeric values
+    class SortReverse < Base
+      self.pattern_id = :sort_reverse
+      self.optimization_type = :allocation
+
+      def visit_call_node(node)
+        super
+
+        # Look for: .reverse where receiver is .sort or .sort_by
+        return unless node.name == :reverse
+
+        receiver = node.receiver
+        return unless receiver.is_a?(Prism::CallNode)
+
+        case receiver.name
+        when :sort
+          # .sort.reverse -> .sort { |a, b| b <=> a }
+          add_finding(
+            node,
+            message: "Use `.sort { |a, b| b <=> a }` instead of `.sort.reverse` to avoid intermediate array",
+            speedup: "Avoids creating intermediate sorted array"
+          )
+        when :sort_by
+          # .sort_by { }.reverse -> consider negating the sort key
+          return unless block_attached?(receiver)
+
+          add_finding(
+            node,
+            message: "Consider negating the sort key in `.sort_by` instead of calling `.reverse`",
+            speedup: "Avoids creating intermediate sorted array"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/hone/patterns/string_casecmp.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: str.downcase == other.downcase -> str.casecmp?(other)
+    #
+    # casecmp? performs case-insensitive comparison without creating
+    # intermediate lowercase/uppercase strings, reducing allocations.
+    class StringCasecmp < Base
+      self.pattern_id = :string_casecmp
+      self.optimization_type = :allocation
+
+      def visit_call_node(node)
+        super
+
+        return unless node.name == :==
+
+        # The receiver should be a call to downcase or upcase
+        receiver = node.receiver
+        return unless case_conversion_call?(receiver)
+
+        # The argument should also be a call to downcase or upcase
+        args = node.arguments&.arguments
+        return unless args&.size == 1
+
+        arg = args[0]
+        return unless case_conversion_call?(arg)
+
+        # Both should use the same case conversion method
+        receiver_method = receiver.name
+        arg_method = arg.name
+        return unless receiver_method == arg_method
+
+        method_name = (receiver_method == :downcase) ? "downcase" : "upcase"
+
+        add_finding(
+          node,
+          message: "Use `.casecmp?(other)` instead of `.#{method_name} == other.#{method_name}`",
+          speedup: "Avoids creating intermediate lowercase strings"
+        )
+      end
+
+      private
+
+      def case_conversion_call?(node)
+        return false unless node.is_a?(Prism::CallNode)
+
+        (node.name == :downcase || node.name == :upcase) &&
+          node.arguments.nil? &&
+          !block_attached?(node)
+      end
+    end
+  end
+end

data/lib/hone/patterns/string_chars_each.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Detects `str.chars.each { }` which should be `str.each_char { }`
+    #
+    # chars.each creates an intermediate array of single-character strings.
+    # each_char iterates directly without allocation.
+    #
+    # @example Bad
+    #   str.chars.each { |c| puts c }
+    #
+    # @example Good
+    #   str.each_char { |c| puts c }
+    #
+    class StringCharsEach < Base
+      self.pattern_id = :string_chars_each
+      self.optimization_type = :allocation
+
+      def visit_call_node(node)
+        if chained_chars_each?(node)
+          replacement = suggest_replacement(node)
+          add_finding(
+            node,
+            message: "Use `#{replacement}` instead of `chars.each` to avoid intermediate array allocation",
+            speedup: "No intermediate array allocation"
+          )
+        end
+
+        super
+      end
+
+      private
+
+      def chained_chars_each?(node)
+        return false unless node.name == :each && has_block?(node)
+
+        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"
+        "#{receiver_src}.each_char { ... }"
+      end
+
+      def has_block?(node)
+        node.block.is_a?(Prism::BlockNode) || node.block.is_a?(Prism::BlockArgumentNode)
+      end
+    end
+  end
+end

data/lib/hone/patterns/string_concat_in_loop.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: String concatenation (`+=`) inside a loop -> use `<<` or array join
+    #
+    # Each string `+=` operation creates a new string object, copying all previous
+    # content. In a loop, this leads to O(n^2) memory allocations and copies.
+    # Using `<<` mutates the string in place, avoiding allocations.
+    #
+    # Example:
+    #   # Bad - O(n^2) allocations
+    #   items.each { |item| result += item.to_s }
+    #
+    #   # Good - O(n) with in-place mutation
+    #   items.each { |item| result << item.to_s }
+    #
+    #   # Good - collect and join once
+    #   result = items.map(&:to_s).join
+    #
+    # Impact: Significant in tight loops, avoids O(n^2) string copying
+    class StringConcatInLoop < Base
+      self.pattern_id = :string_concat_in_loop
+      self.optimization_type = :allocation
+
+      LOOP_METHODS = %i[each each_with_index each_with_object map collect
+        times upto downto step loop].freeze
+
+      def initialize(file_path)
+        super
+        @in_loop = false
+      end
+
+      # Track when we enter/exit while loops
+      def visit_while_node(node)
+        with_context(:@in_loop, true) { super }
+      end
+
+      # Track when we enter/exit until loops
+      def visit_until_node(node)
+        with_context(:@in_loop, true) { super }
+      end
+
+      # Track when we enter/exit for loops
+      def visit_for_node(node)
+        with_context(:@in_loop, true) { super }
+      end
+
+      # Handle block-based loops (.each, .times, .map, loop, etc.)
+      def visit_call_node(node)
+        if loop_method?(node) && node.block
+          with_context(:@in_loop, true) { super }
+        else
+          super
+        end
+      end
+
+      # Detect local variable += (e.g., str += "x")
+      def visit_local_variable_operator_write_node(node)
+        check_string_concat(node)
+        super
+      end
+
+      # Detect instance variable += (e.g., @str += "x")
+      def visit_instance_variable_operator_write_node(node)
+        check_string_concat(node)
+        super
+      end
+
+      # Detect class variable += (e.g., @@str += "x")
+      def visit_class_variable_operator_write_node(node)
+        check_string_concat(node)
+        super
+      end
+
+      # Detect global variable += (e.g., $str += "x")
+      def visit_global_variable_operator_write_node(node)
+        check_string_concat(node)
+        super
+      end
+
+      private
+
+      def loop_method?(node)
+        LOOP_METHODS.include?(node.name)
+      end
+
+      def check_string_concat(node)
+        return unless @in_loop
+        return unless node.binary_operator == :+
+        return unless string_value?(node.value)
+
+        add_finding(
+          node,
+          message: "Use `<<` instead of `+=` for string concatenation in loops to avoid allocations",
+          speedup: "Significant in tight loops, avoids O(n^2) string copying"
+        )
+      end
+
+      def string_value?(node)
+        case node
+        when Prism::StringNode, Prism::InterpolatedStringNode
+          true
+        when Prism::CallNode
+          # Method calls that likely return strings (e.g., to_s, inspect, to_str)
+          %i[to_s to_str inspect].include?(node.name)
+        else
+          # For other node types (variables, etc.), we can't be sure
+          # but += with + operator is most commonly used for strings
+          # We'll be conservative and only match known string types
+          false
+        end
+      end
+    end
+  end
+end

data/lib/hone/patterns/string_delete_prefix.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: str.sub(/^prefix/, '') -> str.delete_prefix('prefix')
+    #
+    # delete_prefix is a specialized method that avoids the regex engine overhead.
+    # It's approximately 2x faster for this common use case.
+    class StringDeletePrefix < Base
+      self.pattern_id = :string_delete_prefix
+      self.optimization_type = :cpu
+
+      def visit_call_node(node)
+        super
+
+        return unless node.name == :sub
+
+        args = node.arguments&.arguments
+        return unless args&.size == 2
+
+        first_arg = args[0]
+        second_arg = args[1]
+
+        # Check if first arg is a regex starting with ^
+        return unless first_arg.is_a?(Prism::RegularExpressionNode)
+        return unless second_arg.is_a?(Prism::StringNode) && second_arg.content.empty?
+
+        pattern = first_arg.content
+        return unless pattern.start_with?("^")
+
+        # Extract the literal prefix (after ^)
+        prefix = pattern[1..]
+
+        # Only suggest for simple literal prefixes (no regex metacharacters)
+        return unless simple_literal?(prefix)
+
+        add_finding(
+          node,
+          message: "Use `.delete_prefix('#{prefix}')` instead of `.sub(/^#{prefix}/, '')`",
+          speedup: "Avoids regex engine overhead"
+        )
+      end
+
+      private
+
+      def simple_literal?(str)
+        # Check that the string doesn't contain regex metacharacters
+        # that would change its meaning
+        !str.match?(/[.+*?\[\](){}|\\$]/)
+      end
+    end
+  end
+end

data/lib/hone/patterns/string_delete_suffix.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: str.sub(/suffix$/, '') -> str.delete_suffix('suffix')
+    #
+    # delete_suffix is a specialized method that avoids the regex engine overhead.
+    # It's approximately 2x faster for this common use case.
+    class StringDeleteSuffix < Base
+      self.pattern_id = :string_delete_suffix
+      self.optimization_type = :cpu
+
+      def visit_call_node(node)
+        super
+
+        return unless node.name == :sub
+
+        args = node.arguments&.arguments
+        return unless args&.size == 2
+
+        first_arg = args[0]
+        second_arg = args[1]
+
+        # Check if first arg is a regex ending with $
+        return unless first_arg.is_a?(Prism::RegularExpressionNode)
+        return unless second_arg.is_a?(Prism::StringNode) && second_arg.content.empty?
+
+        pattern = first_arg.content
+        return unless pattern.end_with?("$")
+
+        # Extract the literal suffix (before $)
+        suffix = pattern[0..-2]
+
+        # Only suggest for simple literal suffixes (no regex metacharacters)
+        return unless simple_literal?(suffix)
+
+        add_finding(
+          node,
+          message: "Use `.delete_suffix('#{suffix}')` instead of `.sub(/#{suffix}$/, '')`",
+          speedup: "Avoids regex engine overhead"
+        )
+      end
+
+      private
+
+      def simple_literal?(str)
+        # Check that the string doesn't contain regex metacharacters
+        # that would change its meaning
+        !str.match?(/[.+*?\[\](){}|\\^]/)
+      end
+    end
+  end
+end

data/lib/hone/patterns/string_empty.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: str.length == 0 or str.size == 0 -> str.empty?
+    #
+    # Comparing length/size to 0 is less idiomatic than using empty?.
+    # empty? is the Ruby way to check for emptiness.
+    #
+    # @example Bad
+    #   str.length == 0
+    #   str.size == 0
+    #   0 == str.length
+    #   0 == str.size
+    #
+    # @example Good
+    #   str.empty?
+    class StringEmpty < Base
+      self.pattern_id = :string_empty
+      self.optimization_type = :cpu
+
+      def visit_call_node(node)
+        super
+
+        return unless length_or_size_equals_zero?(node)
+
+        add_finding(
+          node,
+          message: "Use `empty?` instead of comparing `length`/`size` to 0",
+          speedup: "Minor, but more idiomatic"
+        )
+      end
+
+      private
+
+      # Detects: str.length == 0 or str.size == 0 or 0 == str.length or 0 == str.size
+      def length_or_size_equals_zero?(node)
+        return false unless node.name == :==
+        return false unless node.arguments&.arguments&.size == 1
+
+        receiver = node.receiver
+        arg = node.arguments.arguments[0]
+
+        # Check: receiver.length/size == 0 or 0 == receiver.length/size
+        (length_or_size_call?(receiver) && integer_zero?(arg)) ||
+          (integer_zero?(receiver) && length_or_size_call?(arg))
+      end
+
+      def length_or_size_call?(node)
+        return false unless node.is_a?(Prism::CallNode)
+
+        %i[length size].include?(node.name) && no_arguments?(node)
+      end
+
+      def no_arguments?(node)
+        node.arguments.nil? || node.arguments.arguments.empty?
+      end
+
+      def integer_zero?(node)
+        node.is_a?(Prism::IntegerNode) && node.value == 0
+      end
+    end
+  end
+end

data/lib/hone/patterns/string_end_with.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: str[-1] == 'x' or str.match?(/x$/) -> str.end_with?('x')
+    #
+    # Indexing at position -1 for comparison or using regex with $ anchor
+    # is less clear and potentially slower than using end_with?.
+    #
+    # @example Bad
+    #   str[-1] == 'x'
+    #   str.match?(/foo$/)
+    #
+    # @example Good
+    #   str.end_with?('x')
+    #   str.end_with?('foo')
+    class StringEndWith < Base
+      self.pattern_id = :string_end_with
+      self.optimization_type = :cpu
+
+      def visit_call_node(node)
+        super
+
+        if index_negative_one_comparison?(node)
+          add_finding(
+            node,
+            message: "Use `end_with?` instead of `str[-1] == ...` for cleaner code",
+            speedup: "Cleaner and avoids substring/regex overhead"
+          )
+        elsif regex_end_anchor?(node)
+          add_finding(
+            node,
+            message: "Use `end_with?` instead of `match?(/...$/)` to avoid regex overhead",
+            speedup: "Cleaner and avoids substring/regex overhead"
+          )
+        end
+      end
+
+      private
+
+      # Detects: str[-1] == 'x' or 'x' == str[-1]
+      def index_negative_one_comparison?(node)
+        return false unless node.name == :==
+        return false unless node.arguments&.arguments&.size == 1
+
+        receiver = node.receiver
+        arg = node.arguments.arguments[0]
+
+        # Check receiver[-1] == arg or arg == receiver[-1]
+        index_at_negative_one?(receiver) || index_at_negative_one?(arg)
+      end
+
+      # Detects: str.match?(/...$/)
+      def regex_end_anchor?(node)
+        return false unless node.name == :match?
+        return false unless node.arguments&.arguments&.size == 1
+
+        arg = node.arguments.arguments[0]
+        return false unless arg.is_a?(Prism::RegularExpressionNode)
+
+        # Check if regex ends with $ anchor (and $ is not escaped)
+        content = arg.content
+        content.end_with?("$") && !content.end_with?("\\$")
+      end
+
+      # Check if node is a [] call with index -1
+      def index_at_negative_one?(node)
+        return false unless node.is_a?(Prism::CallNode)
+        return false unless node.name == :[]
+        return false unless node.arguments&.arguments&.size == 1
+
+        index_arg = node.arguments.arguments[0]
+        integer_negative_one?(index_arg)
+      end
+
+      def integer_negative_one?(node)
+        node.is_a?(Prism::IntegerNode) && node.value == -1
+      end
+    end
+  end
+end