fastererer 0.12.0

data/lib/fastererer/scanners/method_call_scanner.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require 'fastererer/method_call'
+require 'fastererer/offense'
+require 'fastererer/scanners/offensive'
+require 'fastererer/scanners/symbol_to_proc_check'
+
+module Fastererer
+  class MethodCallScanner
+    include Fastererer::Offensive
+    include Fastererer::SymbolToProcCheck
+
+    CHECKERS = {
+      module_eval: :check_module_eval_offense,
+      gsub: :check_gsub_offense,
+      sort: :check_sort_offense,
+      each_with_index: :check_each_with_index_offense,
+      first: :check_first_offense,
+      each: :check_each_offense,
+      flatten: :check_flatten_offense,
+      fetch: :check_fetch_offense,
+      merge!: :check_merge_bang_offense,
+      last: :check_last_offense,
+      include?: :check_range_include_offense
+    }.freeze
+    private_constant :CHECKERS
+
+    attr_reader :element
+
+    def initialize(element)
+      @element = element
+      check_offense
+    end
+
+    def method_call
+      @method_call ||= MethodCall.new(element)
+    end
+
+    private
+
+    def check_offense
+      checker = CHECKERS[method_call.method_name]
+      send(checker) if checker
+      check_symbol_to_proc
+    end
+
+    def check_module_eval_offense
+      first_argument = method_call.arguments.first
+      return unless first_argument && first_argument.value.is_a?(String)
+
+      add_offense(:module_eval) if first_argument.value.include?('def')
+    end
+
+    def check_gsub_offense
+      first_argument = method_call.arguments[0]
+      second_argument = method_call.arguments[1]
+      return if first_argument.nil? || second_argument.nil?
+
+      add_offense(:gsub_vs_tr) if both_single_char_strings?(first_argument, second_argument)
+    end
+
+    def both_single_char_strings?(first, second)
+      [first, second].all? { |arg| arg.value.is_a?(String) && arg.value.size == 1 }
+    end
+
+    def check_sort_offense
+      return unless method_call.arguments.any? || method_call.block?
+
+      add_offense(:sort_vs_sort_by)
+    end
+
+    def check_each_with_index_offense
+      add_offense(:each_with_index_vs_while)
+    end
+
+    def check_first_offense
+      return unless method_call.receiver.is_a?(MethodCall)
+
+      case method_call.receiver.name
+      when :shuffle
+        add_offense(:shuffle_first_vs_sample)
+      when :select
+        return unless method_call.receiver.block?
+        return if method_call.arguments.any?
+
+        add_offense(:select_first_vs_detect)
+      end
+    end
+
+    def check_each_offense
+      return unless method_call.receiver.is_a?(MethodCall)
+
+      case method_call.receiver.name
+      when :reverse
+        add_offense(:reverse_each_vs_reverse_each)
+      when :keys
+        add_offense(:keys_each_vs_each_key) if method_call.receiver.arguments.none?
+      end
+    end
+
+    def check_flatten_offense
+      return unless method_call.receiver.is_a?(MethodCall)
+      return unless method_call.receiver.name == :map && method_call.arguments.one?
+
+      add_offense(:map_flatten_vs_flat_map) if method_call.arguments.first.value == 1
+    end
+
+    def check_fetch_offense
+      return unless method_call.arguments.count == 2 && !method_call.block?
+
+      add_offense(:fetch_with_argument_vs_block)
+    end
+
+    def check_merge_bang_offense
+      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
+
+      add_offense(:hash_merge_bang_vs_hash_brackets)
+    end
+
+    def check_last_offense
+      return unless method_call.receiver.is_a?(MethodCall)
+      return unless method_call.receiver.name == :select
+      return if method_call.arguments.any?
+
+      add_offense(:select_last_vs_reverse_detect)
+    end
+
+    def check_range_include_offense
+      return unless method_call.receiver.is_a?(Primitive) && method_call.receiver.range?
+
+      add_offense(:include_vs_cover_on_range)
+    end
+  end
+end

data/lib/fastererer/scanners/method_definition_scanner.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'fastererer/method_definition'
+require 'fastererer/method_call'
+require 'fastererer/offense'
+require 'fastererer/scanners/offensive'
+
+module Fastererer
+  class MethodDefinitionScanner
+    include Fastererer::Offensive
+
+    attr_reader :element
+
+    def initialize(element)
+      @element = element
+      check_offense
+    end
+
+    private
+
+    def check_offense
+      if method_definition.block?
+        scan_block_call_offense
+      else
+        scan_getter_and_setter_offense
+      end
+    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
+    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
+
+    def scan_setter_offense
+      return if method_definition.arguments.size != 1
+      return if method_definition.body.size != 1
+
+      first_argument = method_definition.arguments.first
+      return if first_argument.type != :regular_argument
+
+      add_offense(:setter_vs_attr_writer) if trivial_setter?(first_argument)
+    end
+
+    def trivial_setter?(first_argument)
+      body_first = method_definition.body.first
+      expected_ivar = "@#{method_definition.name.to_s.delete_suffix('=')}"
+
+      body_first.sexp_type == :iasgn &&
+        body_first[1].to_s == expected_ivar &&
+        body_first[2][1] == first_argument.name
+    end
+
+    def scan_getter_offense
+      return if method_definition.arguments.size.positive?
+      return if method_definition.body.size != 1
+
+      add_offense(:getter_vs_attr_reader) if trivial_getter?
+    end
+
+    def trivial_getter?
+      body_first = method_definition.body.first
+
+      body_first.sexp_type == :ivar &&
+        body_first[1].to_s == "@#{method_definition.name}"
+    end
+  end
+end

data/lib/fastererer/scanners/offensive.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'fastererer/offense'
+
+module Fastererer
+  module Offensive
+    attr_accessor :offense
+
+    def offensive?
+      !!offense
+    end
+
+    alias offense_detected? offensive?
+
+    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
+    end
+  end
+end

data/lib/fastererer/scanners/rescue_call_scanner.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'fastererer/rescue_call'
+require 'fastererer/offense'
+require 'fastererer/scanners/offensive'
+
+module Fastererer
+  class RescueCallScanner
+    include Fastererer::Offensive
+
+    attr_reader :element
+
+    def initialize(element)
+      @element = element
+      check_offense
+    end
+
+    private
+
+    def check_offense
+      return unless rescue_call.rescue_classes.include? :NoMethodError
+
+      add_offense(:rescue_vs_respond_to)
+    end
+
+    def rescue_call
+      @rescue_call ||= RescueCall.new(element)
+    end
+  end
+end

data/lib/fastererer/scanners/symbol_to_proc_check.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'fastererer/method_call'
+
+module Fastererer
+  # Includer must respond to #method_call (returning a MethodCall) and #add_offense(symbol).
+  module SymbolToProcCheck
+    private
+
+    def check_symbol_to_proc
+      return unless symbol_to_proc_candidate?
+
+      body_call = MethodCall.new(method_call.block_body)
+      return unless symbol_to_proc_body?(body_call)
+
+      add_offense(:block_vs_symbol_to_proc)
+    end
+
+    def symbol_to_proc_candidate?
+      method_call.block_argument_names.one? &&
+        !method_call.block_body.nil? &&
+        method_call.block_body.sexp_type == :call &&
+        method_call.arguments.none? &&
+        !method_call.lambda_literal?
+    end
+
+    def symbol_to_proc_body?(body_call)
+      body_call.arguments.none? &&
+        !body_call.block? &&
+        !body_call.receiver.nil? &&
+        !body_call.receiver.is_a?(Fastererer::Primitive) &&
+        body_call.receiver.name == method_call.block_argument_names.first
+    end
+  end
+end

data/lib/fastererer/version.rb

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

data/lib/fastererer.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'fastererer/version'
+require 'fastererer/analyzer'
+require 'fastererer/method_definition'
+
+module Fastererer
+  # Your code goes here...
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: fastererer
+version: !ruby/object:Gem::Version
+  version: 0.12.0
+platform: ruby
+authors:
+- Matt Menefee
+- Damir Svrtan
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruby_parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.22.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.22.0
+description: Use Fastererer to check various places in your code that could be faster.
+  A fork of fasterer (https://github.com/DamirSvrtan/fasterer) with Ruby 4.0 support
+  and native Prism parsing.
+email:
+- matt.menefee@extractablemedia.com
+- damir.svrtan@gmail.com
+executables:
+- fastererer
+extensions: []
+extra_rdoc_files: []
+files:
+- ".fastererer.yml"
+- ".ruby-version"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- CONTRIBUTING.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- SECURITY.md
+- exe/fastererer
+- lib/fastererer.rb
+- lib/fastererer/analyzer.rb
+- lib/fastererer/cli.rb
+- lib/fastererer/config.rb
+- lib/fastererer/file_traverser.rb
+- lib/fastererer/method_call.rb
+- lib/fastererer/method_definition.rb
+- lib/fastererer/offense.rb
+- lib/fastererer/offense_collector.rb
+- lib/fastererer/painter.rb
+- lib/fastererer/parser.rb
+- lib/fastererer/rescue_call.rb
+- lib/fastererer/scanners/method_call_scanner.rb
+- lib/fastererer/scanners/method_definition_scanner.rb
+- lib/fastererer/scanners/offensive.rb
+- lib/fastererer/scanners/rescue_call_scanner.rb
+- lib/fastererer/scanners/symbol_to_proc_check.rb
+- lib/fastererer/version.rb
+homepage: https://github.com/ExtractableMedia/fastererer
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/ExtractableMedia/fastererer
+  bug_tracker_uri: https://github.com/ExtractableMedia/fastererer/issues
+  changelog_uri: https://github.com/ExtractableMedia/fastererer/blob/main/CHANGELOG.md
+  documentation_uri: https://rubydoc.info/gems/fastererer
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.10
+specification_version: 4
+summary: Run Ruby more than fast. Fastererer
+test_files: []