fastererer 0.12.0 → 1.1.0

data/lib/fastererer/method_call.rb

@@ -1,141 +1,205 @@
 # frozen_string_literal: true
 
+require 'prism'
+require 'fastererer/receiver'
+
 module Fastererer
   class MethodCall
-    attr_reader :element, :receiver, :method_name, :arguments, :block_body, :block_argument_names
+    include Receiver
 
-    alias name method_name
+    attr_reader :element
 
-    def initialize(element)
-      @element = element
-      set_call_element
-      set_receiver
-      set_method_name
-      set_arguments
-      set_block_presence
-      set_block_body
-      set_block_argument_names
+    def self.build(node)
+      node.is_a?(Prism::LambdaNode) ? LambdaCall.new(node) : new(node)
     end
 
-    def block?
-      @block_present || false
+    def initialize(node)
+      @element = node
     end
 
-    def receiver_element
-      call_element[1]
+    def receiver
+      @receiver ||= ReceiverFactory.build(element.receiver)
     end
 
-    def arguments_element
-      call_element.sexp_body(3) || []
+    def method_name
+      element.name
     end
 
-    def lambda_literal?
-      call_element.sexp_type == :lambda
+    def name
+      method_name
     end
 
-    private
+    def call_name = method_name
 
-    attr_reader :call_element
+    def arguments
+      @arguments ||= argument_nodes.map { |argument| Argument.new(argument) }
+    end
 
-    # TODO: explanation
-    def set_call_element
-      @call_element = case element.sexp_type
-                      when :call
-                        @element
-                      when :iter
-                        @element[1]
-                      end
+    def block_body
+      @block_body ||= block_statements
     end
 
-    def set_receiver
-      @receiver = ReceiverFactory.new(receiver_element)
+    def block_argument_names
+      @block_argument_names ||= positional_block_parameter_names
     end
 
-    def set_method_name
-      @method_name = call_element[2]
+    def block?
+      !block_node.nil?
     end
 
-    def set_arguments
-      @arguments = arguments_element.map { |argument| Argument.new(argument) }
+    def lambda_literal?
+      false
     end
 
-    def set_block_presence
-      if element.sexp_type == :iter || (arguments.last && arguments.last.type == :block_pass)
-        @block_present = true
-      end
+    # Provably a Hash: bare `Hash.new`/`Hash[...]` (any args — every `Hash[...]` yields a Hash),
+    # not qualified `Foo::Hash`. The is_a?(ConstantReadNode) check is load-bearing:
+    # ConstantPathNode#name is :Hash too, so the type (not the name) excludes qualified constants.
+    # unwrap_parentheses lets `(Hash).new` match, as the receiver factory normalizes its input.
+    def hash?
+      return false unless %i[new []].include?(method_name)
+
+      constant = ReceiverFactory.unwrap_parentheses(element.receiver)
+      constant.is_a?(Prism::ConstantReadNode) && constant.name == :Hash
+    end
+
+    private
+
+    def block_node
+      @block_node ||= element.block
     end
 
-    def set_block_body
-      @block_body = element[3] if block?
+    def argument_nodes
+      element.arguments&.arguments || []
     end
 
-    # TODO: write specs for lambdas and procs
-    def set_block_argument_names
-      @block_argument_names = if block? && element[2].is_a?(Sexp) # HACK: for lambdas
-                                element[2].drop(1).map { |argument| argument }
-                              end || []
+    def block_statements
+      return unless block_node.is_a?(Prism::BlockNode)
+
+      body = block_node.body
+      body.body if body.is_a?(Prism::StatementsNode)
     end
+
+    # Only single positional params convert to &:sym, so a splat or keyword param must not count
+    # toward the single-name check
+    def positional_block_parameter_names
+      return [] unless block_node.is_a?(Prism::BlockNode)
+
+      params = block_node.parameters
+      return [] unless params.is_a?(Prism::BlockParametersNode) && params.parameters
+
+      positional = params.parameters.requireds + params.parameters.optionals
+      positional.map { |param| param.is_a?(Prism::MultiTargetNode) ? nil : param.name }
+    end
+  end
+
+  # A `-> {}` lambda literal. Checks ignore it, so its call attributes are inert
+  class LambdaCall < MethodCall
+    def receiver = nil
+    def method_name = :lambda
+    def arguments = []
+    def block_body = nil
+    def block_argument_names = []
+    def block? = true
+    def lambda_literal? = true
   end
 
-  # For now, used for determening if the
-  # receiver is a reference or a method call.
-  class ReceiverFactory
-    def self.new(receiver_info)
-      return unless receiver_info.is_a?(Sexp)
-
-      case receiver_info.sexp_type
-      when :lvar
-        VariableReference.new(receiver_info)
-      when :call, :iter
-        MethodCall.new(receiver_info)
-      when :array, :dot2, :dot3, :lit
-        Primitive.new(receiver_info)
+  module ReceiverFactory
+    PRIMITIVE_NODE_TYPES = [Prism::ArrayNode, Prism::RangeNode, Prism::IntegerNode,
+                            Prism::FloatNode, Prism::SymbolNode, Prism::StringNode,
+                            Prism::HashNode].freeze
+
+    def self.build(node)
+      return unless node
+
+      node = unwrap_parentheses(node)
+      case node
+      # A ConstantPathNode's #name is the unqualified tail only (Foo::Bar => :Bar), which is all
+      # the symbol-to-proc check needs; revisit if a check ever needs the fully-qualified path.
+      when Prism::LocalVariableReadNode, Prism::ConstantReadNode,
+           Prism::ConstantPathNode then VariableReference.new(node)
+      when Prism::CallNode then MethodCall.build(node)
+      when *PRIMITIVE_NODE_TYPES then Primitive.new(node)
+      end
+    end
+
+    # Peels a single parenthesis level, so `((x))` stays wrapped — matches how callers normalize
+    def self.unwrap_parentheses(node)
+      if node.is_a?(Prism::ParenthesesNode) &&
+         node.body.is_a?(Prism::StatementsNode) &&
+         node.body.body.size == 1
+        node.body.body.first
+      else
+        node
       end
     end
   end
 
   class VariableReference
+    include Receiver
+
     attr_reader :name
 
-    def initialize(reference_info)
-      @reference_info = reference_info
-      @name = reference_info[1]
+    def initialize(node)
+      @name = node.name
     end
   end
 
   class Argument
     attr_reader :element
 
-    def initialize(element)
-      @element = element
-    end
+    def initialize(node)
+      @element = node
+    end
+
+    TYPE_BY_NODE_CLASS = {
+      Prism::KeywordHashNode => :hash,
+      Prism::HashNode => :hash,
+      Prism::StringNode => :string,
+      Prism::IntegerNode => :integer,
+      Prism::SymbolNode => :symbol,
+      Prism::FloatNode => :float,
+      Prism::RegularExpressionNode => :regexp,
+      Prism::NilNode => :nil,
+      Prism::TrueNode => :boolean,
+      Prism::FalseNode => :boolean,
+      Prism::LocalVariableReadNode => :variable,
+      Prism::CallNode => :method_call
+    }.freeze
 
     def type
-      @type ||= @element[0]
+      @type ||= TYPE_BY_NODE_CLASS[element.class] || :unknown
     end
 
     def value
-      @value ||= @element[1]
+      return @value if defined?(@value)
+
+      @value = case element
+               when Prism::StringNode then element.unescaped
+               when Prism::IntegerNode, Prism::FloatNode then element.value
+               when Prism::SymbolNode then element.unescaped.to_sym
+               end
     end
   end
 
   class Primitive
-    attr_reader :element
+    include Receiver
 
-    def initialize(element)
-      @element = element
-    end
+    attr_reader :element
 
-    def type
-      @type ||= @element[0]
+    def initialize(node)
+      @element = node
     end
 
     def range?
-      %i[dot2 dot3 lit].include?(type)
+      element.is_a?(Prism::RangeNode)
     end
 
     def array?
-      type == :array
+      element.is_a?(Prism::ArrayNode)
+    end
+
+    def hash?
+      element.is_a?(Prism::HashNode)
     end
   end
 end

data/lib/fastererer/method_definition.rb

@@ -1,22 +1,37 @@
 # frozen_string_literal: true
 
+require 'prism'
+
 module Fastererer
   class MethodDefinition
-    # Exposed for testing purposes.
-    attr_reader :element, :method_name, :block_argument_name, :body, :arguments
+    PARAMETER_CATEGORIES = %i[requireds optionals rest posts keywords keyword_rest block].freeze
+    private_constant :PARAMETER_CATEGORIES
+
+    attr_reader :element
 
+    def initialize(node)
+      @element = node
+    end
+
+    def method_name
+      element.name
+    end
     alias name method_name
 
-    def initialize(element)
-      @element = element # Ripper element
-      set_method_name
-      set_body
-      set_arguments
-      set_block_argument_name
+    def body
+      @body ||= statement_body
+    end
+
+    def arguments
+      @arguments ||= parameter_nodes.map { |node| MethodDefinitionArgument.new(node) }
+    end
+
+    def block_argument_name
+      block_parameter&.name
     end
 
     def block?
-      !!@block_argument_name
+      !block_parameter.nil?
     end
 
     def setter?
@@ -25,70 +40,68 @@ module Fastererer
 
     private
 
-    def arguments_element
-      element[2].drop(1) || []
+    def statement_body
+      body_node = element.body
+      # A rescue/ensure body is a BeginNode wrapping the statements; #statements may be nil
+      body_node = body_node.statements if body_node.is_a?(Prism::BeginNode)
+      body_node.is_a?(Prism::StatementsNode) ? body_node.body : []
     end
 
-    def set_method_name
-      @method_name = @element[1]
-    end
+    def parameter_nodes
+      params = element.parameters
+      return [] unless params
 
-    def set_arguments
-      @arguments = arguments_element.map do |argument_element|
-        MethodDefinitionArgument.new(argument_element)
-      end
+      PARAMETER_CATEGORIES.flat_map { |category| Array(params.public_send(category)) }
     end
 
-    def set_body
-      @body = @element[3..]
+    def block_parameter
+      params = element.parameters
+      return unless params&.block.is_a?(Prism::BlockParameterNode)
+
+      params.block
     end
+  end
 
-    def set_block_argument_name
-      return unless last_argument_element.to_s.start_with?('&')
+  class MethodDefinitionArgument
+    attr_reader :element
 
-      @block_argument_name = last_argument_element.to_s.delete_prefix('&').to_sym
+    def initialize(node)
+      @element = node
     end
 
-    def last_argument_element
-      arguments_element.last
+    # Prism param nodes expose #name (nil when anonymous); MultiTargetNode has none
+    def name
+      element.respond_to?(:name) ? element.name : nil
     end
-  end
 
-  class MethodDefinitionArgument
-    attr_reader :element, :name, :type
-
-    def initialize(element)
-      @element = element
-      set_name
-      set_argument_type
+    def type
+      @type ||= argument_type
     end
 
     def regular_argument?
-      @type == :regular_argument
+      type == :regular_argument
     end
 
     def default_argument?
-      @type == :default_argument
+      type == :default_argument
     end
 
     def keyword_argument?
-      @type == :keyword_argument
+      type == :keyword_argument
     end
 
     private
 
-    def set_name
-      @name = element.is_a?(Symbol) ? element : element[1]
-    end
-
-    def set_argument_type
-      @type = if element.is_a?(Symbol)
-                :regular_argument
-              elsif element.is_a?(Sexp) && element.sexp_type == :lasgn
-                :default_argument
-              elsif element.is_a?(Sexp) && element.sexp_type == :kwarg
-                :keyword_argument
-              end
+    def argument_type
+      case element
+      when Prism::RequiredParameterNode
+        :regular_argument
+      when Prism::OptionalParameterNode
+        :default_argument
+      when Prism::RequiredKeywordParameterNode,
+           Prism::OptionalKeywordParameterNode
+        :keyword_argument
+      end
     end
   end
 end

data/lib/fastererer/offense.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative 'explanation'
+require_relative 'rule_catalog'
+
 module Fastererer
   class Offense
     attr_reader :offense_name, :line_number
@@ -10,72 +13,11 @@ module Fastererer
     def initialize(offense_name, line_number)
       @offense_name = offense_name
       @line_number  = line_number
-      explanation # Set explanation right away.
+      RuleCatalog.validate!(offense_name)
     end
 
     def explanation
-      @explanation ||= EXPLANATIONS.fetch(offense_name)
+      @explanation ||= Explanation.for(offense_name)
     end
-
-    EXPLANATIONS = {
-      rescue_vs_respond_to:
-        'Don\'t rescue NoMethodError, rather check with respond_to?',
-
-      module_eval:
-        'Using module_eval is slower than define_method',
-
-      shuffle_first_vs_sample:
-        'Array#shuffle.first is slower than Array#sample',
-
-      for_loop_vs_each:
-        'For loop is slower than using each',
-
-      each_with_index_vs_while:
-        'Using each_with_index is slower than while loop',
-
-      map_flatten_vs_flat_map:
-        'Array#map.flatten(1) is slower than Array#flat_map',
-
-      reverse_each_vs_reverse_each:
-        'Array#reverse.each is slower than Array#reverse_each',
-
-      select_first_vs_detect:
-        'Array#select.first is slower than Array#detect',
-
-      sort_vs_sort_by:
-        'Enumerable#sort is slower than Enumerable#sort_by',
-
-      fetch_with_argument_vs_block:
-        'Hash#fetch with second argument is slower than Hash#fetch with block',
-
-      keys_each_vs_each_key:
-        'Hash#keys.each is slower than Hash#each_key. N.B. Hash#each_key cannot be used if ' \
-        'the hash is modified during the each block',
-
-      hash_merge_bang_vs_hash_brackets:
-        'Hash#merge! with one argument is slower than Hash#[]',
-
-      block_vs_symbol_to_proc:
-        'Calling argumentless methods within blocks is slower than using symbol to proc',
-
-      proc_call_vs_yield:
-        'Calling blocks with call is slower than yielding',
-
-      gsub_vs_tr:
-        'Using tr is faster than gsub when replacing a single character in a string with ' \
-        'another single character',
-
-      select_last_vs_reverse_detect:
-        'Array#select.last is slower than Array#reverse.detect',
-
-      getter_vs_attr_reader:
-        'Use attr_reader for reading ivars',
-
-      setter_vs_attr_writer:
-        'Use attr_writer for writing to ivars',
-
-      include_vs_cover_on_range:
-        'Use #cover? instead of #include? on ranges'
-    }.freeze
   end
 end

data/lib/fastererer/offense_collector.rb

@@ -14,6 +14,6 @@ module Fastererer
       @offenses.select { |offense| offense.name == offense_name }
     end
 
-    def_delegators :@offenses, :push, :any?, :each, :group_by, :count
+    def_delegators :@offenses, :push, :any?, :each, :group_by, :count, :reject
   end
 end

data/lib/fastererer/painter.rb

@@ -4,7 +4,8 @@ module Fastererer
   module Painter
     COLOR_CODES = {
       red: 31,
-      green: 32
+      green: 32,
+      magenta: 35
     }.freeze
 
     @disabled = false

data/lib/fastererer/parser.rb

@@ -1,13 +1,17 @@
 # frozen_string_literal: true
 
-require 'ruby_parser'
+require 'prism'
 
 module Fastererer
-  class Parser
-    PARSER_CLASS = RubyParser
+  class ParseError < StandardError; end
 
+  # Single seam around Prism.parse: returns the AST root or raises ParseError
+  class Parser
     def self.parse(ruby_code)
-      PARSER_CLASS.for_current_ruby.parse(ruby_code)
+      result = Prism.parse(ruby_code)
+      raise ParseError, result.errors.map(&:message).join('; ') if result.failure?
+
+      result.value
     end
   end
 end

data/lib/fastererer/receiver.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Fastererer
+  # Query surface every receiver answers; includers override only what is true for their type
+  module Receiver
+    def call_name = nil
+    def name = nil
+    def block? = false
+    def arguments = []
+    def range? = false
+    def array? = false
+    def hash? = false
+  end
+end

data/lib/fastererer/report.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Fastererer
+  # Findings arrive already filtered by ignored speedups; formatters must not filter again
+  Report = Data.define(:findings, :files_inspected_count, :unparsable_files, :missing_path) do
+    def offenses_detected_count
+      findings.count
+    end
+  end
+end

data/lib/fastererer/rescue_call.rb

@@ -1,22 +1,20 @@
 # frozen_string_literal: true
 
+require 'prism'
+
 module Fastererer
   class RescueCall
-    attr_reader :element, :rescue_classes
+    attr_reader :element
 
-    def initialize(element)
-      @element = element
-      @rescue_classes = []
-      set_rescue_classes
+    def initialize(node)
+      @element = node
     end
 
-    private
-
-    def set_rescue_classes
-      return if element[1].sexp_type != :array
-
-      @rescue_classes = element[1].drop(1).filter_map do |rescue_reference|
-        rescue_reference[1] if rescue_reference.sexp_type == :const
+    # Only unqualified constants: a namespaced `Foo::NoMethodError` is not the core NoMethodError,
+    # so it must not match the rescue_vs_respond_to check.
+    def rescue_classes
+      @rescue_classes ||= element.exceptions.filter_map do |exception|
+        exception.name if exception.is_a?(Prism::ConstantReadNode)
       end
     end
   end