fasterer 0.1.0

data/lib/fasterer/scanners/method_definition_scanner.rb

@@ -0,0 +1,52 @@
+require 'fasterer/method_definition'
+require 'fasterer/method_call'
+require 'fasterer/offense'
+require 'fasterer/scanners/offensive'
+
+module Fasterer
+  class MethodDefinitionScanner
+    include Fasterer::Offensive
+
+    attr_reader :element
+
+    def initialize(element)
+      @element = element
+      check_offense
+    end
+
+    private
+
+    def check_offense
+      if method_definition.has_block?
+        scan_block_call_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?(Fasterer::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
+  end
+end

data/lib/fasterer/scanners/offensive.rb

@@ -0,0 +1,25 @@
+require 'fasterer/offense'
+
+module Fasterer
+  module Offensive
+
+    attr_accessor :offense
+
+    def offensive?
+      !!offense
+    end
+
+    alias_method :offense_detected?, :offensive?
+
+    private
+
+      def add_offense(offense_name, element_line_number = element.line)
+        self.offense = Fasterer::Offense.new(offense_name, element_line_number)
+      end
+
+      def check_offense
+        raise NotImplementedError
+      end
+
+  end
+end

data/lib/fasterer/scanners/rescue_call_scanner.rb

@@ -0,0 +1,28 @@
+require 'fasterer/rescue_call'
+require 'fasterer/offense'
+require 'fasterer/scanners/offensive'
+
+module Fasterer
+  class RescueCallScanner
+    include Fasterer::Offensive
+
+    attr_reader :element
+
+    def initialize(element)
+      @element = element
+      check_offense
+    end
+
+    private
+
+    def check_offense
+      if rescue_call.rescue_classes.include? :NoMethodError
+        add_offense(:rescue_vs_respond_to)
+      end
+    end
+
+    def rescue_call
+      @rescue_call ||= RescueCall.new(element)
+    end
+  end
+end

data/lib/fasterer/token.rb

@@ -0,0 +1,27 @@
+module Fasterer
+  class Token
+    def initialize(name)
+      @name = name
+    end
+
+    def method_definition?
+      name == :def
+    end
+
+    def method_call?
+      name == :call
+    end
+
+    def command_call?
+      name == :command
+    end
+
+    def parallel_assignment?
+      name == :massign
+    end
+
+    def for_loop?
+      name == :for
+    end
+  end
+end

data/lib/fasterer/version.rb

@@ -0,0 +1,3 @@
+module Fasterer
+  VERSION = '0.1.0'
+end

data/spec/lib/fasterer/analyzer/01_parallel_assignment_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Fasterer::Analyzer do
+
+  let(:test_file_path) { RSpec.root.join('support', 'analyzer', '01_parallel_assignment.rb') }
+
+  it 'should detect parallel assignment 2 times' do
+    analyzer = Fasterer::Analyzer.new(test_file_path)
+    analyzer.scan
+    expect(analyzer.errors[:parallel_assignment].count).to eq(2)
+  end
+end

data/spec/lib/fasterer/analyzer/02_rescue_vs_respond_to_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Fasterer::Analyzer do
+
+  let(:test_file_path) { RSpec.root.join('support', 'analyzer', '02_rescue_vs_respond_to.rb') }
+
+  it 'should detect rescue NoMethodError' do
+    analyzer = Fasterer::Analyzer.new(test_file_path)
+    analyzer.scan
+    expect(analyzer.errors[:rescue_vs_respond_to].count).to eq(3)
+  end
+end

data/spec/lib/fasterer/analyzer/03_module_eval_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Fasterer::Analyzer do
+
+  let(:test_file_path) { RSpec.root.join('support', 'analyzer', '03_module_eval.rb') }
+
+  it 'should detect module eval' do
+    analyzer = Fasterer::Analyzer.new(test_file_path)
+    analyzer.scan
+    expect(analyzer.errors[:module_eval].count).to eq(1)
+  end
+end

data/spec/lib/fasterer/analyzer/04_find_vs_bsearch_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Fasterer::Analyzer do
+
+  let(:test_file_path) { RSpec.root.join('support', 'analyzer', '04_find_vs_bsearch.rb') }
+
+  xit 'should detect Array#find' do
+    analyzer = Fasterer::Analyzer.new(test_file_path)
+    analyzer.scan
+    # expect(analyzer.error_occurrence[:module_eval]).to eq(1)
+  end
+end

data/spec/lib/fasterer/analyzer/06_shuffle_first_vs_sample_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Fasterer::Analyzer do
+
+  let(:test_file_path) { RSpec.root.join('support', 'analyzer', '06_shuffle_first_vs_sample.rb') }
+
+  it 'should detect a for loop' do
+    analyzer = Fasterer::Analyzer.new(test_file_path)
+    analyzer.scan
+    expect(analyzer.errors[:shuffle_first_vs_sample].count).to eq(5)
+  end
+end

data/spec/lib/fasterer/analyzer/08_for_loop_vs_each_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Fasterer::Analyzer do
+
+  let(:test_file_path) { RSpec.root.join('support', 'analyzer', '08_for_loop_vs_each.rb') }
+
+  it 'should detect a for loop' do
+    analyzer = Fasterer::Analyzer.new(test_file_path)
+    analyzer.scan
+    expect(analyzer.errors[:for_loop_vs_each].count).to eq(1)
+  end
+end

data/spec/lib/fasterer/analyzer/09_each_with_index_vs_while_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Fasterer::Analyzer do
+
+  let(:test_file_path) { RSpec.root.join('support', 'analyzer', '09_each_with_index_vs_while.rb') }
+
+  it 'should detect a for loop' do
+    analyzer = Fasterer::Analyzer.new(test_file_path)
+    analyzer.scan
+    expect(analyzer.errors[:each_with_index_vs_while].count).to eq(1)
+  end
+end

data/spec/lib/fasterer/analyzer/10_map_flatten_vs_flat_map_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Fasterer::Analyzer do
+
+  let(:test_file_path) { RSpec.root.join('support', 'analyzer', '10_map_flatten_vs_flat_map.rb') }
+
+  it 'should detect a map{}.flatten(1) ' do
+    analyzer = Fasterer::Analyzer.new(test_file_path)
+    analyzer.scan
+    expect(analyzer.errors[:map_flatten_vs_flat_map].count).to eq(2)
+  end
+end

data/spec/lib/fasterer/analyzer/11_reverse_each_vs_reverse_each_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Fasterer::Analyzer do
+
+  let(:test_file_path) { RSpec.root.join('support', 'analyzer', '11_reverse_each_vs_reverse_each.rb') }
+
+  it 'should detect a for loop' do
+    analyzer = Fasterer::Analyzer.new(test_file_path)
+    analyzer.scan
+    expect(analyzer.errors[:reverse_each_vs_reverse_each].count).to eq(2)
+  end
+end

data/spec/lib/fasterer/analyzer/12_select_first_vs_detect_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Fasterer::Analyzer do
+
+  let(:test_file_path) { RSpec.root.join('support', 'analyzer', '12_select_first_vs_detect.rb') }
+
+  it 'should detect sort once' do
+    analyzer = Fasterer::Analyzer.new(test_file_path)
+    analyzer.scan
+    expect(analyzer.errors[:select_first_vs_detect].count).to eq(2)
+  end
+end

data/spec/lib/fasterer/analyzer/13_sort_vs_sort_by_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Fasterer::Analyzer do
+
+  let(:test_file_path) { RSpec.root.join('support', 'analyzer', '13_sort_vs_sort_by.rb') }
+
+  it 'should detect sort once' do
+    analyzer = Fasterer::Analyzer.new(test_file_path)
+    analyzer.scan
+    expect(analyzer.errors[:sort_vs_sort_by].count).to eq(1)
+  end
+end

data/spec/lib/fasterer/analyzer/14_fetch_with_argument_vs_block_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Fasterer::Analyzer do
+
+  let(:test_file_path) { RSpec.root.join('support', 'analyzer', '14_fetch_with_argument_vs_block.rb') }
+
+  it 'should detect keys fetch with argument once' do
+    analyzer = Fasterer::Analyzer.new(test_file_path)
+    analyzer.scan
+    expect(analyzer.errors[:fetch_with_argument_vs_block].count).to eq(1)
+  end
+end

data/spec/lib/fasterer/analyzer/15_keys_each_vs_each_key_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Fasterer::Analyzer do
+
+  let(:test_file_path) { RSpec.root.join('support', 'analyzer', '15_keys_each_vs_each_key.rb') }
+
+  it 'should detect keys each 3 times' do
+    analyzer = Fasterer::Analyzer.new(test_file_path)
+    analyzer.scan
+    expect(analyzer.errors[:keys_each_vs_each_key].count).to eq(3)
+  end
+end

data/spec/lib/fasterer/analyzer/16_hash_merge_bang_vs_hash_brackets_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Fasterer::Analyzer do
+
+  let(:test_file_path) { RSpec.root.join('support', 'analyzer', '16_hash_merge_bang_vs_hash_brackets.rb') }
+
+  it 'should detect keys each 3 times' do
+    analyzer = Fasterer::Analyzer.new(test_file_path)
+    analyzer.scan
+    expect(analyzer.errors[:hash_merge_bang_vs_hash_brackets].count).to eq(3)
+  end
+end

data/spec/lib/fasterer/analyzer/18_block_vs_symbol_to_proc_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Fasterer::Analyzer do
+
+  let(:test_file_path) { RSpec.root.join('support', 'analyzer', '18_block_vs_symbol_to_proc.rb') }
+
+  it 'should block that could be called with symbol 2 times' do
+    analyzer = Fasterer::Analyzer.new(test_file_path)
+    analyzer.scan
+    expect(analyzer.errors[:block_vs_symbol_to_proc].count).to eq(2)
+  end
+end

data/spec/lib/fasterer/analyzer/19_proc_call_vs_yield_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Fasterer::Analyzer do
+
+  let(:test_file_path) { RSpec.root.join('support', 'analyzer', '19_proc_call_vs_yield.rb') }
+
+  it 'should detect sort once' do
+    analyzer = Fasterer::Analyzer.new(test_file_path)
+    analyzer.scan
+    expect(analyzer.errors[:proc_call_vs_yield].count).to eq(3)
+  end
+end

data/spec/lib/fasterer/analyzer/24_gsub_vs_tr_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Fasterer::Analyzer do
+
+  let(:test_file_path) { RSpec.root.join('support', 'analyzer', '24_gsub_vs_tr.rb') }
+
+  it 'should detect gsub 4 times' do
+    analyzer = Fasterer::Analyzer.new(test_file_path)
+    analyzer.scan
+    expect(analyzer.errors[:gsub_vs_tr].count).to eq(4)
+  end
+end

data/spec/lib/fasterer/analyzer/98_misc_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Fasterer::Analyzer do
+
+  let(:test_file_path) { RSpec.root.join('support', 'analyzer', '98_misc.rb') }
+
+  it 'should detect gsub 4 times' do
+    analyzer = Fasterer::Analyzer.new(test_file_path)
+    analyzer.scan
+  end
+end

data/spec/lib/fasterer/analyzer/99_exceptional_files_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Fasterer::Analyzer do
+
+  let(:test_file_path) { RSpec.root.join('support', 'analyzer', '99_exceptional_files.rb') }
+
+  it 'diacritics should not raise an error' do
+    analyzer = Fasterer::Analyzer.new(test_file_path)
+    expect { analyzer.scan }.not_to raise_error
+  end
+end

data/spec/lib/fasterer/method_call_spec.rb

@@ -0,0 +1,483 @@
+require 'spec_helper'
+
+describe Fasterer::MethodCall do
+
+  let(:ripper) do
+    Fasterer::Parser.parse(code)
+  end
+
+  let(:method_call) do
+    Fasterer::MethodCall.new(call_element)
+  end
+
+  describe 'with explicit receiver' do
+    describe 'without arguments, without block, called with parentheses' do
+      describe 'method call on a constant' do
+
+        let(:code) { 'User.hello()' }
+
+        # This is where the :call token will be recognized.
+        let(:call_element) { ripper }
+
+        it 'should detect constant' do
+          expect(method_call.method_name).to eq(:hello)
+          expect(method_call.arguments).to be_empty
+        end
+
+      end
+
+      describe 'method call on a integer' do
+
+        let(:code) { '1.hello()' }
+
+        # This is where the :call token will be recognized.
+        let(:call_element) { ripper }
+
+        it 'should detect integer' do
+          expect(method_call.method_name).to eq(:hello)
+          expect(method_call.arguments).to be_empty
+        end
+
+      end
+
+      describe 'method call on a string' do
+
+        let(:code) { "'hello'.hello()" }
+
+        let(:call_element) { ripper }
+
+        it 'should detect string' do
+          expect(method_call.method_name).to eq(:hello)
+          expect(method_call.arguments).to be_empty
+        end
+
+      end
+
+      describe 'method call on a variable' do
+
+        let(:code) do
+          "number_one = 1\n"\
+          'number_one.hello()'
+        end
+
+        let(:call_element) { ripper[2] }
+
+        it 'should detect variable' do
+          expect(method_call.method_name).to eq(:hello)
+          expect(method_call.arguments).to be_empty
+          expect(method_call.receiver).to be_a(Fasterer::VariableReference)
+          expect(method_call.receiver.name).to eq(:number_one)
+        end
+
+      end
+
+      describe 'method call on a method' do
+
+        let(:code) { '1.hi(2).hello()' }
+
+        let(:call_element) { ripper }
+
+        it 'should detect method' do
+          expect(method_call.method_name).to eq(:hello)
+          expect(method_call.receiver).to be_a(Fasterer::MethodCall)
+          expect(method_call.receiver.name).to eq(:hi)
+          expect(method_call.arguments).to be_empty
+        end
+
+      end
+    end
+
+    describe 'without arguments, without block, called without parentheses' do
+      describe 'method call on a constant' do
+
+        let(:code) { 'User.hello' }
+
+        let(:call_element) { ripper }
+
+        it 'should detect constant' do
+          expect(method_call.method_name).to eq(:hello)
+          expect(method_call.arguments).to be_empty
+        end
+
+      end
+
+      describe 'method call on a integer' do
+
+        let(:code) { '1.hello' }
+
+        # This is where the :call token will be recognized.
+        let(:call_element) { ripper }
+
+        it 'should detect integer' do
+          expect(method_call.method_name).to eq(:hello)
+          expect(method_call.arguments).to be_empty
+        end
+
+      end
+
+      describe 'method call on a string' do
+
+        let(:code) { "'hello'.hello" }
+
+        let(:call_element) { ripper }
+
+        it 'should detect string' do
+          expect(method_call.method_name).to eq(:hello)
+          expect(method_call.arguments).to be_empty
+        end
+
+      end
+
+      describe 'method call on a variable' do
+
+        let(:code) do
+          "number_one = 1\n"\
+          'number_one.hello'
+        end
+
+        let(:call_element) { ripper[2] }
+
+        it 'should detect variable' do
+          expect(method_call.method_name).to eq(:hello)
+          expect(method_call.arguments).to be_empty
+          expect(method_call.receiver).to be_a(Fasterer::VariableReference)
+          expect(method_call.receiver.name).to eq(:number_one)
+        end
+
+      end
+
+      describe 'method call on a method' do
+
+        let(:code) { '1.hi(2).hello' }
+
+        let(:call_element) { ripper }
+
+        it 'should detect method' do
+          expect(method_call.method_name).to eq(:hello)
+          expect(method_call.receiver).to be_a(Fasterer::MethodCall)
+          expect(method_call.receiver.name).to eq(:hi)
+          expect(method_call.arguments).to be_empty
+        end
+
+      end
+    end
+
+    describe 'with do end block' do
+
+      describe 'and no arguments, without block parameter' do
+
+        let(:code) do
+          <<-code
+            number_one.fetch do
+              number_two = 2
+              number_three = 3
+            end
+          code
+        end
+
+        let(:call_element) { ripper }
+
+        it 'should detect block' do
+          expect(method_call.method_name).to eq(:fetch)
+          expect(method_call.arguments).to be_empty
+          expect(method_call.has_block?).to be
+          expect(method_call.block_argument_names.count).to be(0)
+          expect(method_call.receiver).to be_a(Fasterer::MethodCall)
+        end
+
+      end
+
+      describe 'and no arguments, with block parameter' do
+
+        let(:code) do
+          <<-code
+            number_one.fetch do |el|
+              number_two = 2
+              number_three = 3
+            end
+          code
+        end
+
+        let(:call_element) { ripper }
+
+        it 'should detect block' do
+          expect(method_call.method_name).to eq(:fetch)
+          expect(method_call.arguments).to be_empty
+          expect(method_call.has_block?).to be
+          expect(method_call.block_argument_names.count).to be(1)
+          expect(method_call.block_argument_names.first).to be(:el)
+          expect(method_call.receiver).to be_a(Fasterer::MethodCall)
+        end
+
+      end
+
+      describe 'and no arguments, with block parameter' do
+
+        let(:code) do
+          <<-code
+            number_one.fetch do |el, tip|
+              number_two = 2
+              number_three = 3
+            end
+          code
+        end
+
+        let(:call_element) { ripper }
+
+        it 'should detect block' do
+          expect(method_call.method_name).to eq(:fetch)
+          expect(method_call.arguments).to be_empty
+          expect(method_call.has_block?).to be
+          expect(method_call.block_argument_names.count).to be(2)
+          expect(method_call.block_argument_names.first).to be(:el)
+          expect(method_call.block_argument_names.last).to be(:tip)
+          expect(method_call.receiver).to be_a(Fasterer::MethodCall)
+        end
+
+      end
+
+      describe 'and one argument within parentheses' do
+
+        let(:code) do
+          <<-code
+            number_one = 1
+            number_one.fetch(100) do |el|
+              number_two = 2
+              number_three = 3
+            end
+          code
+        end
+
+        let(:call_element) { ripper[2] }
+
+        it 'should detect block' do
+          expect(method_call.method_name).to eq(:fetch)
+          expect(method_call.arguments.count).to be(1)
+          expect(method_call.has_block?).to be
+          expect(method_call.receiver).to be_a(Fasterer::VariableReference)
+        end
+
+      end
+    end
+
+    describe 'with curly block' do
+      describe 'in one line' do
+
+        let(:code) do
+          <<-code
+            number_one = 1
+            number_one.fetch { |el| number_two = 2 }
+          code
+        end
+
+        let(:call_element) { ripper[2] }
+
+        it 'should detect block' do
+          expect(method_call.method_name).to eq(:fetch)
+          expect(method_call.arguments).to be_empty
+          expect(method_call.has_block?).to be
+          expect(method_call.receiver).to be_a(Fasterer::VariableReference)
+        end
+
+      end
+
+      describe 'multi lined' do
+
+        let(:code) do
+          <<-code
+            number_one = 1
+            number_one.fetch { |el|
+              number_two = 2
+              number_three = 3
+            }
+          code
+        end
+
+        let(:call_element) { ripper[2] }
+
+        it 'should detect block' do
+          expect(method_call.method_name).to eq(:fetch)
+          expect(method_call.arguments).to be_empty
+          expect(method_call.has_block?).to be
+          expect(method_call.receiver).to be_a(Fasterer::VariableReference)
+        end
+
+      end
+    end
+
+    describe 'with arguments, without block, called with parentheses' do
+
+      describe 'method call with an argument' do
+
+        let(:code) { '{}.fetch(:writing)' }
+
+        let(:call_element) { ripper }
+
+        it 'should detect argument' do
+          expect(method_call.method_name).to eq(:fetch)
+          expect(method_call.arguments.count).to eq(1)
+          expect(method_call.arguments.first.type).to eq(:lit)
+        end
+
+      end
+    end
+
+    describe 'arguments without parenthesis' do
+      describe 'method call with an argument' do
+
+        let(:code) { '{}.fetch :writing, :listening' }
+
+        let(:call_element) { ripper }
+
+        it 'should detect argument' do
+          expect(method_call.method_name).to eq(:fetch)
+          expect(method_call.arguments.count).to eq(2)
+          expect(method_call.arguments[0].type).to eq(:lit)
+          expect(method_call.arguments[1].type).to eq(:lit)
+        end
+
+      end
+    end
+  end
+
+  describe 'with implicit receiver' do
+  end
+
+  describe 'method call with an argument and a block' do
+
+    let(:code) do
+      <<-code
+        number_one = 1
+        number_one.fetch(:writing) { [*1..100] }
+      code
+    end
+
+    let(:call_element) { ripper[2] }
+
+    it 'should detect argument and a block' do
+      expect(method_call.method_name).to eq(:fetch)
+      expect(method_call.arguments.count).to eq(1)
+      expect(method_call.arguments.first.type).to eq(:lit)
+      expect(method_call.has_block?).to be
+      expect(method_call.receiver).to be_a(Fasterer::VariableReference)
+    end
+
+  end
+
+  describe 'method call without an explicit receiver' do
+
+    let(:code) { 'fetch(:writing, :listening)' }
+
+    let(:call_element) { ripper }
+
+    it 'should detect two arguments' do
+      expect(method_call.method_name).to eq(:fetch)
+      expect(method_call.arguments.count).to eq(2)
+      expect(method_call.arguments[0].type).to eq(:lit)
+      expect(method_call.arguments[1].type).to eq(:lit)
+      expect(method_call.receiver).to be_nil
+    end
+
+  end
+
+  describe 'method call without an explicit receiver and without brackets' do
+
+    let(:code) { 'fetch :writing, :listening' }
+
+    let(:call_element) { ripper }
+
+    it 'should detect two arguments' do
+      expect(method_call.method_name).to eq(:fetch)
+      expect(method_call.arguments.count).to eq(2)
+      expect(method_call.arguments[0].type).to eq(:lit)
+      expect(method_call.arguments[1].type).to eq(:lit)
+      expect(method_call.receiver).to be_nil
+    end
+
+  end
+
+  describe 'method call without an explicit receiver and without brackets and do end' do
+
+    let(:code) do
+      <<-code
+        "fetch :writing do\n"\
+        "end"
+      code
+    end
+
+    let(:call_element) { ripper.drop(1).first.first }
+
+    it 'should detect argument and a block' do
+      # expect(method_call.method_name).to eq('fetch')
+      # expect(method_call.arguments.count).to eq(2)
+      # expect(method_call.arguments[0].type).to eq(:symbol_literal)
+      # expect(method_call.arguments[1].type).to eq(:symbol_literal)
+      # expect(method_call.receiver).to be_nil
+    end
+
+  end
+
+  describe 'method call with two arguments' do
+
+    let(:code) do
+      "number_one = 1\n"\
+      'number_one.fetch(:writing, :zumba)'
+    end
+
+    let(:call_element) { ripper[2] }
+
+    it 'should detect arguments' do
+      expect(method_call.method_name).to eq(:fetch)
+      expect(method_call.arguments.count).to eq(2)
+      expect(method_call.arguments[0].type).to eq(:lit)
+      expect(method_call.arguments[1].type).to eq(:lit)
+      expect(method_call.receiver).to be_a(Fasterer::VariableReference)
+    end
+
+  end
+
+  describe 'method call with a regex argument' do
+
+    let(:code) { '{}.fetch(/.*/)' }
+
+    let(:call_element) { ripper }
+
+    it 'should detect regex argument' do
+      expect(method_call.method_name).to eq(:fetch)
+      expect(method_call.arguments.count).to eq(1)
+      expect(method_call.arguments[0].type).to eq(:lit)
+      expect(method_call.arguments[0].value).to be_a(Regexp)
+    end
+
+  end
+
+  describe 'method call with a integer argument' do
+
+    let(:code) { '[].flatten(1)' }
+
+    let(:call_element) { ripper }
+
+    it 'should detect regex argument' do
+      expect(method_call.method_name).to eq(:flatten)
+      expect(method_call.arguments.count).to eq(1)
+      expect(method_call.arguments[0].type).to eq(:lit)
+      expect(method_call.arguments[0].value).to eq(1)
+    end
+
+  end
+
+  describe 'method call with equals operator' do
+
+    let(:code) { 'method_call_with_equals.rb' }
+
+    let(:call_element) { ripper.drop(1).first.first[1] }
+
+    xit 'should recognize receiver' do
+      # expect(method_call.method_name).to eq('hello')
+      # expect(method_call.receiver).to be_a(Fasterer::MethodCall)
+      # expect(method_call.receiver.name).to eq('hi')
+    end
+
+  end
+
+end