reek 1.6.6 → 2.0.0

data/spec/reek/cli/yaml_report_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'reek/examiner'
+require 'reek/cli/report/report'
+require 'reek/cli/report/formatter'
+
+include Reek
+include Reek::Cli
+
+describe Report::YamlReport do
+  let(:instance) { Report::YamlReport.new }
+
+  context 'empty source' do
+    let(:examiner) { Examiner.new('') }
+
+    before do
+      instance.add_examiner examiner
+    end
+
+    it 'prints empty yaml' do
+      expect { instance.show }.to output(/^--- \[\]\n.*$/).to_stdout
+    end
+  end
+end

data/spec/reek/configuration/configuration_file_finder_spec.rb

@@ -8,19 +8,18 @@ describe ConfigurationFileFinder do
   describe '.find' do
     let(:sample_config_path) { Pathname.new('spec/samples/simple_configuration.reek') }
     let(:config_path_same_level) { Pathname.new('spec/samples/simple_configuration.reek') }
-    let(:options) { double(config_file: sample_config_path) }
-    let(:application_with_options) { double(options: options) }
-    let(:application_without_options) { nil }
+    let(:options_with_config_file) { double(config_file: sample_config_path) }
+    let(:options_without_config_file) { double(config_file: nil) }
 
     it 'should return the config file we passed as cli option if given' do
-      expect(ConfigurationFileFinder.find(application_with_options)).to eq(sample_config_path)
+      expect(ConfigurationFileFinder.find(options_with_config_file)).to eq(sample_config_path)
     end
 
     it 'should return the first configuration file it can find in the current directory' do
       allow(ConfigurationFileFinder).to receive(:detect_or_traverse_up).
         and_return config_path_same_level
 
-      expect(ConfigurationFileFinder.find(application_without_options)).
+      expect(ConfigurationFileFinder.find(options_without_config_file)).
         to eq(config_path_same_level)
     end
 
@@ -29,7 +28,7 @@ describe ConfigurationFileFinder do
       allow(ConfigurationFileFinder).to receive(:configuration_in_file_system).and_return nil
       expect(ConfigurationFileFinder).to receive(:configuration_in_home_directory).once
 
-      ConfigurationFileFinder.find application_without_options
+      ConfigurationFileFinder.find nil
     end
   end
 end

data/spec/reek/core/module_context_spec.rb

@@ -10,7 +10,7 @@ describe ModuleContext do
       module Fred
         def simple(x) x + 1; end
       end
-    ').to reek_of(:UncommunicativeParameterName, /x/, /simple/)
+    ').to reek_of(:UncommunicativeParameterName,  name: 'x')
   end
 
   it 'should not report module with empty class' do

data/spec/reek/core/smell_repository_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+require 'reek/core/smell_repository'
+
+include Reek::Core
+
+describe SmellRepository do
+  describe '.smell_types' do
+    it 'should include existing smell_types' do
+      expect(SmellRepository.smell_types).to include(Reek::Smells::IrresponsibleModule)
+      expect(SmellRepository.smell_types).to include(Reek::Smells::TooManyStatements)
+    end
+
+    it 'should exclude certain smell_types' do
+      expect(SmellRepository.smell_types).to_not include(Reek::Smells::SmellDetector)
+    end
+  end
+end

data/spec/reek/smell_warning_spec.rb

@@ -89,7 +89,7 @@ describe SmellWarning do
     end
   end
 
-  context 'YAML representation' do
+  context '#yaml_hash' do
     before :each do
       @message = 'test message'
       @lines = [24, 513]
@@ -100,18 +100,16 @@ describe SmellWarning do
 
     shared_examples_for 'common fields' do
       it 'includes the smell type' do
-        expect(@yaml).to match(/smell_type:\s*FeatureEnvy/)
+        expect(@yaml['smell_type']).to eq 'FeatureEnvy'
       end
       it 'includes the context' do
-        expect(@yaml).to match(/context:\s*#{@context_name}/)
+        expect(@yaml['context']).to eq @context_name
       end
       it 'includes the message' do
-        expect(@yaml).to match(/message:\s*#{@message}/)
+        expect(@yaml['message']).to eq @message
       end
       it 'includes the line numbers' do
-        @lines.each do |line|
-          expect(@yaml).to match(/lines:[\s\d-]*- #{line}/)
-        end
+        expect(@yaml['lines']).to match_array @lines
       end
     end
 
@@ -125,20 +123,20 @@ describe SmellWarning do
                                                lines: @lines,
                                                message: @message,
                                                parameters: @parameters)
-        @yaml = @warning.to_yaml
+        @yaml = @warning.yaml_hash
       end
 
       it_should_behave_like 'common fields'
 
       it 'includes the smell type' do
-        expect(@yaml).to match(/smell_type:\s*#{@smell_type}/)
+        expect(@yaml['smell_type']).to eq @smell_type
       end
       it 'includes the source' do
-        expect(@yaml).to match(/source:\s*#{@source}/)
+        expect(@yaml['source']).to eq @source
       end
       it 'includes the parameters' do
         @parameters.each do |key, value|
-          expect(@yaml).to match(/#{key}:\s*#{value}/)
+          expect(@yaml[key]).to eq value
         end
       end
     end

data/spec/reek/smells/boolean_parameter_spec.rb

@@ -8,35 +8,35 @@ describe 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) end'
-        expect(src).to smell_of(BooleanParameter, name: 'arga')
+        src = 'def cc(arga = true); arga; end'
+        expect(src).to reek_of(:BooleanParameter, name: 'arga')
       end
+
       it 'reports a parameter defaulted to false' do
         src = 'def cc(arga = false) end'
-        expect(src).to smell_of(BooleanParameter, name: 'arga')
+        expect(src).to reek_of(BooleanParameter, name: 'arga')
       end
+
       it 'reports two parameters defaulted to booleans' do
         src = 'def cc(nowt, arga = true, argb = false, &blk) end'
-        expect(src).to smell_of(BooleanParameter,
-                                { name: 'arga' },
-                                { name: 'argb' })
+        expect(src).to reek_of(BooleanParameter, name: 'arga')
+        expect(src).to reek_of(BooleanParameter, name: 'argb')
       end
     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 smell_of(BooleanParameter, name: 'arga')
+        expect(src).to reek_of(BooleanParameter, name: 'arga')
       end
       it 'reports a parameter defaulted to false' do
         src = 'def fred.cc(arga = false) end'
-        expect(src).to smell_of(BooleanParameter, name: 'arga')
+        expect(src).to reek_of(BooleanParameter, name: 'arga')
       end
       it 'reports two parameters defaulted to booleans' do
         src = 'def Module.cc(nowt, arga = true, argb = false, &blk) end'
-        expect(src).to smell_of(BooleanParameter,
-                                { name: 'arga' },
-                                { name: 'argb' })
+        expect(src).to reek_of(BooleanParameter, name: 'arga')
+        expect(src).to reek_of(BooleanParameter, name: 'argb')
       end
     end
   end

data/spec/reek/smells/control_parameter_spec.rb

@@ -15,94 +15,94 @@ describe ControlParameter do
   context 'parameter not used to determine code path' do
     it 'does not report a ternary check on an ivar' do
       src = 'def simple(arga) @ivar ? arga : 3 end'
-      expect(src).not_to smell_of(ControlParameter)
+      expect(src).not_to reek_of(ControlParameter)
     end
 
     it 'does not report a ternary check on a lvar' do
       src = 'def simple(arga) lvar = 27; lvar ? arga : @ivar end'
-      expect(src).not_to smell_of(ControlParameter)
+      expect(src).not_to reek_of(ControlParameter)
     end
 
     it 'does not report when parameter is unused' do
       src = 'def simple(arg) test = 1 end'
-      expect(src).not_to smell_of(ControlParameter)
+      expect(src).not_to reek_of(ControlParameter)
     end
 
     it 'does not report when parameter is used inside conditional' do
       src = 'def simple(arg) if true then puts arg end end'
-      expect(src).not_to smell_of(ControlParameter)
+      expect(src).not_to reek_of(ControlParameter)
     end
   end
 
   context 'parameter only used to determine code path' do
     it 'reports a ternary check on a parameter' do
       src = 'def simple(arga) arga ? @ivar : 3 end'
-      expect(src).to smell_of(ControlParameter, name: 'arga')
+      expect(src).to reek_of(ControlParameter, name: 'arga')
     end
 
     it 'reports a couple inside a block' do
       src = 'def blocks(arg) @text.map { |blk| arg ? blk : "#{blk}" } end'
-      expect(src).to smell_of(ControlParameter, name: 'arg')
+      expect(src).to reek_of(ControlParameter, name: 'arg')
     end
 
     it 'reports on an if statement modifier' do
       src = 'def simple(arg) args = {}; args.merge(\'a\' => \'A\') if arg end'
-      expect(src).to smell_of(ControlParameter, name: 'arg')
+      expect(src).to reek_of(ControlParameter, name: 'arg')
     end
 
     it 'reports on an unless statement modifier' do
       src = 'def simple(arg) args = {}; args.merge(\'a\' => \'A\') unless arg end'
-      expect(src).to smell_of(ControlParameter, name: 'arg')
+      expect(src).to reek_of(ControlParameter, name: 'arg')
     end
 
     it 'reports on if control expression' do
       src = 'def simple(arg) args = {}; if arg then args.merge(\'a\' => \'A\') end end'
-      expect(src).to smell_of(ControlParameter, name: 'arg')
+      expect(src).to reek_of(ControlParameter, name: 'arg')
     end
 
     it 'reports on if control expression with &&' do
       src = 'def simple(arg) if arg && true then puts "arg" end end'
-      expect(src).to smell_of(ControlParameter, name: 'arg')
+      expect(src).to reek_of(ControlParameter, name: 'arg')
     end
 
     it 'reports on if control expression with preceding &&' do
       src = 'def simple(arg) if true && arg then puts "arg" end end'
-      expect(src).to smell_of(ControlParameter, name: 'arg')
+      expect(src).to reek_of(ControlParameter, name: 'arg')
     end
 
     it 'reports on if control expression with two && conditions' do
       src = 'def simple(a) ag = {}; if a && true && true then puts "2" end end'
-      expect(src).to smell_of(ControlParameter, name: 'a')
+      expect(src).to reek_of(ControlParameter, name: 'a')
     end
 
     it 'reports on if control expression with ||' do
       src = 'def simple(arg) args = {}; if arg || true then puts "arg" end end'
-      expect(src).to smell_of(ControlParameter, name: 'arg')
+      expect(src).to reek_of(ControlParameter, name: 'arg')
     end
 
     it 'reports on if control expression with or' do
       src = 'def simple(arg) args = {}; if arg or true then puts "arg" end end'
-      expect(src).to smell_of(ControlParameter, name: 'arg')
+      expect(src).to reek_of(ControlParameter, name: 'arg')
     end
 
     it 'reports on if control expression with if' do
       src = 'def simple(arg) args = {}; if (arg if true) then puts "arg" end end'
-      expect(src).to smell_of(ControlParameter, name: 'arg')
+      expect(src).to reek_of(ControlParameter, name: 'arg')
     end
 
     it 'reports on && notation' do
       src = 'def simple(arg) args = {}; arg && args.merge(\'a\' => \'A\') end'
-      expect(src).to smell_of(ControlParameter, name: 'arg')
+      expect(src).to reek_of(ControlParameter, name: 'arg')
     end
 
     it 'reports on || notation' do
       src = 'def simple(arg) args = {}; arg || args.merge(\'a\' => \'A\') end'
-      expect(src).to smell_of(ControlParameter, name: 'arg')
+      expect(src).to reek_of(ControlParameter, name: 'arg')
     end
 
     it 'reports on case statement' do
       src = 'def simple(arg) case arg when nil; nil when false; nil else nil end end'
-      expect(src).to smell_of(ControlParameter, name: 'arg')
+      expect(src).to reek_of(ControlParameter, name: 'arg')
     end
 
     it 'reports on nested if statements that are both control parameters' do
@@ -114,7 +114,7 @@ describe ControlParameter do
           end
         end
       EOS
-      expect(src).to smell_of(ControlParameter, name: 'arg')
+      expect(src).to reek_of(ControlParameter, name: 'arg')
     end
 
     it 'reports on nested if statements where the inner if is a control parameter' do
@@ -126,32 +126,32 @@ describe ControlParameter do
           end
         end
       EOS
-      expect(src).to smell_of(ControlParameter, name: 'arg')
+      expect(src).to reek_of(ControlParameter, name: 'arg')
     end
 
     it 'reports on explicit comparison in the condition' do
       src = 'def simple(arg) if arg == :foo then :foo else :bar end end'
-      expect(src).to smell_of(ControlParameter)
+      expect(src).to reek_of(ControlParameter)
     end
 
     it 'reports on explicit negative comparison in the condition' do
       src = 'def simple(arg) if arg != :foo then :bar else :foo end end'
-      expect(src).to smell_of(ControlParameter)
+      expect(src).to reek_of(ControlParameter)
     end
 
     it 'reports when the argument is compared to a regexp' do
       src = 'def simple(arg) if arg =~ /foo/ then :foo else :bar end end'
-      expect(src).to smell_of(ControlParameter)
+      expect(src).to reek_of(ControlParameter)
     end
 
     it 'reports when the argument is reverse-compared to a regexp' do
       src = 'def simple(arg) if /foo/ =~ arg then :foo else :bar end end'
-      expect(src).to smell_of(ControlParameter)
+      expect(src).to reek_of(ControlParameter)
     end
 
     it 'reports when the argument is used in a complex regexp' do
       src = 'def simple(arg) if /foo#{arg}/ =~ bar then :foo else :bar end end'
-      expect(src).to smell_of(ControlParameter)
+      expect(src).to reek_of(ControlParameter)
     end
 
     it 'reports when the argument is a block parameter' do
@@ -160,64 +160,64 @@ describe ControlParameter do
           bar(blk || proc {})
         end
       EOS
-      expect(src).to smell_of(ControlParameter)
+      expect(src).to reek_of(ControlParameter)
     end
   end
 
   context 'parameter used besides determining code path' do
     it 'does not report on if conditional expression' do
       src = 'def simple(arg) if arg then use(arg) else use(@other) end end'
-      expect(src).not_to smell_of(ControlParameter)
+      expect(src).not_to reek_of(ControlParameter)
     end
 
     it 'does not report on an if statement modifier' do
       src = 'def simple(arg) args = {}; args.merge(\'a\' => arg) if arg end'
-      expect(src).not_to smell_of(ControlParameter)
+      expect(src).not_to reek_of(ControlParameter)
     end
 
     it 'does not report on an unless statement modifier' do
       src = 'def simple(arg) args = {}; args.merge(\'a\' => arg) unless arg end'
-      expect(src).not_to smell_of(ControlParameter)
+      expect(src).not_to reek_of(ControlParameter)
     end
 
     it 'does not report on if control expression' do
       src = 'def simple(arg) args = {}; if arg then args.merge(\'a\' => arg) end end'
-      expect(src).not_to smell_of(ControlParameter)
+      expect(src).not_to reek_of(ControlParameter)
     end
 
     it 'does not report on if control expression with &&' do
       src = 'def simple(arg) if arg && true then puts arg end end'
-      expect(src).not_to smell_of(ControlParameter)
+      expect(src).not_to reek_of(ControlParameter)
     end
 
     it 'does not report on && notation' do
       src = 'def simple(arg) args = {}; arg && args.merge(\'a\' => arg) end'
-      expect(src).not_to smell_of(ControlParameter)
+      expect(src).not_to reek_of(ControlParameter)
     end
 
     it 'does not report on || notation' do
       src = 'def simple(arg) args = {}; arg || args.merge(\'a\' => arg) end'
-      expect(src).not_to smell_of(ControlParameter)
+      expect(src).not_to reek_of(ControlParameter)
     end
 
     it 'does not report when parameter is used outside conditional' do
       src = 'def simple(arg) puts arg; if arg then @a = 1 end end'
-      expect(src).not_to smell_of(ControlParameter)
+      expect(src).not_to reek_of(ControlParameter)
     end
 
     it 'does not report when parameter is used as a method call argument in a condition' do
       src = 'def simple(arg) if foo(arg) then @a = 1 end end'
-      expect(src).not_to smell_of(ControlParameter)
+      expect(src).not_to reek_of(ControlParameter)
     end
 
     it 'does not report when parameter is used as a method call receiver in a condition' do
       src = 'def simple(arg) if arg.foo? then @a = 1 end end'
-      expect(src).not_to smell_of(ControlParameter)
+      expect(src).not_to reek_of(ControlParameter)
     end
 
     it 'does not report when the argument is a hash on which we access a key' do
       src = 'def simple(arg) if arg[\'a\'] then puts \'a\' else puts \'b\' end end'
-      expect(src).not_to smell_of ControlParameter
+      expect(src).not_to reek_of ControlParameter
     end
 
     it 'does not report when used in first conditional but not second' do
@@ -231,7 +231,7 @@ describe ControlParameter do
           end
         end
       EOS
-      expect(src).not_to smell_of(ControlParameter)
+      expect(src).not_to reek_of(ControlParameter)
     end
 
     it 'does not report when used in second conditional but not first' do
@@ -245,7 +245,7 @@ describe ControlParameter do
           end
         end
       EOS
-      expect(src).not_to smell_of(ControlParameter)
+      expect(src).not_to reek_of(ControlParameter)
     end
 
     it 'does not report when used in body of control flow operator' do
@@ -260,7 +260,7 @@ describe ControlParameter do
           qux or quuz(arg)
         end
       EOS
-      expect(src).not_to smell_of(ControlParameter)
+      expect(src).not_to reek_of(ControlParameter)
     end
   end