fastererer 0.12.0

data/lib/fastererer/file_traverser.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require 'English'
+
+require_relative 'analyzer'
+require_relative 'config'
+require_relative 'painter'
+
+module Fastererer
+  class FileTraverser
+    CONFIG_FILE_NAME  = Config::FILE_NAME
+    SPEEDUPS_KEY      = Config::SPEEDUPS_KEY
+    EXCLUDE_PATHS_KEY = Config::EXCLUDE_PATHS_KEY
+
+    attr_reader :config, :parse_error_paths
+    attr_accessor :offenses_total_count
+
+    def initialize(path)
+      @path = Pathname(path || '.')
+      @parse_error_paths = []
+      @config = Config.new
+      @offenses_total_count = 0
+    end
+
+    def traverse
+      traverse_files
+      output_parse_errors
+      output_statistics
+    end
+
+    def config_file
+      config.file
+    end
+
+    def offenses_found?
+      !!offenses_found
+    end
+
+    def scannable_files
+      all_files - ignored_files
+    end
+
+    private
+
+    attr_accessor :offenses_found
+
+    def traverse_files
+      if @path.exist?
+        scannable_files.each { |ruby_file| scan_file(ruby_file) }
+      else
+        output_unable_to_find_file(@path)
+      end
+    end
+
+    def scan_file(path)
+      analyzer = Analyzer.new(path)
+      analyzer.scan
+    rescue RubyParser::SyntaxError, Racc::ParseError, Timeout::Error => e
+      parse_error_paths.push(ErrorData.new(path, e.class, e.message).to_s)
+    else
+      if offenses_grouped_by_type(analyzer).any?
+        output(analyzer)
+        self.offenses_found = true
+        self.offenses_total_count += analyzer.errors.count
+      end
+    end
+
+    def all_files
+      if @path.directory?
+        Dir[File.join(@path, '**', '*.rb')].map do |ruby_file_path|
+          Pathname(ruby_file_path).relative_path_from(root_dir).to_s
+        end
+      else
+        [@path.to_s]
+      end
+    end
+
+    def root_dir
+      @root_dir ||= Pathname('.')
+    end
+
+    def output(analyzer)
+      offenses_grouped_by_type(analyzer).each do |error_group_name, error_occurences|
+        error_occurences.map(&:line_number).each do |line|
+          file_and_line = "#{analyzer.file_path}:#{line}"
+          print "#{Painter.paint(file_and_line, :red)} #{Fastererer::Offense::EXPLANATIONS[error_group_name]}.\n"
+        end
+      end
+
+      print "\n"
+    end
+
+    def offenses_grouped_by_type(analyzer)
+      analyzer.errors.group_by(&:name).delete_if do |offense_name, _|
+        ignored_speedups.include?(offense_name)
+      end
+    end
+
+    def output_parse_errors
+      return if parse_error_paths.none?
+
+      puts 'Fastererer was unable to process some files because the'
+      puts 'internal parser is not able to read some characters or'
+      puts 'has timed out. Unprocessable files were:'
+      puts '-----------------------------------------------------'
+      puts parse_error_paths
+      puts
+    end
+
+    def output_statistics
+      puts Statistics.new(self)
+    end
+
+    def output_unable_to_find_file(path)
+      puts Painter.paint("No such file or directory - #{path}", :red)
+    end
+
+    def ignored_speedups
+      config.ignored_speedups
+    end
+
+    def ignored_files
+      config.ignored_files
+    end
+
+    def nil_config_file
+      config.nil_file
+    end
+  end
+
+  ErrorData = Struct.new(:file_path, :error_class, :error_message) do
+    def to_s
+      "#{file_path} - #{error_class} - #{error_message}"
+    end
+  end
+
+  class Statistics
+    def initialize(traverser)
+      @files_inspected_count  = traverser.scannable_files.count
+      @offenses_found_count   = traverser.offenses_total_count
+      @unparsable_files_count = traverser.parse_error_paths.count
+    end
+
+    def to_s
+      [
+        inspected_files_output,
+        offenses_found_output,
+        unparsable_files_output
+      ].compact.join(', ')
+    end
+
+    def inspected_files_output
+      Painter.paint(
+        "#{@files_inspected_count} #{pluralize(@files_inspected_count, 'file')} inspected", :green
+      )
+    end
+
+    def offenses_found_output
+      color = @offenses_found_count.zero? ? :green : :red
+
+      Painter.paint(
+        "#{@offenses_found_count} #{pluralize(@offenses_found_count, 'offense')} detected", color
+      )
+    end
+
+    def unparsable_files_output
+      return if @unparsable_files_count.zero?
+
+      Painter.paint(
+        "#{@unparsable_files_count} unparsable #{pluralize(@unparsable_files_count, 'file')} found",
+        :red
+      )
+    end
+
+    def pluralize(count, singular, plural = nil)
+      if count == 1
+        singular.to_s
+      elsif plural
+        plural.to_s
+      else
+        "#{singular}s"
+      end
+    end
+  end
+end

data/lib/fastererer/method_call.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Fastererer
+  class MethodCall
+    attr_reader :element, :receiver, :method_name, :arguments, :block_body, :block_argument_names
+
+    alias name method_name
+
+    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
+    end
+
+    def block?
+      @block_present || false
+    end
+
+    def receiver_element
+      call_element[1]
+    end
+
+    def arguments_element
+      call_element.sexp_body(3) || []
+    end
+
+    def lambda_literal?
+      call_element.sexp_type == :lambda
+    end
+
+    private
+
+    attr_reader :call_element
+
+    # TODO: explanation
+    def set_call_element
+      @call_element = case element.sexp_type
+                      when :call
+                        @element
+                      when :iter
+                        @element[1]
+                      end
+    end
+
+    def set_receiver
+      @receiver = ReceiverFactory.new(receiver_element)
+    end
+
+    def set_method_name
+      @method_name = call_element[2]
+    end
+
+    def set_arguments
+      @arguments = arguments_element.map { |argument| Argument.new(argument) }
+    end
+
+    def set_block_presence
+      if element.sexp_type == :iter || (arguments.last && arguments.last.type == :block_pass)
+        @block_present = true
+      end
+    end
+
+    def set_block_body
+      @block_body = element[3] if block?
+    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 || []
+    end
+  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)
+      end
+    end
+  end
+
+  class VariableReference
+    attr_reader :name
+
+    def initialize(reference_info)
+      @reference_info = reference_info
+      @name = reference_info[1]
+    end
+  end
+
+  class Argument
+    attr_reader :element
+
+    def initialize(element)
+      @element = element
+    end
+
+    def type
+      @type ||= @element[0]
+    end
+
+    def value
+      @value ||= @element[1]
+    end
+  end
+
+  class Primitive
+    attr_reader :element
+
+    def initialize(element)
+      @element = element
+    end
+
+    def type
+      @type ||= @element[0]
+    end
+
+    def range?
+      %i[dot2 dot3 lit].include?(type)
+    end
+
+    def array?
+      type == :array
+    end
+  end
+end

data/lib/fastererer/method_definition.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Fastererer
+  class MethodDefinition
+    # Exposed for testing purposes.
+    attr_reader :element, :method_name, :block_argument_name, :body, :arguments
+
+    alias name method_name
+
+    def initialize(element)
+      @element = element # Ripper element
+      set_method_name
+      set_body
+      set_arguments
+      set_block_argument_name
+    end
+
+    def block?
+      !!@block_argument_name
+    end
+
+    def setter?
+      name.to_s.end_with?('=')
+    end
+
+    private
+
+    def arguments_element
+      element[2].drop(1) || []
+    end
+
+    def set_method_name
+      @method_name = @element[1]
+    end
+
+    def set_arguments
+      @arguments = arguments_element.map do |argument_element|
+        MethodDefinitionArgument.new(argument_element)
+      end
+    end
+
+    def set_body
+      @body = @element[3..]
+    end
+
+    def set_block_argument_name
+      return unless last_argument_element.to_s.start_with?('&')
+
+      @block_argument_name = last_argument_element.to_s.delete_prefix('&').to_sym
+    end
+
+    def last_argument_element
+      arguments_element.last
+    end
+  end
+
+  class MethodDefinitionArgument
+    attr_reader :element, :name, :type
+
+    def initialize(element)
+      @element = element
+      set_name
+      set_argument_type
+    end
+
+    def regular_argument?
+      @type == :regular_argument
+    end
+
+    def default_argument?
+      @type == :default_argument
+    end
+
+    def 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
+    end
+  end
+end

data/lib/fastererer/offense.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Fastererer
+  class Offense
+    attr_reader :offense_name, :line_number
+
+    alias name offense_name
+    alias line line_number
+
+    def initialize(offense_name, line_number)
+      @offense_name = offense_name
+      @line_number  = line_number
+      explanation # Set explanation right away.
+    end
+
+    def explanation
+      @explanation ||= EXPLANATIONS.fetch(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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Fastererer
+  class OffenseCollector
+    extend Forwardable
+
+    def initialize
+      @offenses = []
+    end
+
+    def [](offense_name)
+      @offenses.select { |offense| offense.name == offense_name }
+    end
+
+    def_delegators :@offenses, :push, :any?, :each, :group_by, :count
+  end
+end

data/lib/fastererer/painter.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Fastererer
+  module Painter
+    COLOR_CODES = {
+      red: 31,
+      green: 32
+    }.freeze
+
+    @disabled = false
+
+    def self.paint(string, color)
+      # Validate before short-circuit so bad color symbols surface even with --no-color/NO_COLOR.
+      color_code = COLOR_CODES[color.to_sym]
+      if color_code.nil?
+        raise ArgumentError,
+              "Color #{color} is not supported. Allowed colors are #{COLOR_CODES.keys.join(', ')}"
+      end
+
+      return string unless colorize?
+
+      paint_with_code(string, color_code)
+    end
+
+    def self.paint_with_code(string, color_code)
+      "\e[#{color_code}m#{string}\e[0m"
+    end
+
+    def self.disable!
+      @disabled = true
+    end
+
+    # Re-enables colorization; production never calls this — exists so tests can reset state.
+    def self.enable!
+      @disabled = false
+    end
+
+    def self.colorize?
+      return false unless ENV.fetch('NO_COLOR', '').empty?
+      return false if @disabled
+
+      $stdout.tty?
+    end
+  end
+end

data/lib/fastererer/parser.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'ruby_parser'
+
+module Fastererer
+  class Parser
+    PARSER_CLASS = RubyParser
+
+    def self.parse(ruby_code)
+      PARSER_CLASS.for_current_ruby.parse(ruby_code)
+    end
+  end
+end

data/lib/fastererer/rescue_call.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Fastererer
+  class RescueCall
+    attr_reader :element, :rescue_classes
+
+    def initialize(element)
+      @element = element
+      @rescue_classes = []
+      set_rescue_classes
+    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
+      end
+    end
+  end
+end