reek 4.4.0 → 4.4.1

data/spec/reek/code_comment_spec.rb

@@ -30,6 +30,14 @@ RSpec.describe Reek::CodeComment do
 
   context 'comment config' do
     it 'parses hashed options' do
+      comment = '# :reek:Duplication { enabled: false }'
+      config = described_class.new(comment).config
+      expect(config).to include('Duplication')
+      expect(config['Duplication']).to include('enabled')
+      expect(config['Duplication']['enabled']).to be_falsey
+    end
+
+    it "supports hashed options with the legacy separator ':' after the smell detector" do
       comment = '# :reek:Duplication: { enabled: false }'
       config = described_class.new(comment).config
       expect(config).to include('Duplication')
@@ -39,8 +47,8 @@ RSpec.describe Reek::CodeComment do
 
     it 'parses multiple hashed options' do
       config = described_class.new('
-        # :reek:Duplication: { enabled: false }
-        # :reek:NestedIterators: { enabled: true }
+        # :reek:Duplication { enabled: false }
+        # :reek:NestedIterators { enabled: true }
       ').config
       expect(config).to include('Duplication', 'NestedIterators')
       expect(config['Duplication']).to include('enabled')
@@ -51,7 +59,7 @@ RSpec.describe Reek::CodeComment do
 
     it 'parses multiple hashed options on the same line' do
       config = described_class.new('
-        #:reek:Duplication: { enabled: false } and :reek:NestedIterators: { enabled: true }
+        #:reek:Duplication { enabled: false } and :reek:NestedIterators { enabled: true }
       ').config
       expect(config).to include('Duplication', 'NestedIterators')
       expect(config['Duplication']).to include('enabled')
@@ -85,8 +93,8 @@ RSpec.describe Reek::CodeComment do
     it 'removes the configuration options from the comment' do
       subject = described_class.new('
         # Actual
-        # :reek:Duplication: { enabled: false }
-        # :reek:NestedIterators: { enabled: true }
+        # :reek:Duplication { enabled: false }
+        # :reek:NestedIterators { enabled: true }
         # comment
       ')
       expect(subject.send(:sanitized_comment)).to eq('Actual comment')

data/spec/reek/examiner_spec.rb

@@ -67,7 +67,7 @@ RSpec.describe Reek::Examiner do
       end
 
       it 'has been run on the given source' do
-        expect(examiner.description).to eq('string')
+        expect(examiner.origin).to eq('string')
       end
 
       it 'has the right smells' do
@@ -90,7 +90,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
 
     context 'source is empty' do

data/spec/reek/smells/attribute_spec.rb

@@ -1,187 +1,200 @@
 require_relative '../../spec_helper'
 require_lib 'reek/smells/attribute'
-require_relative 'smell_detector_shared'
 
 RSpec.describe Reek::Smells::Attribute do
-  let(:detector) { build(:smell_detector, smell_type: :Attribute) }
-
-  it_should_behave_like 'SmellDetector'
-
   it 'reports the right values' do
     src = <<-EOS
-      class Klass
-        attr_writer :my_attr
+      class Alfa
+        attr_writer :bravo
       end
     EOS
+
     expect(src).to reek_of(:Attribute,
                            lines: [2],
+                           context: 'Alfa#bravo',
                            message: 'is a writable attribute')
   end
 
-  context 'with no attributes' do
-    it 'records nothing' do
-      src = <<-EOS
-        class Klass
-        end
-      EOS
-      expect(src).to_not reek_of(:Attribute)
-    end
+  it 'does count all occurences' do
+    src = <<-EOS
+      class Alfa
+        attr_writer :bravo
+        attr_writer :charlie
+      end
+    EOS
+
+    expect(src).to reek_of(:Attribute,
+                           lines:   [2],
+                           context: 'Alfa#bravo')
+    expect(src).to reek_of(:Attribute,
+                           lines:   [3],
+                           context: 'Alfa#charlie')
+  end
+
+  it 'records nothing with no attributes' do
+    src = <<-EOS
+      class Alfa
+      end
+    EOS
+
+    expect(src).to_not reek_of(:Attribute)
   end
 
   context 'with attributes' do
     it 'records nothing for attribute readers' do
       src = <<-EOS
-        class Klass
-          attr :my_attr
-          attr_reader :my_attr2
+        class Alfa
+          attr :bravo
+          attr_reader :charlie
         end
       EOS
+
       expect(src).to_not reek_of(:Attribute)
     end
 
     it 'records writer attribute' do
       src = <<-EOS
-        class Klass
-          attr_writer :my_attr
+        class Alfa
+          attr_writer :bravo
         end
       EOS
-      expect(src).to reek_of(:Attribute, context: 'Klass#my_attr')
+
+      expect(src).to reek_of(:Attribute, context: 'Alfa#bravo')
     end
 
     it 'does not record writer attribute if suppressed with a preceding code comment' do
       src = <<-EOS
-        class Klass
+        class Alfa
           # :reek:Attribute
-          attr_writer :my_attr
+          attr_writer :bravo
         end
       EOS
+
       expect(src).not_to reek_of(:Attribute)
     end
 
     it 'records attr_writer attribute in a module' do
       src = <<-EOS
         module Mod
-          attr_writer :my_attr
+          attr_writer :bravo
         end
       EOS
-      expect(src).to reek_of(:Attribute, context: 'Mod#my_attr')
+
+      expect(src).to reek_of(:Attribute)
     end
 
     it 'records accessor attribute' do
       src = <<-EOS
-        class Klass
-          attr_accessor :my_attr
+        class Alfa
+          attr_accessor :bravo
         end
       EOS
-      expect(src).to reek_of(:Attribute, context: 'Klass#my_attr')
+
+      expect(src).to reek_of(:Attribute)
     end
 
     it 'records attr defining a writer' do
       src = <<-EOS
-        class Klass
-          attr :my_attr, true
+        class Alfa
+          attr :bravo, true
         end
       EOS
-      expect(src).to reek_of(:Attribute, context: 'Klass#my_attr')
+
+      expect(src).to reek_of(:Attribute)
     end
 
     it "doesn't record protected attributes" do
-      src = '
-        class Klass
+      src = <<-EOS
+        class Alfa
           protected
-          attr_writer :attr1
-          attr_accessor :attr2
-          attr :attr3
-          attr :attr4, true
-          attr_reader :attr5
+          attr_writer :alfa
+          attr_accessor :bravo
+          attr :charlie
+          attr :delta, true
+          attr_reader :echo
         end
-      '
+      EOS
+
       expect(src).to_not reek_of(:Attribute)
     end
 
     it "doesn't record private attributes" do
-      src = '
-        class Klass
+      src = <<-EOS
+        class Alfa
           private
-          attr_writer :attr1
-          attr_accessor :attr2
-          attr :attr3
-          attr :attr4, true
-          attr_reader :attr5
+          attr_writer :alfa
+          attr_accessor :bravo
+          attr :charlie
+          attr :delta, true
+          attr_reader :echo
         end
-      '
+      EOS
+
       expect(src).to_not reek_of(:Attribute)
     end
 
     it 'records attr_writer defined in public section' do
       src = <<-EOS
-        class Klass
+        class Alfa
           private
           public
-          attr_writer :my_attr
+          attr_writer :bravo
         end
       EOS
-      expect(src).to reek_of(:Attribute, context: 'Klass#my_attr')
+
+      expect(src).to reek_of(:Attribute)
     end
 
     it 'records attr_writer after switching visbility to public' do
       src = <<-EOS
-        class Klass
+        class Alfa
           private
-          attr_writer :my_attr
-          public :my_attr
+          attr_writer :bravo
+          public :bravo
         end
       EOS
-      expect(src).to reek_of(:Attribute, context: 'Klass#my_attr')
+
+      expect(src).to reek_of(:Attribute)
     end
 
     it 'resets visibility in new contexts' do
-      src = '
-        class Klass
+      src = <<-EOS
+        class Alfa
           private
-          attr_writer :attr1
+          attr_writer :bravo
         end
 
-        class OtherKlass
-          attr_writer :attr1
+        class Charlie
+          attr_writer :delta
         end
-      '
-      expect(src).to reek_of(:Attribute, context: 'OtherKlass#attr1')
+      EOS
+
+      expect(src).to reek_of(:Attribute, context: 'Charlie#delta')
     end
 
     it 'records attr_writer defining a class attribute' do
       src = <<-EOS
-        class Klass
+        class Alfa
           class << self
-            attr_writer :my_attr
+            attr_writer :bravo
           end
         end
       EOS
-      expect(src).to reek_of(:Attribute, context: 'Klass#my_attr')
+
+      expect(src).to reek_of(:Attribute)
     end
 
     it 'does not record private class attributes' do
       src = <<-EOS
-        class Klass
+        class Alfa
           class << self
             private
-            attr_writer :my_attr
+            attr_writer :bravo
           end
         end
       EOS
-      expect(src).not_to reek_of(:Attribute)
-    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, context: 'Klass#my_attr')
+      expect(src).not_to reek_of(:Attribute)
     end
   end
 end

data/spec/reek/smells/boolean_parameter_spec.rb

@@ -1,91 +1,99 @@
 require_relative '../../spec_helper'
 require_lib 'reek/smells/boolean_parameter'
-require_relative 'smell_detector_shared'
 
 RSpec.describe Reek::Smells::BooleanParameter do
-  context 'parameter defaulted with boolean' do
-    context 'in a method' do
-      it 'reports a parameter defaulted to true' do
-        src = 'def cc(arga = true); arga; end'
-        expect(src).to reek_of(:BooleanParameter, parameter: 'arga')
+  it 'reports the right values' do
+    src = <<-EOS
+      def alfa(bravo = true)
       end
+    EOS
+
+    expect(src).to reek_of(:BooleanParameter,
+                           lines: [1],
+                           context: 'alfa',
+                           message: "has boolean parameter 'bravo'",
+                           source: 'string',
+                           parameter: 'bravo')
+  end
 
-      it 'reports a parameter defaulted to false' do
-        src = 'def cc(arga = false) end'
-        expect(src).to reek_of(:BooleanParameter, parameter: 'arga')
+  it 'does count all occurences' do
+    src = <<-EOS
+      def alfa(bravo = true, charlie = true)
       end
+    EOS
+
+    expect(src).to reek_of(:BooleanParameter,
+                           lines:   [1],
+                           context: 'alfa',
+                           parameter: 'bravo')
+    expect(src).to reek_of(:BooleanParameter,
+                           lines:   [1],
+                           context: 'alfa',
+                           parameter: 'charlie')
+  end
 
-      it 'reports two parameters defaulted to booleans' do
-        src = 'def cc(nowt, arga = true, argb = false, &blk) end'
-        expect(src).to reek_of(:BooleanParameter, parameter: 'arga')
-        expect(src).to reek_of(:BooleanParameter, parameter: 'argb')
-      end
+  context 'in a method' do
+    it 'reports a parameter defaulted to false' do
+      src = 'def alfa(bravo = false) end'
+      expect(src).to reek_of(:BooleanParameter)
+    end
 
-      it 'reports keyword parameters defaulted to booleans' do
-        src = 'def cc(arga: true, argb: false) end'
-        expect(src).to reek_of(:BooleanParameter, parameter: 'arga')
-        expect(src).to reek_of(:BooleanParameter, parameter: 'argb')
-      end
+    it 'reports two parameters defaulted to booleans in a mixed parameter list' do
+      src = 'def alfa(bravo, charlie = true, delta = false, &echo) end'
 
-      it 'does not report regular parameters' do
-        src = 'def cc(a, b) end'
-        expect(src).not_to reek_of(:BooleanParameter)
-      end
+      expect(src).to reek_of(:BooleanParameter, parameter: 'charlie')
+      expect(src).to reek_of(:BooleanParameter, parameter: 'delta')
 
-      it 'does not report array decomposition parameters' do
-        src = 'def cc((a, b)) end'
-        expect(src).not_to reek_of(:BooleanParameter)
-      end
+      expect(src).not_to reek_of(:BooleanParameter, parameter: 'bravo')
+      expect(src).not_to reek_of(:BooleanParameter, parameter: 'echo')
+    end
 
-      it 'does not report keyword parameters with no default' do
-        src = 'def cc(a:, b:) end'
-        expect(src).not_to reek_of(:BooleanParameter)
-      end
+    it 'reports keyword parameters defaulted to booleans' do
+      src = 'def alfa(bravo: true, charlie: false) end'
+      expect(src).to reek_of(:BooleanParameter, parameter: 'bravo')
+      expect(src).to reek_of(:BooleanParameter, parameter: 'charlie')
+    end
 
-      it 'does not report keyword parameters with non-boolean default' do
-        src = 'def cc(a: 42, b: "32") end'
-        expect(src).not_to reek_of(:BooleanParameter)
-      end
+    it 'does not report regular parameters' do
+      src = 'def alfa(bravo, charlie) end'
+      expect(src).not_to reek_of(:BooleanParameter)
     end
 
-    context 'in a singleton method' do
-      it 'reports a parameter defaulted to true' do
-        src = 'def self.cc(arga = true) end'
-        expect(src).to reek_of(:BooleanParameter, parameter: 'arga')
-      end
+    it 'does not report array decomposition parameters' do
+      src = 'def alfa((bravo, charlie)) end'
+      expect(src).not_to reek_of(:BooleanParameter)
+    end
 
-      it 'reports a parameter defaulted to false' do
-        src = 'def fred.cc(arga = false) end'
-        expect(src).to reek_of(:BooleanParameter, parameter: 'arga')
-      end
+    it 'does not report keyword parameters with no default' do
+      src = 'def alfa(bravo:, charlie:) end'
+      expect(src).not_to reek_of(:BooleanParameter)
+    end
 
-      it 'reports two parameters defaulted to booleans' do
-        src = 'def Module.cc(nowt, arga = true, argb = false, &blk) end'
-        expect(src).to reek_of(:BooleanParameter, parameter: 'arga')
-        expect(src).to reek_of(:BooleanParameter, parameter: 'argb')
-      end
+    it 'does not report keyword parameters with non-boolean default' do
+      src = 'def alfa(bravo: 42, charlie: "32") end'
+      expect(src).not_to reek_of(:BooleanParameter)
     end
   end
 
-  context 'when a smell is reported' do
-    let(:detector) { build(:smell_detector, smell_type: :BooleanParameter) }
+  context 'in a singleton method' do
+    it 'reports a parameter defaulted to true' do
+      src = 'def self.alfa(bravo = true) end'
+      expect(src).to reek_of(:BooleanParameter)
+    end
 
-    it_should_behave_like 'SmellDetector'
+    it 'reports a parameter defaulted to false' do
+      src = 'def self.alfa(bravo = false) end'
+      expect(src).to reek_of(:BooleanParameter)
+    end
 
-    context 'when a smell is reported' do
-      let(:warning) do
-        src = 'def cc(arga = true) end'
-        ctx = Reek::Context::MethodContext.new(nil, Reek::Source::SourceCode.from(src).syntax_tree)
-        detector.sniff(ctx).first
-      end
+    it 'reports two parameters defaulted to booleans' do
+      src = 'def self.alfa(bravo, charlie = true, delta = false, &echo) end'
 
-      it_should_behave_like 'common fields set correctly'
+      expect(src).to reek_of(:BooleanParameter, parameter: 'charlie')
+      expect(src).to reek_of(:BooleanParameter, parameter: 'delta')
 
-      it 'reports the correct values' do
-        expect(warning.parameters[:parameter]).to eq('arga')
-        expect(warning.lines).to eq([1])
-        expect(warning.message).to eq("has boolean parameter 'arga'")
-      end
+      expect(src).not_to reek_of(:BooleanParameter, parameter: 'bravo')
+      expect(src).not_to reek_of(:BooleanParameter, parameter: 'echo')
     end
   end
 end