fasterer 0.1.0

data/lib/fasterer/method_call.rb

@@ -0,0 +1,138 @@
+module Fasterer
+  class MethodCall
+    attr_reader :element
+    attr_reader :receiver
+    attr_reader :method_name
+    attr_reader :arguments
+    attr_reader :block_body
+    attr_reader :block_argument_names
+
+    alias_method :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 has_block?
+      @block_present || false
+    end
+
+    def receiver_element
+      call_element[1]
+    end
+
+    def arguments_element
+      call_element[3..-1] || []
+    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]
+                      else
+                        fail '!!!!!!!'
+                      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
+        @block_present = true
+      end
+    end
+
+    def set_block_body
+      if has_block?
+        @block_body = element[3]
+      end
+    end
+
+    # TODO: write specs for lambdas and procs
+    def set_block_argument_names
+      @block_argument_names = if has_block? and element[2].is_a?(Sexp) # hack for lambdas
+        element[2].drop(1).map { |argument| argument }
+      end || []
+    end
+
+    def token
+      element[0]
+    end
+  end
+
+  # For now, used for determening if
+  # the receiver is a reference or not.
+  class ReceiverFactory
+    attr_reader :name
+    attr_reader :method
+
+    def self.new(receiver_info)
+      return if receiver_info.nil?
+      token = receiver_info.first
+
+      case token
+      when :lvar
+        return VariableReference.new(receiver_info)
+      when :method_add_arg, :method_add_block
+        case receiver_info[1][0]
+        when :call, :fcall
+          return MethodCall.new(receiver_info[1])
+        else
+          # binding.pry watch out for :method_add_arg
+          # raise 'nije ni metoda'
+        end
+      when :call, :iter
+        return MethodCall.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
+end

data/lib/fasterer/method_definition.rb

@@ -0,0 +1,51 @@
+module Fasterer
+  class MethodDefinition
+    attr_reader :element # for testing purposes
+    attr_reader :method_name
+    attr_reader :block_argument_name
+    attr_reader :body
+
+    def initialize(element)
+      @element = element # Ripper element
+      set_method_name
+      set_body
+
+      if arguments_element.any?
+        set_argument_names
+        set_block_argument_name
+      end
+    end
+
+    def has_block?
+      !!@block_argument_name
+    end
+
+    private
+
+    def arguments_element
+      element[2].drop(1)
+    end
+
+    def set_method_name
+      @method_name = @element[1]
+    end
+
+    def set_argument_names
+      # TODO
+    end
+
+    def set_body
+      @body = @element[3..-1]
+    end
+
+    def set_block_argument_name
+      if last_argument.to_s.start_with?('&')
+        @block_argument_name = last_argument.to_s[1..-1].to_sym
+      end
+    end
+
+    def last_argument
+      arguments_element.last
+    end
+  end
+end

data/lib/fasterer/offense.rb

@@ -0,0 +1,69 @@
+module Fasterer
+  class Offense
+    attr_reader :offense_name, :line_number
+
+    alias_method :name, :offense_name
+    alias_method :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 = {
+      parallel_assignment:
+        'Parallel assignment is slower than sequential assignment',
+
+      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#reverese.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',
+
+      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:
+        'Use tr instead of gsub when grepping plain strings'
+    }
+
+  end
+end

data/lib/fasterer/offense_collector.rb

@@ -0,0 +1,17 @@
+require 'forwardable'
+
+module Fasterer
+  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
+  end
+end

data/lib/fasterer/parse_error.rb

@@ -0,0 +1,10 @@
+module Fasterer
+  class ParseError < StandardError
+    attr_reader :file_path
+
+    def initialize(file_path)
+      @file_path = file_path
+      super("Unable to read #{file_path}")
+    end
+  end
+end

data/lib/fasterer/parser.rb

@@ -0,0 +1,11 @@
+require 'ruby_parser'
+
+module Fasterer
+  class Parser
+    PARSER_CLASS = RubyParser
+
+    def self.parse(ruby_code)
+      PARSER_CLASS.new.parse(ruby_code)
+    end
+  end
+end

data/lib/fasterer/rescue_call.rb

@@ -0,0 +1,36 @@
+module Fasterer
+  class RescueCall
+    attr_reader :element
+    attr_reader :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).map do |rescue_reference|
+        if rescue_reference.sexp_type == :const
+          rescue_reference[1]
+        end
+      end.compact
+    end
+
+    def set_multiple_rescue_classes
+      @rescue_classes = element[1].drop(1).map do |rescue_reference|
+        rescue_reference.flatten[2]
+      end
+    end
+
+    def set_single_rescue_class
+      if element[1][0][0] == :var_ref
+        @rescue_classes = Array(element[1][0][1][1])
+      end
+    end
+  end
+end

data/lib/fasterer/scanners/method_call_scanner.rb

@@ -0,0 +1,134 @@
+require 'fasterer/method_call'
+require 'fasterer/offense'
+require 'fasterer/scanners/offensive'
+
+module Fasterer
+  class MethodCallScanner
+    include Fasterer::Offensive
+
+    attr_reader :element
+
+    def initialize(element)
+      @element = element
+      check_offense
+    end
+
+    def method_call
+      @method_call ||= MethodCall.new(element)
+    end
+
+    private
+
+    def check_offense
+      case method_call.method_name
+      when :module_eval
+        check_module_eval_offense
+      when :gsub
+        check_gsub_offense
+      when :sort
+        check_sort_offense
+      when :each_with_index
+        check_each_with_index_offense
+      when :first
+        check_first_offense
+      when :each
+        check_each_offense
+      when :flatten
+        check_flatten_offense
+      when :fetch
+        check_fetch_offense
+      when :merge!
+        check_merge_bang_offense
+      end
+    end
+
+    def check_module_eval_offense
+      add_offense(:module_eval)
+    end
+
+    def check_gsub_offense
+      unless method_call.arguments.first.value.is_a? Regexp
+        add_offense(:gsub_vs_tr)
+      end
+    end
+
+    def check_sort_offense
+      if method_call.arguments.count > 0 || method_call.has_block?
+        add_offense(:sort_vs_sort_by)
+      end
+    end
+
+    def check_each_with_index_offense
+      add_offense(:each_with_index_vs_while)
+    end
+
+    def check_first_offense
+      return method_call unless method_call.receiver.is_a?(MethodCall)
+
+      case method_call.receiver.name
+      when :shuffle
+        add_offense(:shuffle_first_vs_sample)
+      when :select
+        add_offense(:select_first_vs_detect)
+      end
+    end
+
+    def check_each_offense
+      return method_call 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)
+      end
+
+      check_symbol_to_proc
+    end
+
+    def check_flatten_offense
+      return method_call unless method_call.receiver.is_a?(MethodCall)
+
+      if method_call.receiver.name == :map &&
+         method_call.arguments.count == 1 &&
+         method_call.arguments.first.value == 1
+
+        add_offense(:map_flatten_vs_flat_map)
+      end
+    end
+
+    def check_fetch_offense
+      if method_call.arguments.count == 2 && !method_call.has_block?
+        add_offense(:fetch_with_argument_vs_block)
+      end
+    end
+
+    # Need to refactor, fukken complicated conditions.
+    def check_symbol_to_proc
+      return unless method_call.block_argument_names.count == 1
+      return if method_call.block_body.nil?
+      return unless method_call.block_body.sexp_type == :call
+      return if method_call.arguments.count > 0
+
+      body_method_call = MethodCall.new(method_call.block_body)
+
+      return unless body_method_call.arguments.count.zero?
+      return if body_method_call.has_block?
+      return unless body_method_call.receiver.name == method_call.block_argument_names.first
+
+      add_offense(:block_vs_symbol_to_proc)
+    end
+
+    def check_merge_bang_offense
+      return unless method_call.arguments.count == 1
+
+      first_argument = method_call.arguments.first
+      return unless first_argument.type == :hash
+
+      if first_argument.element.drop(1).count == 2 # each key and value is an item by itself.
+        add_offense(:hash_merge_bang_vs_hash_brackets)
+      end
+    end
+
+  end
+end