reek 3.8.3 → 3.9.0

data/spec/reek/context/code_context_spec.rb

@@ -45,11 +45,11 @@ RSpec.describe Reek::Context::CodeContext do
     context 'when there is an outer' do
       let(:ctx)        { Reek::Context::CodeContext.new(outer, exp) }
       let(:outer_name) { 'another_random sting' }
-      let(:outer)      { double('outer') }
+      let(:outer)      { Reek::Context::CodeContext.new(nil, double('exp1')) }
 
       before :each do
+        ctx.register_with_parent outer
         allow(outer).to receive(:full_name).at_least(:once).and_return(outer_name)
-        allow(outer).to receive(:config).and_return({})
       end
 
       it 'creates the correct full name' do
@@ -174,6 +174,7 @@ RSpec.describe Reek::Context::CodeContext do
     let(:sniffer) { double('sniffer') }
 
     before :each do
+      context.register_with_parent(outer)
       allow(sniffer).to receive(:smell_type).and_return('DuplicateMethodCall')
     end
 
@@ -184,7 +185,7 @@ RSpec.describe Reek::Context::CodeContext do
     end
 
     context 'when there is an outer context' do
-      let(:outer) { double('outer') }
+      let(:outer) { Reek::Context::CodeContext.new(nil, double('exp1')) }
 
       before :each do
         allow(outer).to receive(:config_for).with(sniffer).and_return(
@@ -198,37 +199,16 @@ RSpec.describe Reek::Context::CodeContext do
     end
   end
 
-  describe '#append_child_context' do
+  describe '#register_with_parent' 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 "appends the element to the parent context's list of children" do
+      first_child.register_with_parent context
+      second_child.register_with_parent context
 
-    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
+      expect(context.children).to eq [first_child, second_child]
     end
   end
 
@@ -238,8 +218,9 @@ RSpec.describe Reek::Context::CodeContext do
     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
+      first_child.register_with_parent context
+      second_child.register_with_parent context
+
       result = []
       context.each do |ctx|
         result << ctx

data/spec/reek/context/ghost_context_spec.rb

@@ -0,0 +1,60 @@
+require_relative '../../spec_helper'
+require_lib 'reek/context/code_context'
+require_lib 'reek/context/ghost_context'
+
+RSpec.describe Reek::Context::GhostContext do
+  let(:exp) { double('exp') }
+  let(:parent) { Reek::Context::CodeContext.new(nil, exp) }
+
+  describe '#register_with_parent' do
+    it 'does not append itself to its parent' do
+      ghost = described_class.new(parent, nil)
+      ghost.register_with_parent(parent)
+      expect(parent.children).not_to include ghost
+    end
+  end
+
+  describe '#append_child_context' do
+    let(:ghost) { described_class.new(parent, nil) }
+
+    before do
+      ghost.register_with_parent(parent)
+    end
+
+    it 'appends the child to the grandparent context' do
+      child = Reek::Context::CodeContext.new(ghost, sexp(:foo))
+      child.register_with_parent(ghost)
+
+      expect(parent.children).to include child
+    end
+
+    it "sets the child's parent to the grandparent context" do
+      child = Reek::Context::CodeContext.new(ghost, sexp(:foo))
+      child.register_with_parent(ghost)
+
+      expect(child.parent).to eq parent
+    end
+
+    it 'appends the child to the list of children' do
+      child = Reek::Context::CodeContext.new(ghost, sexp(:foo))
+      child.register_with_parent(ghost)
+
+      expect(ghost.children).to include child
+    end
+
+    context 'if the grandparent is also a ghost' do
+      let(:child_ghost) { described_class.new(ghost, nil) }
+
+      before do
+        child_ghost.register_with_parent(ghost)
+      end
+
+      it 'sets the childs parent to its remote ancestor' do
+        child = Reek::Context::CodeContext.new(child_ghost, sexp(:foo))
+        child.register_with_parent(child_ghost)
+
+        expect(child.parent).to eq parent
+      end
+    end
+  end
+end

data/spec/reek/context/module_context_spec.rb

@@ -18,9 +18,7 @@ RSpec.describe Reek::Context::ModuleContext do
         # module for test
         class Jim; end; end').not_to reek
   end
-end
 
-RSpec.describe Reek::Context::ModuleContext do
   it 'should recognise global constant' do
     expect('
       # module for test
@@ -28,4 +26,26 @@ RSpec.describe Reek::Context::ModuleContext do
         # module for test
         class Inside; end; end').not_to reek
   end
+
+  describe '#track_visibility' do
+    let(:context) { Reek::Context::ModuleContext.new(nil, double('exp1')) }
+    let(:first_child) { Reek::Context::MethodContext.new(context, double('exp2', type: :def, name: :foo)) }
+    let(:second_child) { Reek::Context::MethodContext.new(context, double('exp3', type: :def)) }
+
+    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
 end

data/spec/reek/context_builder_spec.rb

@@ -27,7 +27,7 @@ RSpec.describe Reek::ContextBuilder do
         end
 
         it 'holds a reference to the parent context' do
-          expect(module_context.send(:context)).to eq(context_tree)
+          expect(module_context.parent).to eq(context_tree)
         end
 
         describe 'the module node' do
@@ -39,7 +39,7 @@ RSpec.describe Reek::ContextBuilder do
           end
 
           it 'holds a reference to the parent context' do
-            expect(method_context.send(:context)).to eq(module_context)
+            expect(method_context.parent).to eq(module_context)
           end
         end
       end
@@ -218,4 +218,227 @@ RSpec.describe Reek::ContextBuilder do
       end
     end
   end
+
+  describe 'visibility tracking' do
+    def context_tree_for(code)
+      described_class.new(syntax_tree(code)).context_tree
+    end
+
+    it 'does not mark class methods with instance visibility' do
+      code = <<-EOS
+        class Foo
+          private
+          def bar
+          end
+          def self.baz
+          end
+        end
+      EOS
+
+      root = context_tree_for(code)
+      module_context = root.children.first
+      method_contexts = module_context.children
+      expect(method_contexts[0].visibility).to eq :private
+      expect(method_contexts[1].visibility).to eq :public
+    end
+
+    it 'only marks existing instance methods using later instance method modifiers' do
+      code = <<-EOS
+        class Foo
+          def bar
+          end
+
+          def baz
+          end
+
+          def self.bar
+          end
+
+          class << self
+            def bar
+            end
+          end
+
+          private :bar, :baz
+        end
+      EOS
+
+      root = context_tree_for(code)
+      module_context = root.children.first
+      method_contexts = module_context.children
+      expect(method_contexts[0].visibility).to eq :private
+      expect(method_contexts[1].visibility).to eq :private
+      expect(method_contexts[2].visibility).to eq :public
+      expect(method_contexts[3].visibility).to eq :public
+    end
+
+    it 'only marks existing instance attributes using later instance method modifiers' do
+      code = <<-EOS
+        class Foo
+          attr_writer :bar
+
+          class << self
+            attr_writer :bar
+          end
+
+          private :bar
+        end
+      EOS
+
+      root = context_tree_for(code)
+      module_context = root.children.first
+      method_contexts = module_context.children
+      expect(method_contexts[0].visibility).to eq :private
+      expect(method_contexts[1].visibility).to eq :public
+    end
+
+    it 'marks class method visibility using private_class_method' do
+      code = <<-EOS
+        class Foo
+          def self.baz
+          end
+
+          private_class_method :baz
+        end
+      EOS
+
+      root = context_tree_for(code)
+      module_context = root.children.first
+      method_contexts = module_context.children
+      expect(method_contexts[0].visibility).to eq :private
+    end
+
+    it 'marks class method visibility using public_class_method' do
+      code = <<-EOS
+        class Foo
+          class << self
+            private
+
+            def baz
+            end
+          end
+
+          public_class_method :baz
+        end
+      EOS
+
+      root = context_tree_for(code)
+      module_context = root.children.first
+      method_contexts = module_context.children
+      expect(method_contexts[0].visibility).to eq :public
+    end
+
+    it 'correctly skips nested modules' do
+      code = <<-EOS
+        class Foo
+          class Bar
+            def baz
+            end
+          end
+
+          def baz
+          end
+
+          def self.bar
+          end
+
+          private :baz
+          private_class_method :bar
+        end
+      EOS
+
+      root = context_tree_for(code)
+      foo_context = root.children.first
+      bar_context = foo_context.children.first
+      nested_baz_context = bar_context.children.first
+      expect(nested_baz_context.visibility).to eq :public
+    end
+  end
+
+  describe '#context_tree' do
+    it 'creates the proper context for all kinds of singleton methods' do
+      src = <<-EOS
+        class Car
+          def self.start; end
+
+          class << self
+            def drive; end
+          end
+        end
+      EOS
+
+      syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
+      context_tree = Reek::ContextBuilder.new(syntax_tree).context_tree
+
+      class_node = context_tree.children.first
+      start_method = class_node.children.first
+      drive_method = class_node.children.last
+
+      expect(start_method).to be_instance_of Reek::Context::SingletonMethodContext
+      expect(drive_method).to be_instance_of Reek::Context::SingletonMethodContext
+    end
+
+    it 'returns something sensible for nested metaclasses' do
+      src = <<-EOS
+        class Foo
+          class << self
+            class << self
+              def bar; end
+            end
+          end
+        end
+      EOS
+
+      syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
+      context_tree = Reek::ContextBuilder.new(syntax_tree).context_tree
+
+      class_context = context_tree.children.first
+      method_context = class_context.children.first
+
+      expect(method_context).to be_instance_of Reek::Context::SingletonMethodContext
+      expect(method_context.parent).to eq class_context
+    end
+
+    it 'returns something sensible for nested method definitions' do
+      src = <<-EOS
+        class Foo
+          def foo
+            def bar
+            end
+          end
+        end
+      EOS
+
+      syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
+      context_tree = Reek::ContextBuilder.new(syntax_tree).context_tree
+
+      class_context = context_tree.children.first
+      foo_context = class_context.children.first
+
+      bar_context = foo_context.children.first
+      expect(bar_context).to be_instance_of Reek::Context::MethodContext
+      expect(bar_context.parent).to eq foo_context
+    end
+
+    it 'returns something sensible for method definitions nested in singleton methods' do
+      src = <<-EOS
+        class Foo
+          def self.foo
+            def bar
+            end
+          end
+        end
+      EOS
+
+      syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
+      context_tree = Reek::ContextBuilder.new(syntax_tree).context_tree
+
+      class_context = context_tree.children.first
+      foo_context = class_context.children.first
+
+      bar_context = foo_context.children.first
+      expect(bar_context).to be_instance_of Reek::Context::SingletonMethodContext
+      expect(bar_context.parent).to eq foo_context
+    end
+  end
 end

data/spec/reek/examiner_spec.rb

@@ -63,7 +63,7 @@ RSpec.describe Reek::Examiner do
 
       smell = examiner.smells.first
       expect(smell).to be_a(Reek::Smells::SmellWarning)
-      expect(smell.message).to eq('calls bar.call_me 2 times')
+      expect(smell.message).to eq('calls bar.call_me() 2 times')
     end
   end
 end

data/spec/reek/smells/attribute_spec.rb

@@ -137,5 +137,40 @@ RSpec.describe Reek::Smells::Attribute do
       '
       expect(src).to reek_of(:Attribute)
     end
+
+    it 'records attr_writer defining a class attribute' do
+      src = <<-EOS
+        class Klass
+          class << self
+            attr_writer :my_attr
+          end
+        end
+      EOS
+      expect(src).to reek_of(:Attribute, name: 'my_attr')
+    end
+
+    it 'does not record private class attributes' do
+      src = <<-EOS
+        class Klass
+          class << self
+            private
+            attr_writer :my_attr
+          end
+        end
+      EOS
+      expect(src).not_to reek_of(:Attribute, name: 'my_attr')
+    end
+
+    it 'tracks visibility in metaclasses separately' do
+      src = <<-EOS
+        class Klass
+          private
+          class << self
+            attr_writer :my_attr
+          end
+        end
+      EOS
+      expect(src).to reek_of(:Attribute, name: 'my_attr')
+    end
   end
 end