fastererer 0.12.0 → 1.0.0

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/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/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

data/lib/fastererer/rule_catalog.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Fastererer
+  class UnknownRuleError < StandardError; end
+
+  # Loads, validates, memoizes and looks up the rule catalog from the i18n locale.
+  module RuleCatalog
+    LOCALE_PATH = File.expand_path('../../config/locales/en.yml', __dir__)
+
+    class << self
+      def all
+        @all ||= load
+      end
+
+      def fetch(offense_name)
+        all.fetch(offense_name.to_s) do
+          raise UnknownRuleError, "Unknown rule: #{offense_name.inspect}"
+        end
+      end
+
+      # Guard-only: raises for an unknown rule, returns nil otherwise.
+      def validate!(offense_name)
+        fetch(offense_name)
+        nil
+      end
+
+      private
+
+      def load
+        rows = read_rows
+        rows.each { |key, row| validate_row!(key, row) }
+        rows.transform_values { |row| row.transform_values(&:freeze).freeze }.freeze
+      end
+
+      def read_rows
+        loaded = YAML.safe_load_file(LOCALE_PATH)
+        rows = loaded.is_a?(Hash) ? loaded.dig('en', 'fastererer', 'rules') : nil
+        return rows if rows.is_a?(Hash)
+
+        raise "Fastererer locale at #{LOCALE_PATH} is missing the 'en.fastererer.rules' section"
+      rescue Errno::ENOENT
+        raise "Fastererer locale file not found at #{LOCALE_PATH}"
+      rescue Psych::SyntaxError => e
+        raise "Fastererer locale at #{LOCALE_PATH} is not valid YAML: #{e.message}"
+      end
+
+      def validate_row!(key, row)
+        raise "Fastererer rule #{key} is malformed: #{row.inspect}" unless row.is_a?(Hash)
+
+        validate_url!(key, row['url'])
+        validate_description!(key, row['description'])
+      end
+
+      def validate_url!(key, url)
+        unless url.is_a?(String) && url.start_with?('https://')
+          raise "Fastererer rule #{key} has a non-https url: #{url.inspect}"
+        end
+
+        return if url.match?(/\A[[:print:]]+\z/)
+
+        raise "Fastererer rule #{key} has a non-printable url: #{url.inspect}"
+      end
+
+      def validate_description!(key, text)
+        return if text.is_a?(String) && text.match?(/\A[[:print:][:space:]]+\z/)
+
+        raise "Fastererer rule #{key} has a non-printable description: #{text.inspect}"
+      end
+
+      # Test-only hook: clears the memoized catalog so the YAML can be re-read.
+      def reset!
+        @all = nil
+      end
+    end
+  end
+end

data/lib/fastererer/rule_name.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Fastererer
+  # Derives a rubocop-style "Performance/PascalCase" display name from a snake_case rule key.
+  module RuleName
+    DEPARTMENT = 'Performance'
+
+    def self.from(offense_name)
+      "#{DEPARTMENT}/#{pascal_case(offense_name)}"
+    end
+
+    def self.pascal_case(name)
+      name.to_s.split('_').filter_map { |part| part.capitalize unless part.empty? }.join
+    end
+    private_class_method :pascal_case
+  end
+end

data/lib/fastererer/scanners/method_call_scanner.rb

@@ -20,6 +20,7 @@ module Fastererer
       flatten: :check_flatten_offense,
       fetch: :check_fetch_offense,
       merge!: :check_merge_bang_offense,
+      update: :check_update_offense,
       last: :check_last_offense,
       include?: :check_range_include_offense
     }.freeze
@@ -33,7 +34,7 @@ module Fastererer
     end
 
     def method_call
-      @method_call ||= MethodCall.new(element)
+      @method_call ||= MethodCall.build(element)
     end
 
     private
@@ -115,13 +116,16 @@ module Fastererer
       return unless method_call.arguments.one?
 
       first_argument = method_call.arguments.first
-      return unless first_argument.type == :hash
-      # each key and value is an item by itself.
-      return unless first_argument.element.drop(1).count == 2
+      return unless first_argument.type == :hash && first_argument.element.elements.one?
 
       add_offense(:hash_merge_bang_vs_hash_brackets)
     end
 
+    # Hash#update is a merge! alias but heavily overloaded, so require a provably-Hash receiver
+    def check_update_offense
+      check_merge_bang_offense if method_call.receiver&.hash?
+    end
+
     def check_last_offense
       return unless method_call.receiver.is_a?(MethodCall)
       return unless method_call.receiver.name == :select

data/lib/fastererer/scanners/method_definition_scanner.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'prism'
 require 'fastererer/method_definition'
 require 'fastererer/method_call'
 require 'fastererer/offense'
@@ -27,33 +28,15 @@ module Fastererer
     end
 
     def scan_block_call_offense
-      traverse_tree(method_definition.body) do |element|
-        next unless element.sexp_type == :call
-
-        method_call = MethodCall.new(element)
-
-        if method_call.receiver.is_a?(Fastererer::VariableReference) &&
-           method_call.receiver.name == method_definition.block_argument_name &&
-           method_call.method_name == :call
-
-          add_offense(:proc_call_vs_yield) && return
-        end
-      end
+      visitor = ProcCallVisitor.new(method_definition.block_argument_name)
+      method_definition.body.each { |node| node.accept(visitor) }
+      add_offense(:proc_call_vs_yield) if visitor.proc_call_found?
     end
 
     def method_definition
       @method_definition ||= MethodDefinition.new(element)
     end
 
-    def traverse_tree(sexp_tree, &block)
-      sexp_tree.each do |element|
-        next unless element.is_a?(Array)
-
-        yield element
-        traverse_tree(element, &block)
-      end
-    end
-
     def scan_getter_and_setter_offense
       method_definition.setter? ? scan_setter_offense : scan_getter_offense
     end
@@ -69,12 +52,12 @@ module Fastererer
     end
 
     def trivial_setter?(first_argument)
-      body_first = method_definition.body.first
-      expected_ivar = "@#{method_definition.name.to_s.delete_suffix('=')}"
+      body_node = method_definition.body.first
+      return false unless body_node.is_a?(Prism::InstanceVariableWriteNode)
+      return false unless body_node.value.is_a?(Prism::LocalVariableReadNode)
 
-      body_first.sexp_type == :iasgn &&
-        body_first[1].to_s == expected_ivar &&
-        body_first[2][1] == first_argument.name
+      expected_ivar = :"@#{method_definition.name.to_s.delete_suffix('=')}"
+      body_node.name == expected_ivar && body_node.value.name == first_argument.name
     end
 
     def scan_getter_offense
@@ -85,10 +68,55 @@ module Fastererer
     end
 
     def trivial_getter?
-      body_first = method_definition.body.first
+      body_node = method_definition.body.first
+      expected_ivar = :"@#{method_definition.name}"
 
-      body_first.sexp_type == :ivar &&
-        body_first[1].to_s == "@#{method_definition.name}"
+      body_node.is_a?(Prism::InstanceVariableReadNode) && body_node.name == expected_ivar
     end
   end
+
+  # Finds `block_name.call` in a method body, without descending into nested def/class/module scopes
+  # where the block parameter is no longer in scope
+  class ProcCallVisitor < Prism::Visitor
+    def initialize(block_name)
+      super()
+      @block_name = block_name
+      @proc_call_found = false
+    end
+
+    def proc_call_found?
+      @proc_call_found
+    end
+
+    def visit_call_node(node)
+      @proc_call_found = true if proc_call?(node)
+      super
+    end
+
+    # No super on purpose: these open a new scope where the block param is unbound, so we stop
+    # descending rather than attribute their inner `name.call`s to the enclosing method.
+    def visit_def_node(_node)
+    end
+
+    def visit_class_node(_node)
+    end
+
+    def visit_module_node(_node)
+    end
+
+    def visit_singleton_class_node(_node)
+    end
+
+    private
+
+    def proc_call?(node)
+      return false if @block_name.nil? # an anonymous block param (&) is never invoked by name
+
+      node.receiver.is_a?(Prism::LocalVariableReadNode) &&
+        node.receiver.name == @block_name &&
+        node.name == :call
+    end
+  end
+
+  private_constant :ProcCallVisitor
 end

data/lib/fastererer/scanners/offensive.rb

@@ -14,12 +14,8 @@ module Fastererer
 
     private
 
-    def add_offense(offense_name, element_line_number = element.line)
-      self.offense = Fastererer::Offense.new(offense_name, element_line_number)
-    end
-
-    def check_offense
-      raise NotImplementedError
+    def add_offense(offense_name)
+      self.offense = Fastererer::Offense.new(offense_name, element.location.start_line)
     end
   end
 end

data/lib/fastererer/scanners/rescue_call_scanner.rb

@@ -18,7 +18,7 @@ module Fastererer
     private
 
     def check_offense
-      return unless rescue_call.rescue_classes.include? :NoMethodError
+      return unless rescue_call.rescue_classes.include?(:NoMethodError)
 
       add_offense(:rescue_vs_respond_to)
     end

data/lib/fastererer/scanners/symbol_to_proc_check.rb

@@ -1,16 +1,18 @@
 # frozen_string_literal: true
 
+require 'prism'
 require 'fastererer/method_call'
 
 module Fastererer
-  # Includer must respond to #method_call (returning a MethodCall) and #add_offense(symbol).
+  # Includer must respond to #method_call (returning a MethodCall) and #add_offense(symbol)
+  # (the latter via the Offensive mixin).
   module SymbolToProcCheck
     private
 
     def check_symbol_to_proc
       return unless symbol_to_proc_candidate?
 
-      body_call = MethodCall.new(method_call.block_body)
+      body_call = MethodCall.build(method_call.block_body.first)
       return unless symbol_to_proc_body?(body_call)
 
       add_offense(:block_vs_symbol_to_proc)
@@ -18,12 +20,18 @@ module Fastererer
 
     def symbol_to_proc_candidate?
       method_call.block_argument_names.one? &&
-        !method_call.block_body.nil? &&
-        method_call.block_body.sexp_type == :call &&
+        single_call_body? &&
         method_call.arguments.none? &&
         !method_call.lambda_literal?
     end
 
+    # A safe-nav body (foo&.bar) is excluded: arr.map(&:bar) raises on a nil element, so the rewrite
+    # would not preserve behavior
+    def single_call_body?
+      body = method_call.block_body
+      body&.size == 1 && body.first.is_a?(Prism::CallNode) && !body.first.safe_navigation?
+    end
+
     def symbol_to_proc_body?(body_call)
       body_call.arguments.none? &&
         !body_call.block? &&

data/lib/fastererer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Fastererer
-  VERSION = '0.12.0'
+  VERSION = '1.0.0'
 end