reek 5.4.1 → 6.0.2

data/spec/reek/ast/sexp_extensions_spec.rb

@@ -443,73 +443,55 @@ end
 
 RSpec.describe Reek::AST::SexpExtensions::CasgnNode do
   describe '#defines_module?' do
-    context 'with single assignment' do
-      it 'does not define a module' do
-        exp = sexp(:casgn, nil, :Foo)
-        expect(exp).not_to be_defines_module
-      end
+    it 'is false for single assignment' do
+      exp = sexp(:casgn, nil, :Foo)
+      expect(exp).not_to be_defines_module
     end
 
-    context 'with implicit receiver to new' do
-      it 'does not define a module' do
-        exp = sexp(:casgn, nil, :Foo, sexp(:send, nil, :new))
-        expect(exp).not_to be_defines_module
-      end
+    it 'is false for implicit receiver to new' do
+      exp = sexp(:casgn, nil, :Foo, sexp(:send, nil, :new))
+      expect(exp).not_to be_defines_module
     end
 
-    context 'with implicit receiver to new' do
-      it 'does not define a module' do
-        exp = Reek::Source::SourceCode.from('Foo = Class.new(Bar)').syntax_tree
-
-        expect(exp).to be_defines_module
-      end
+    it 'is true for explicit receiver to new' do
+      exp = Reek::Source::SourceCode.from('Foo = Class.new(Bar)').syntax_tree
+      expect(exp).to be_defines_module
     end
 
-    context 'when assigning a lambda to a constant' do
-      it 'does not define a module' do
-        exp = Reek::Source::SourceCode.from('C = ->{}').syntax_tree
-
-        expect(exp).not_to be_defines_module
-      end
+    it 'is false for assigning a lambda to a constant' do
+      exp = Reek::Source::SourceCode.from('C = ->{}').syntax_tree
+      expect(exp).not_to be_defines_module
     end
 
-    context 'when assigning a string to a constant' do
-      it 'does not define a module' do
-        exp = Reek::Source::SourceCode.from('C = "hello"').syntax_tree
-
-        expect(exp).not_to be_defines_module
-      end
+    it 'is false for assigning a string to a constant' do
+      exp = Reek::Source::SourceCode.from('C = "hello"').syntax_tree
+      expect(exp).not_to be_defines_module
     end
   end
 
   describe '#superclass' do
     it 'returns the superclass from the class definition' do
       exp = Reek::Source::SourceCode.from('Foo = Class.new(Bar)').syntax_tree
-
       expect(exp.superclass).to eq sexp(:const, nil, :Bar)
     end
 
     it 'returns nil in case of no class definition' do
       exp = Reek::Source::SourceCode.from('Foo = 23').syntax_tree
-
       expect(exp.superclass).to be_nil
     end
 
     it 'returns nil in case of no superclass' do
       exp = Reek::Source::SourceCode.from('Foo = Class.new').syntax_tree
-
       expect(exp.superclass).to be_nil
     end
 
     it 'returns nothing for a class definition using Struct.new' do
       exp = Reek::Source::SourceCode.from('Foo = Struct.new("Bar")').syntax_tree
-
       expect(exp.superclass).to be_nil
     end
 
     it 'returns nothing for a constant assigned with a bare method call' do
       exp = Reek::Source::SourceCode.from('Foo = foo("Bar")').syntax_tree
-
       expect(exp.superclass).to be_nil
     end
   end

data/spec/reek/code_comment_spec.rb

@@ -3,7 +3,7 @@ require_lib 'reek/code_comment'
 
 RSpec.describe Reek::CodeComment do
   context 'with an empty comment' do
-    let(:comment) { build(:code_comment, comment: '') }
+    let(:comment) { build_code_comment(comment: '') }
 
     it 'is not descriptive' do
       expect(comment).not_to be_descriptive
@@ -16,77 +16,63 @@ RSpec.describe Reek::CodeComment do
 
   describe '#descriptive' do
     it 'rejects an empty comment' do
-      comment = build(:code_comment, comment: '#')
+      comment = build_code_comment(comment: '#')
       expect(comment).not_to be_descriptive
     end
 
     it 'rejects a 1-word comment' do
-      comment = build(:code_comment, comment: "# alpha\n#  ")
+      comment = build_code_comment(comment: "# alpha\n#  ")
       expect(comment).not_to be_descriptive
     end
 
     it 'accepts a 2-word comment' do
-      comment = build(:code_comment, comment: '# alpha bravo  ')
+      comment = build_code_comment(comment: '# alpha bravo  ')
       expect(comment).to be_descriptive
     end
 
     it 'accepts a multi-word comment' do
-      comment = build(:code_comment, comment: "# alpha bravo \n# charlie \n   # delta ")
+      comment = build_code_comment(comment: "# alpha bravo \n# charlie \n   # delta ")
       expect(comment).to be_descriptive
     end
   end
 
   describe 'good comment config' do
     it 'parses hashed options' do
-      comment = '# :reek:DuplicateMethodCall { enabled: false }'
-      config = build(:code_comment,
-                     comment: comment).config
+      comment = '# :reek:DuplicateMethodCall { max_calls: 3 }'
+      config = build_code_comment(comment: comment).config
 
       expect(config).to include('DuplicateMethodCall')
-      expect(config['DuplicateMethodCall']).to include('enabled')
-      expect(config['DuplicateMethodCall']['enabled']).to be_falsey
-    end
-
-    it "supports hashed options with the legacy separator ':' after the smell detector" do
-      comment = '# :reek:DuplicateMethodCall: { enabled: false }'
-      config = build(:code_comment,
-                     comment: comment).config
-
-      expect(config).to include('DuplicateMethodCall')
-      expect(config['DuplicateMethodCall']).to include('enabled')
-      expect(config['DuplicateMethodCall']['enabled']).to be_falsey
+      expect(config['DuplicateMethodCall']).to have_key 'max_calls'
+      expect(config['DuplicateMethodCall']['max_calls']).to eq 3
     end
 
     it 'parses multiple hashed options' do
       comment = <<-RUBY
-        # :reek:DuplicateMethodCall { enabled: false }
+        # :reek:DuplicateMethodCall { max_calls: 3 }
         # :reek:NestedIterators { enabled: true }
       RUBY
-      config = build(:code_comment, comment: comment).config
+      config = build_code_comment(comment: comment).config
 
       expect(config).to include('DuplicateMethodCall', 'NestedIterators')
-      expect(config['DuplicateMethodCall']).to include('enabled')
-      expect(config['DuplicateMethodCall']['enabled']).to be_falsey
-      expect(config['NestedIterators']).to include('enabled')
+      expect(config['DuplicateMethodCall']['max_calls']).to eq 3
       expect(config['NestedIterators']['enabled']).to be_truthy
     end
 
     it 'parses multiple hashed options on the same line' do
       comment = <<-RUBY
-        #:reek:DuplicateMethodCall { enabled: false } and :reek:NestedIterators { enabled: true }
+        #:reek:DuplicateMethodCall { max_calls: 3 } and :reek:NestedIterators { enabled: true }
       RUBY
-      config = build(:code_comment, comment: comment).config
+      config = build_code_comment(comment: comment).config
 
       expect(config).to include('DuplicateMethodCall', 'NestedIterators')
-      expect(config['DuplicateMethodCall']).to include('enabled')
-      expect(config['DuplicateMethodCall']['enabled']).to be_falsey
+      expect(config['DuplicateMethodCall']['max_calls']).to eq 3
       expect(config['NestedIterators']).to include('enabled')
       expect(config['NestedIterators']['enabled']).to be_truthy
     end
 
     it 'parses multiple unhashed options on the same line' do
       comment = '# :reek:DuplicateMethodCall and :reek:NestedIterators'
-      config = build(:code_comment, comment: comment).config
+      config = build_code_comment(comment: comment).config
 
       expect(config).to include('DuplicateMethodCall', 'NestedIterators')
       expect(config['DuplicateMethodCall']).to include('enabled')
@@ -97,27 +83,33 @@ RSpec.describe Reek::CodeComment do
 
     it 'disables the smell if no options are specifed' do
       comment = '# :reek:DuplicateMethodCall'
-      config = build(:code_comment, comment: comment).config
+      config = build_code_comment(comment: comment).config
 
       expect(config).to include('DuplicateMethodCall')
       expect(config['DuplicateMethodCall']).to include('enabled')
       expect(config['DuplicateMethodCall']['enabled']).to be_falsey
     end
 
+    it 'does not disable the smell if options are specifed' do
+      comment = '# :reek:DuplicateMethodCall { max_calls: 3 }'
+      config = build_code_comment(comment: comment).config
+
+      expect(config['DuplicateMethodCall']).not_to include('enabled')
+    end
+
     it 'ignores smells after a space' do
-      config = build(:code_comment,
-                     comment: '# :reek: DuplicateMethodCall').config
+      config = build_code_comment(comment: '# :reek: DuplicateMethodCall').config
       expect(config).not_to include('DuplicateMethodCall')
     end
 
     it 'removes the configuration options from the comment' do
       original_comment = <<-RUBY
         # Actual
-        # :reek:DuplicateMethodCall { enabled: false }
+        # :reek:DuplicateMethodCall { max_calls: 3 }
         # :reek:NestedIterators { enabled: true }
         # comment
       RUBY
-      comment = build(:code_comment, comment: original_comment)
+      comment = build_code_comment(comment: original_comment)
 
       expect(comment.send(:sanitized_comment)).to eq('Actual comment')
     end
@@ -128,8 +120,7 @@ RSpec.describe Reek::CodeComment::CodeCommentValidator do
   context 'when the comment contains an unknown detector name' do
     it 'raises BadDetectorInCommentError' do
       expect do
-        build(:code_comment,
-              comment: '# :reek:DoesNotExist')
+        build_code_comment(comment: '# :reek:DoesNotExist')
       end.to raise_error(Reek::Errors::BadDetectorInCommentError)
     end
   end
@@ -138,18 +129,26 @@ RSpec.describe Reek::CodeComment::CodeCommentValidator do
     it 'raises GarbageDetectorConfigurationInCommentError' do
       expect do
         comment = '# :reek:UncommunicativeMethodName { thats: a: bad: config }'
-        build(:code_comment, comment: comment)
+        build_code_comment(comment: comment)
       end.to raise_error(Reek::Errors::GarbageDetectorConfigurationInCommentError)
     end
   end
 
+  context 'when the legacy comment format was used' do
+    it 'raises LegacyCommentSeparatorError' do
+      comment = '# :reek:DuplicateMethodCall:'
+      expect { build_code_comment(comment: comment) }.
+        to raise_error Reek::Errors::LegacyCommentSeparatorError
+    end
+  end
+
   describe 'validating configuration keys' do
     context 'when basic options are mispelled' do
       it 'raises BadDetectorConfigurationKeyInCommentError' do
         expect do
           # exclude -> exlude and enabled -> nabled
           comment = '# :reek:UncommunicativeMethodName { exlude: alfa, nabled: true }'
-          build(:code_comment, comment: comment)
+          build_code_comment(comment: comment)
         end.to raise_error(Reek::Errors::BadDetectorConfigurationKeyInCommentError)
       end
     end
@@ -158,7 +157,7 @@ RSpec.describe Reek::CodeComment::CodeCommentValidator do
       it 'does not raise' do
         expect do
           comment = '# :reek:UncommunicativeMethodName { exclude: alfa, enabled: true }'
-          build(:code_comment, comment: comment)
+          build_code_comment(comment: comment)
         end.not_to raise_error
       end
     end
@@ -168,7 +167,7 @@ RSpec.describe Reek::CodeComment::CodeCommentValidator do
         expect do
           # max_copies -> mx_copies and min_clump_size -> mn_clump_size
           comment = '# :reek:DataClump { mx_copies: 4, mn_clump_size: 3 }'
-          build(:code_comment, comment: comment)
+          build_code_comment(comment: comment)
         end.to raise_error(Reek::Errors::BadDetectorConfigurationKeyInCommentError)
       end
     end
@@ -177,7 +176,7 @@ RSpec.describe Reek::CodeComment::CodeCommentValidator do
       it 'does not raise' do
         expect do
           comment = '# :reek:DataClump { max_copies: 4, min_clump_size: 3 }'
-          build(:code_comment, comment: comment)
+          build_code_comment(comment: comment)
         end.not_to raise_error
       end
     end

data/spec/reek/configuration/directory_directives_spec.rb

@@ -89,6 +89,12 @@ RSpec.describe Reek::Configuration::DirectoryDirectives do
       expect(hit.to_s).to eq('bar/**/.spec/*')
     end
 
+    it 'returns the corresponding directory when source_base_dir is an absolute_path' do
+      source_base_dir = Pathname.new('foo/bar').expand_path
+      hit = directives.send :best_match_for, source_base_dir
+      expect(hit.to_s).to eq('foo/bar')
+    end
+
     it 'does not match an arbitrary directory when source_base_dir contains a character that could match the .' do
       source_base_dir = 'bar/something/aspec/direct'
       hit = directives.send :best_match_for, source_base_dir

data/spec/reek/context_builder_spec.rb

@@ -3,42 +3,126 @@ require_lib 'reek/context_builder'
 
 RSpec.describe Reek::ContextBuilder do
   describe '#context_tree' do
-    let(:walker) do
-      code = 'class Car; def drive; end; end'
-      described_class.new(syntax_tree(code))
+    context 'with some simple example code' do
+      let(:walker) do
+        code = 'class Car; def drive; end; end'
+        described_class.new(syntax_tree(code))
+      end
+      let(:context_tree) { walker.context_tree }
+      let(:module_context) { context_tree.children.first }
+      let(:method_context) { module_context.children.first }
+
+      describe 'the starting node' do
+        it 'is a root node' do
+          expect(context_tree.type).to eq(:root)
+          expect(context_tree).to be_a(Reek::Context::RootContext)
+        end
+
+        it 'has one module_context child' do
+          aggregate_failures do
+            expect(context_tree.children.count).to eq 1
+            expect(module_context).to be_a(Reek::Context::ModuleContext)
+          end
+        end
+      end
+
+      describe 'the module node' do
+        it 'has one method_context child' do
+          aggregate_failures do
+            expect(method_context).to be_a(Reek::Context::MethodContext)
+            expect(module_context.children.size).to eq(1)
+          end
+        end
+
+        it 'holds a reference to the parent context' do
+          expect(method_context.parent).to eq(module_context)
+        end
+      end
     end
-    let(:context_tree) { walker.context_tree }
-    let(:module_context) { context_tree.children.first }
-    let(:method_context) { module_context.children.first }
 
-    it 'starts with a root node' do
-      expect(context_tree.type).to eq(:root)
-      expect(context_tree).to be_a(Reek::Context::RootContext)
+    it 'creates the proper context for all kinds of singleton methods' do
+      src = <<-RUBY
+        class Car
+          def self.start; end
+
+          class << self
+            def drive; end
+          end
+        end
+      RUBY
+
+      syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
+      context_tree = described_class.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 'has one child' do
-      expect(context_tree.children.size).to eq(1)
+    it 'returns something sensible for nested metaclasses' do
+      src = <<-RUBY
+        class Foo
+          class << self
+            class << self
+              def bar; end
+            end
+          end
+        end
+      RUBY
+
+      syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
+      context_tree = described_class.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
 
-    describe 'the root node' do
-      it 'has one module_context' do
-        expect(module_context).to be_a(Reek::Context::ModuleContext)
-      end
+    it 'returns something sensible for nested method definitions' do
+      src = <<-RUBY
+        class Foo
+          def foo
+            def bar
+            end
+          end
+        end
+      RUBY
 
-      it 'holds a reference to the parent context' do
-        expect(module_context.parent).to eq(context_tree)
-      end
+      syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
+      context_tree = described_class.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
 
-    describe 'the module node' do
-      it 'has one method_context' do
-        expect(method_context).to be_a(Reek::Context::MethodContext)
-        expect(module_context.children.size).to eq(1)
-      end
+    it 'returns something sensible for method definitions nested in singleton methods' do
+      src = <<-RUBY
+        class Foo
+          def self.foo
+            def bar
+            end
+          end
+        end
+      RUBY
 
-      it 'holds a reference to the parent context' do
-        expect(method_context.parent).to eq(module_context)
-      end
+      syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
+      context_tree = described_class.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
 
@@ -370,91 +454,4 @@ RSpec.describe Reek::ContextBuilder do
       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 = <<-RUBY
-        class Car
-          def self.start; end
-
-          class << self
-            def drive; end
-          end
-        end
-      RUBY
-
-      syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
-      context_tree = described_class.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 = <<-RUBY
-        class Foo
-          class << self
-            class << self
-              def bar; end
-            end
-          end
-        end
-      RUBY
-
-      syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
-      context_tree = described_class.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 = <<-RUBY
-        class Foo
-          def foo
-            def bar
-            end
-          end
-        end
-      RUBY
-
-      syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
-      context_tree = described_class.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 = <<-RUBY
-        class Foo
-          def self.foo
-            def bar
-            end
-          end
-        end
-      RUBY
-
-      syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
-      context_tree = described_class.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