reek 3.0.4 → 3.1

data/spec/reek/context/code_context_spec.rb

@@ -1,7 +1,6 @@
 require_relative '../../spec_helper'
 require_relative '../../../lib/reek/context/method_context'
 require_relative '../../../lib/reek/context/module_context'
-require_relative '../../../lib/reek/context/root_context'
 
 RSpec.describe Reek::Context::CodeContext do
   context 'name recognition' do
@@ -55,16 +54,6 @@ RSpec.describe Reek::Context::CodeContext do
     end
   end
 
-  context 'generics' do
-    it 'should pass unknown method calls down the stack' do
-      stop = Reek::Context::RootContext.new
-      def stop.bananas(arg1, arg2) arg1 + arg2 + 43 end
-      element = Reek::Context::ModuleContext.new(stop, s(:module, :mod, nil))
-      element = Reek::Context::MethodContext.new(element, s(:def, :bad, s(:args), nil))
-      expect(element.bananas(17, -5)).to eq(55)
-    end
-  end
-
   context 'enumerating syntax elements' do
     context 'in an empty module' do
       before :each do
@@ -161,22 +150,31 @@ EOS
   end
 
   describe '#config_for' do
-    let(:expression) { double('exp') }
+    let(:src) do
+      <<-EOS
+      # :reek:DuplicateMethodCall: { allow_calls: [ puts ] }')
+      def repeated_greeting
+        puts 'Hello!'
+        puts 'Hello!'
+      end
+      EOS
+    end
+    let(:expression) { Reek::Source::SourceCode.from(src).syntax_tree }
     let(:outer) { nil }
     let(:context) { Reek::Context::CodeContext.new(outer, expression) }
     let(:sniffer) { double('sniffer') }
 
     before :each do
       allow(sniffer).to receive(:smell_type).and_return('DuplicateMethodCall')
-      allow(expression).to receive(:full_comment).and_return(
-        ':reek:DuplicateMethodCall: { allow_calls: [ puts ] }')
     end
 
-    it 'gets its configuration from the expression comments' do
-      expect(context.config_for(sniffer)).to eq('allow_calls' => ['puts'])
+    context 'when there is no outer context' do
+      it 'gets its configuration from the expression comments' do
+        expect(context.config_for(sniffer)).to eq('allow_calls' => ['puts'])
+      end
     end
 
-    context 'when there is an outer' do
+    context 'when there is an outer context' do
       let(:outer) { double('outer') }
 
       before :each do
@@ -190,4 +188,55 @@ EOS
       end
     end
   end
+
+  describe '#append_child_context' do
+    let(:context) { Reek::Context::CodeContext.new(nil, double('exp1')) }
+    let(:first_child) { Reek::Context::CodeContext.new(context, double('exp2')) }
+    let(:second_child) { Reek::Context::CodeContext.new(context, double('exp3')) }
+
+    it 'appends the child to the list of children' do
+      context.append_child_context first_child
+      context.append_child_context second_child
+      expect(context.children).to eq [first_child, second_child]
+    end
+  end
+
+  describe '#track_visibility' do
+    let(:context) { Reek::Context::CodeContext.new(nil, double('exp1')) }
+    let(:first_child) { Reek::Context::CodeContext.new(context, double('exp2', name: :foo)) }
+    let(:second_child) { Reek::Context::CodeContext.new(context, double('exp3')) }
+
+    it 'sets visibility on subsequent child contexts' do
+      context.append_child_context first_child
+      context.track_visibility :private
+      context.append_child_context second_child
+      expect(first_child.visibility).to eq :public
+      expect(second_child.visibility).to eq :private
+    end
+
+    it 'sets visibility on specifically mentioned child contexts' do
+      context.append_child_context first_child
+      context.track_visibility :private, [first_child.name]
+      context.append_child_context second_child
+      expect(first_child.visibility).to eq :private
+      expect(second_child.visibility).to eq :public
+    end
+  end
+
+  describe '#each' do
+    let(:context) { Reek::Context::CodeContext.new(nil, double('exp1')) }
+    let(:first_child) { Reek::Context::CodeContext.new(context, double('exp2')) }
+    let(:second_child) { Reek::Context::CodeContext.new(context, double('exp3')) }
+
+    it 'yields each child' do
+      context.append_child_context first_child
+      context.append_child_context second_child
+      result = []
+      context.each do |ctx|
+        result << ctx
+      end
+
+      expect(result).to eq [context, first_child, second_child]
+    end
+  end
 end

data/spec/reek/context/method_context_spec.rb

@@ -1,94 +1,96 @@
 require_relative '../../spec_helper'
 require_relative '../../../lib/reek/context/method_context'
-require_relative '../../../lib/reek/context/root_context'
 
-RSpec.describe Reek::Context::MethodContext, 'matching' do
-  before :each do
-    exp = double('exp').as_null_object
-    expect(exp).to receive(:full_name).at_least(:once).and_return('mod')
-    @element = Reek::Context::MethodContext.new(Reek::Context::RootContext.new, exp)
-  end
+RSpec.describe Reek::Context::MethodContext do
+  let(:method_context) { Reek::Context::MethodContext.new(nil, exp) }
 
-  it 'should recognise itself in a collection of names' do
-    expect(@element.matches?(['banana', 'mod'])).to eq(true)
-    expect(@element.matches?(['banana'])).to eq(false)
-  end
+  describe '#matches?' do
+    let(:exp) { double('exp').as_null_object }
 
-  it 'should recognise itself in a collection of REs' do
-    expect(@element.matches?([/banana/, /mod/])).to eq(true)
-    expect(@element.matches?([/banana/])).to eq(false)
-  end
-end
+    before :each do
+      expect(exp).to receive(:full_name).at_least(:once).and_return('mod')
+    end
 
-RSpec.describe Reek::Context::MethodContext do
-  let(:mc) do
-    sexp = s(:def, :foo, s(:args, s(:arg, :bar)), nil)
-    Reek::Context::MethodContext.new(Reek::Context::RootContext.new, sexp)
+    it 'should recognise itself in a collection of names' do
+      expect(method_context.matches?(['banana', 'mod'])).to eq(true)
+      expect(method_context.matches?(['banana'])).to eq(false)
+    end
+
+    it 'should recognise itself in a collection of REs' do
+      expect(method_context.matches?([/banana/, /mod/])).to eq(true)
+      expect(method_context.matches?([/banana/])).to eq(false)
+    end
   end
 
   describe '#envious_receivers' do
+    let(:exp) { s(:def, :foo, s(:args, s(:arg, :bar)), nil) }
+
     it 'should ignore ivars as refs to self' do
-      mc.record_call_to s(:send, s(:ivar, :@cow), :feed_to)
-      expect(mc.envious_receivers).to be_empty
+      method_context.record_call_to s(:send, s(:ivar, :@cow), :feed_to)
+      expect(method_context.envious_receivers).to be_empty
     end
 
     it 'should ignore explicit calls to self' do
-      mc.refs.record_reference_to :other
-      mc.record_call_to s(:send, s(:self), :thing)
-      expect(mc.envious_receivers).to be_empty
+      method_context.refs.record_reference_to :other
+      method_context.record_call_to s(:send, s(:self), :thing)
+      expect(method_context.envious_receivers).to be_empty
     end
 
     it 'should ignore implicit calls to self' do
-      mc.record_call_to s(:send, s(:lvar, :text), :each, s(:arglist))
-      mc.record_call_to s(:send, nil, :shelve, s(:arglist))
-      expect(mc.envious_receivers).to be_empty
+      method_context.record_call_to s(:send, s(:lvar, :text), :each, s(:arglist))
+      method_context.record_call_to s(:send, nil, :shelve, s(:arglist))
+      expect(method_context.envious_receivers).to be_empty
     end
 
     it 'should record envious calls' do
-      mc.record_call_to s(:send, s(:lvar, :bar), :baz)
-      expect(mc.envious_receivers).to include(:bar)
+      method_context.record_call_to s(:send, s(:lvar, :bar), :baz)
+      expect(method_context.envious_receivers).to include(:bar)
     end
   end
-end
 
-RSpec.describe Reek::Context::MethodParameters, 'default assignments' do
-  def assignments_from(src)
-    exp = Reek::Source::SourceCode.from(src).syntax_tree
-    ctx = Reek::Context::MethodContext.new(Reek::Context::RootContext.new, exp)
-    ctx.parameters.default_assignments
-  end
-
-  context 'with no defaults' do
-    it 'returns an empty hash' do
-      src = 'def meth(arga, argb, &blk) end'
-      expect(assignments_from(src)).to be_empty
+  describe '#default_assignments' do
+    def assignments_from(src)
+      exp = Reek::Source::SourceCode.from(src).syntax_tree
+      ctx = Reek::Context::MethodContext.new(nil, exp)
+      ctx.default_assignments
     end
-  end
 
-  context 'with 1 default' do
-    before :each do
-      src = 'def meth(arga, argb=456, &blk) end'
-      @defaults = assignments_from(src)
-    end
-    it 'returns the param-value pair' do
-      expect(@defaults[0]).to eq [:argb, s(:int, 456)]
+    context 'with no defaults' do
+      it 'returns an empty hash' do
+        src = 'def meth(arga, argb, &blk) end'
+        expect(assignments_from(src)).to be_empty
+      end
     end
-    it 'returns the nothing else' do
-      expect(@defaults.length).to eq(1)
-    end
-  end
 
-  context 'with 2 defaults' do
-    before :each do
-      src = 'def meth(arga=123, argb=456, &blk) end'
-      @defaults = assignments_from(src)
-    end
-    it 'returns both param-value pairs' do
-      expect(@defaults[0]).to eq [:arga, s(:int, 123)]
-      expect(@defaults[1]).to eq [:argb, s(:int, 456)]
+    context 'with 1 default' do
+      before :each do
+        src = 'def meth(arga, argb=456, &blk) end'
+        @defaults = assignments_from(src)
+      end
+
+      it 'returns the param-value pair' do
+        expect(@defaults[0]).to eq [:argb, s(:int, 456)]
+      end
+
+      it 'returns the nothing else' do
+        expect(@defaults.length).to eq(1)
+      end
     end
-    it 'returns nothing else' do
-      expect(@defaults.length).to eq(2)
+
+    context 'with 2 defaults' do
+      before :each do
+        src = 'def meth(arga=123, argb=456, &blk) end'
+        @defaults = assignments_from(src)
+      end
+
+      it 'returns both param-value pairs' do
+        expect(@defaults[0]).to eq [:arga, s(:int, 123)]
+        expect(@defaults[1]).to eq [:argb, s(:int, 456)]
+      end
+
+      it 'returns nothing else' do
+        expect(@defaults.length).to eq(2)
+      end
     end
   end
 end

data/spec/reek/context/root_context_spec.rb

@@ -3,7 +3,9 @@ require_relative '../../../lib/reek/context/root_context'
 
 RSpec.describe Reek::Context::RootContext do
   before :each do
-    @root = Reek::Context::RootContext.new
+    src = 'foo = 1'
+    ast = Reek::Source::SourceCode.from(src).syntax_tree
+    @root = Reek::Context::RootContext.new(ast)
   end
 
   context 'full_name' do

data/spec/reek/context/singleton_method_context_spec.rb

@@ -1,11 +1,10 @@
 require_relative '../../spec_helper'
 require_relative '../../../lib/reek/context/singleton_method_context'
-require_relative '../../../lib/reek/context/root_context'
 
 RSpec.describe Reek::Context::SingletonMethodContext do
   let(:smc) do
     sexp = s(:def, :foo, s(:args, s(:arg, :bar)), nil)
-    Reek::Context::SingletonMethodContext.new(Reek::Context::RootContext.new, sexp)
+    Reek::Context::SingletonMethodContext.new(nil, sexp)
   end
 
   describe '#envious_receivers' do

data/spec/reek/examiner_spec.rb

@@ -45,15 +45,12 @@ RSpec.describe Reek::Examiner do
   end
 
   context 'with a partially masked smelly File' do
-    around(:each) do |example|
-      with_test_config('spec/samples/all_but_one_masked/masked.reek') do
-        example.run
-      end
-    end
+    let(:path) { SAMPLES_PATH.join('all_but_one_masked/masked.reek') }
+    let(:configuration) { test_configuration_for(path) }
 
     before :each do
-      smelly_file = File.new(Dir['spec/samples/all_but_one_masked/d*.rb'][0])
-      @examiner = described_class.new(smelly_file)
+      smelly_file = Pathname.glob(SAMPLES_PATH.join('all_but_one_masked/d*.rb')).first
+      @examiner = described_class.new(smelly_file, [], configuration: configuration)
     end
 
     it_should_behave_like 'one smell found'
@@ -61,7 +58,7 @@ RSpec.describe Reek::Examiner do
 
   context 'with a fragrant File' do
     before :each do
-      clean_file = File.new(Dir['spec/samples/three_clean_files/*.rb'][0])
+      clean_file = Pathname.glob(SAMPLES_PATH.join('three_clean_files/*.rb')).first
       @examiner = described_class.new(clean_file)
     end
 

data/spec/reek/report/xml_report_spec.rb

@@ -1,3 +1,4 @@
+require 'pathname'
 require_relative '../../spec_helper'
 require_relative '../../../lib/reek/examiner'
 require_relative '../../../lib/reek/report/report'
@@ -27,8 +28,8 @@ RSpec.describe Reek::Report::XMLReport do
     end
 
     it 'prints non-empty checkstyle xml' do
-      sample_path = File.expand_path 'checkstyle.xml', 'spec/samples'
-      expect { instance.show }.to output(File.read(sample_path)).to_stdout
+      sample_path = SAMPLES_PATH.join('checkstyle.xml')
+      expect { instance.show }.to output(sample_path.read).to_stdout
     end
   end
 end

data/spec/reek/smells/attribute_spec.rb

@@ -6,21 +6,16 @@ require_relative 'smell_detector_shared'
 RSpec.describe Reek::Smells::Attribute do
   let(:config) do
     {
-      Attribute: { Reek::Smells::SmellConfiguration::ENABLED_KEY => true }
+      Reek::Smells::Attribute => { Reek::Smells::SmellConfiguration::ENABLED_KEY => true }
     }
   end
+  let(:configuration) { test_configuration_for(config) }
 
   before(:each) do
     @source_name = 'dummy_source'
     @detector = build(:smell_detector, smell_type: :Attribute, source: @source_name)
   end
 
-  around(:each) do |example|
-    with_test_config(config) do
-      example.run
-    end
-  end
-
   it_should_behave_like 'SmellDetector'
 
   context 'with no attributes' do
@@ -28,7 +23,7 @@ RSpec.describe Reek::Smells::Attribute do
       expect('
         class Klass
         end
-      ').to_not reek_of(:Attribute)
+      ').to_not reek_of(:Attribute, {}, configuration)
     end
   end
 
@@ -45,7 +40,7 @@ RSpec.describe Reek::Smells::Attribute do
           private
           attr :super_thing2
         end
-      ').to_not reek_of(:Attribute)
+      ').to_not reek_of(:Attribute, {}, configuration)
     end
 
     it 'records attr attribute in a module' do
@@ -53,7 +48,7 @@ RSpec.describe Reek::Smells::Attribute do
         module Mod
           attr :my_attr
         end
-      ').to reek_of(:Attribute, name: 'my_attr')
+      ').to reek_of(:Attribute, { name: 'my_attr' }, configuration)
     end
 
     it 'records attr attribute' do
@@ -61,7 +56,7 @@ RSpec.describe Reek::Smells::Attribute do
         class Klass
           attr :my_attr
         end
-      ').to reek_of(:Attribute, name: 'my_attr')
+      ').to reek_of(:Attribute, { name: 'my_attr' }, configuration)
     end
 
     it 'records reader attribute' do
@@ -69,7 +64,7 @@ RSpec.describe Reek::Smells::Attribute do
         class Klass
           attr_reader :my_attr
         end
-      ').to reek_of(:Attribute, name: 'my_attr')
+      ').to reek_of(:Attribute, { name: 'my_attr' }, configuration)
     end
 
     it 'records writer attribute' do
@@ -77,7 +72,7 @@ RSpec.describe Reek::Smells::Attribute do
         class Klass
           attr_writer :my_attr
         end
-      ').to reek_of(:Attribute, name: 'my_attr')
+      ').to reek_of(:Attribute, { name: 'my_attr' }, configuration)
     end
 
     it 'records accessor attribute' do
@@ -85,7 +80,7 @@ RSpec.describe Reek::Smells::Attribute do
         class Klass
           attr_accessor :my_attr
         end
-      ').to reek_of(:Attribute, name: 'my_attr')
+      ').to reek_of(:Attribute, { name: 'my_attr' }, configuration)
     end
 
     it 'records attr attribute after switching visbility' do
@@ -97,7 +92,7 @@ RSpec.describe Reek::Smells::Attribute do
           private :my_attr
           public :my_attr
         end
-      ').to reek_of(:Attribute, name: 'my_attr')
+      ').to reek_of(:Attribute, { name: 'my_attr' }, configuration)
     end
 
     it "doesn't record protected attributes" do
@@ -107,7 +102,7 @@ RSpec.describe Reek::Smells::Attribute do
           attr :iam_protected
         end
       '
-      expect(src).to_not reek_of(:Attribute, name: 'iam_protected')
+      expect(src).to_not reek_of(:Attribute, { name: 'iam_protected' }, configuration)
     end
 
     it "doesn't record private attributes" do
@@ -117,7 +112,7 @@ RSpec.describe Reek::Smells::Attribute do
           attr :iam_private
         end
       '
-      expect(src).to_not reek_of(:Attribute, name: 'iam_private')
+      expect(src).to_not reek_of(:Attribute, { name: 'iam_private' }, configuration)
     end
   end
 end