reek 4.4.1 → 4.4.2

data/spec/reek/smells/utility_function_spec.rb

@@ -17,31 +17,37 @@ RSpec.describe Reek::Smells::UtilityFunction do
   end
 
   it 'counts a local call in a param initializer' do
-    expect('def alfa(bravo = charlie) bravo.to_s end').not_to reek_of(:UtilityFunction)
+    src = 'def alfa(bravo = charlie) bravo.to_s end'
+    expect(src).not_to reek_of(:UtilityFunction)
   end
 
   it 'counts usages of self' do
-    expect('def alfa(bravo); alfa.bravo(self); end').not_to reek_of(:UtilityFunction)
+    src = 'def alfa(bravo); alfa.bravo(self); end'
+    expect(src).not_to reek_of(:UtilityFunction)
   end
 
   it 'counts self reference within a dstr' do
-    expect('def alfa(bravo); "#{self} #{bravo}"; end').not_to reek_of(:UtilityFunction)
+    src = 'def alfa(bravo); "#{self} #{bravo}"; end'
+    expect(src).not_to reek_of(:UtilityFunction)
   end
 
   it 'counts calls to self within a dstr' do
-    expect('def alfa(bravo); "#{self.gsub(/charlie/, /delta/)}"; end').
+    src = 'def alfa(bravo); "#{self.gsub(/charlie/, /delta/)}"; end'
+    expect(src).
       not_to reek_of(:UtilityFunction)
   end
 
   it 'does not report a method that calls super' do
-    expect('def alfa(bravo) super; bravo.to_s; end').not_to reek_of(:UtilityFunction)
+    src = 'def alfa(bravo) super; bravo.to_s; end'
+    expect(src).not_to reek_of(:UtilityFunction)
   end
 
   it 'does not report a method that calls super with arguments' do
-    expect('def alfa(bravo) super(bravo); bravo.to_s; end').not_to reek_of(:UtilityFunction)
+    src = 'def alfa(bravo) super(bravo); bravo.to_s; end'
+    expect(src).not_to reek_of(:UtilityFunction)
   end
 
-  it 'should recognise a deep call' do
+  it 'recognises a deep call' do
     src = <<-EOS
         class Alfa
           def bravo(charlie)
@@ -58,31 +64,38 @@ RSpec.describe Reek::Smells::UtilityFunction do
   end
 
   it 'does not report empty method' do
-    expect('def alfa(bravo); end').not_to reek_of(:UtilityFunction)
+    src = 'def alfa(bravo); end'
+    expect(src).not_to reek_of(:UtilityFunction)
   end
 
   it 'does not report literal' do
-    expect('def alfa; 3; end').not_to reek_of(:UtilityFunction)
+    src = 'def alfa; 3; end'
+    expect(src).not_to reek_of(:UtilityFunction)
   end
 
   it 'does not report instance variable reference' do
-    expect('def alfa; @bravo; end').not_to reek_of(:UtilityFunction)
+    src = 'def alfa; @bravo; end'
+    expect(src).not_to reek_of(:UtilityFunction)
   end
 
   it 'does not report vcall' do
-    expect('def alfa; bravo; end').not_to reek_of(:UtilityFunction)
+    src = 'def alfa; bravo; end'
+    expect(src).not_to reek_of(:UtilityFunction)
   end
 
   it 'does not report references to self' do
-    expect('def alfa; self; end').not_to reek_of(:UtilityFunction)
+    src = 'def alfa; self; end'
+    expect(src).not_to reek_of(:UtilityFunction)
   end
 
   it 'recognises an ivar reference within a block' do
-    expect('def alfa(bravo) bravo.each { @charlie = 3} end').not_to reek_of(:UtilityFunction)
+    src = 'def alfa(bravo) bravo.each { @charlie = 3} end'
+    expect(src).not_to reek_of(:UtilityFunction)
   end
 
   it 'reports a call to a constant' do
-    expect('def simple(arga) FIELDS[arga] end').to reek_of(:UtilityFunction, context: 'simple')
+    src = 'def simple(arga) FIELDS[arga] end'
+    expect(src).to reek_of(:UtilityFunction, context: 'simple')
   end
 
   context 'Singleton methods' do

data/spec/reek/source/source_code_spec.rb

@@ -6,20 +6,20 @@ RSpec.describe Reek::Source::SourceCode do
   describe '#syntax_tree' do
     it 'associates comments with the AST' do
       source = "# this is\n# a comment\ndef foo; end"
-      source_code = Reek::Source::SourceCode.new(code: source, origin: '(string)')
+      source_code = described_class.new(code: source, origin: '(string)')
       result = source_code.syntax_tree
       expect(result.leading_comment).to eq "# this is\n# a comment"
     end
 
     it 'cleanly processes empty source' do
-      source_code = Reek::Source::SourceCode.new(code: '', origin: '(string)')
+      source_code = described_class.new(code: '', origin: '(string)')
       result = source_code.syntax_tree
       expect(result).to be_nil
     end
 
     it 'cleanly processes empty source with comments' do
       source = "# this is\n# a comment\n"
-      source_code = Reek::Source::SourceCode.new(code: source, origin: '(string)')
+      source_code = described_class.new(code: source, origin: '(string)')
       result = source_code.syntax_tree
       expect(result).to be_nil
     end
@@ -29,8 +29,8 @@ RSpec.describe Reek::Source::SourceCode do
     let(:catcher) { StringIO.new }
     let(:source_name) { 'Test source' }
     let(:error_message) { 'Error message' }
-    let(:parser) { double('parser') }
-    let(:src) { Reek::Source::SourceCode.new(code: '', origin: source_name, parser: parser) }
+    let(:parser) { class_double(Parser::Ruby23) }
+    let(:src) { described_class.new(code: '', origin: source_name, parser: parser) }
 
     before { $stderr = catcher }
 
@@ -61,7 +61,7 @@ RSpec.describe Reek::Source::SourceCode do
 
     context 'with a Parser::SyntaxError' do
       let(:error_class) { Parser::SyntaxError }
-      let(:diagnostic) { double('diagnostic', message: error_message) }
+      let(:diagnostic) { instance_double('Parser::Diagnostic', message: error_message) }
 
       before do
         allow(parser).to receive(:parse_with_comments).

data/spec/reek/source/source_locator_spec.rb

@@ -9,19 +9,23 @@ RSpec.describe Reek::Source::SourceLocator do
       let(:path) { SAMPLES_PATH.join('source_with_hidden_directories') }
 
       let(:expected_paths) do
-        [SAMPLES_PATH.join('source_with_hidden_directories/uncommunicative_parameter_name.rb')]
+        [path.join('uncommunicative_parameter_name.rb')]
       end
 
       let(:paths_that_are_expected_to_be_ignored) do
-        [SAMPLES_PATH.join('source_with_hidden_directories/.hidden/\
-          uncommunicative_parameter_nameicative_method_name.rb')]
+        [path.join('.hidden/uncommunicative_method_name.rb')]
       end
 
       it 'does not scan hidden directories' do
         sources = described_class.new([path]).sources
 
         expect(sources).not_to include(*paths_that_are_expected_to_be_ignored)
-        expect(sources).to eq expected_paths
+      end
+
+      it 'scans directories that are not hidden' do
+        sources = described_class.new([path]).sources
+
+        expect(sources).to match_array expected_paths
       end
     end
 
@@ -32,42 +36,50 @@ RSpec.describe Reek::Source::SourceLocator do
 
       let(:path) { SAMPLES_PATH.join('source_with_exclude_paths') }
 
+      let(:expected_paths) do
+        [path.join('nested/uncommunicative_parameter_name.rb')]
+      end
+
       let(:paths_that_are_expected_to_be_ignored) do
         [
-          SAMPLES_PATH.join('source_with_exclude_paths/ignore_me/uncommunicative_method_name.rb'),
-          SAMPLES_PATH.join('source_with_exclude_paths/nested/' \
-                            'ignore_me_as_well/irresponsible_module.rb')
+          path.join('ignore_me/uncommunicative_method_name.rb'),
+          path.join('nested/ignore_me_as_well/irresponsible_module.rb')
         ]
       end
 
       it 'does not use excluded paths' do
         sources = described_class.new([path], configuration: configuration).sources
         expect(sources).not_to include(*paths_that_are_expected_to_be_ignored)
+      end
 
-        expect(sources).to eq [
-          SAMPLES_PATH.join('source_with_exclude_paths/nested/uncommunicative_parameter_name.rb')
-        ]
+      it 'scans directories that are not excluded' do
+        sources = described_class.new([path], configuration: configuration).sources
+        expect(sources).to eq expected_paths
       end
     end
 
     context 'non-Ruby paths' do
       let(:path) { SAMPLES_PATH.join('source_with_non_ruby_files') }
       let(:expected_sources) do
-        [SAMPLES_PATH.join('source_with_non_ruby_files/uncommunicative_parameter_name.rb')]
+        [path.join('uncommunicative_parameter_name.rb')]
       end
       let(:paths_that_are_expected_to_be_ignored) do
         [
-          SAMPLES_PATH.join('source_with_non_ruby_files/gibberish'),
-          SAMPLES_PATH.join('source_with_non_ruby_files/python_source.py')
+          path.join('gibberish'),
+          path.join('python_source.py')
         ]
       end
 
-      it 'does only use Ruby source paths' do
+      it 'uses Ruby source paths' do
         sources = described_class.new([path]).sources
 
-        expect(sources).not_to include(*paths_that_are_expected_to_be_ignored)
+        expect(sources).to include(*expected_sources)
+      end
 
-        expect(sources).to eq expected_sources
+      it 'does not use non-Ruby source paths' do
+        sources = described_class.new([path]).sources
+
+        expect(sources).not_to include(*paths_that_are_expected_to_be_ignored)
       end
     end
 
@@ -77,10 +89,15 @@ RSpec.describe Reek::Source::SourceLocator do
       end
 
       it 'expands it correctly' do
+        sources_for_dot = described_class.new([Pathname.new('.')]).sources
+
+        expect(sources_for_dot).to include(*expected_sources)
+      end
+
+      it 'ignores the trailing slash' do
         sources_for_dot       = described_class.new([Pathname.new('.')]).sources
         sources_for_dot_slash = described_class.new([Pathname.new('./')]).sources
 
-        expect(sources_for_dot).to include(*expected_sources)
         expect(sources_for_dot).to eq(sources_for_dot_slash)
       end
     end

data/spec/reek/spec/should_reek_of_spec.rb

@@ -24,7 +24,7 @@ RSpec.describe Reek::Spec::ShouldReekOf do
   describe 'different sources of input' do
     context 'checking code in a string' do
       let(:clean_code) { 'def good() true; end' }
-      let(:matcher) { Reek::Spec::ShouldReekOf.new(:UncommunicativeVariableName, name: 'y') }
+      let(:matcher) { described_class.new(:UncommunicativeVariableName, name: 'y') }
       let(:smelly_code) { 'def x() y = 4; end' }
 
       it 'matches a smelly String' do
@@ -42,7 +42,7 @@ RSpec.describe Reek::Spec::ShouldReekOf do
     end
 
     context 'checking code in a File' do
-      let(:matcher) { Reek::Spec::ShouldReekOf.new(:UncommunicativeMethodName, name: 'x') }
+      let(:matcher) { described_class.new(:UncommunicativeMethodName, name: 'x') }
 
       it 'matches a smelly file' do
         expect(matcher.matches?(SMELLY_FILE)).to be_truthy
@@ -56,7 +56,7 @@ RSpec.describe Reek::Spec::ShouldReekOf do
 
   describe 'smell types and smell details' do
     context 'passing in smell_details with unknown parameter name' do
-      let(:matcher) { Reek::Spec::ShouldReekOf.new(:UncommunicativeVariableName, foo: 'y') }
+      let(:matcher) { described_class.new(:UncommunicativeVariableName, foo: 'y') }
       let(:smelly_code) { 'def x() y = 4; end' }
 
       it 'raises ArgumentError' do
@@ -65,7 +65,7 @@ RSpec.describe Reek::Spec::ShouldReekOf do
     end
 
     context 'both are matching' do
-      let(:matcher) { Reek::Spec::ShouldReekOf.new(:UncommunicativeVariableName, name: 'y') }
+      let(:matcher) { described_class.new(:UncommunicativeVariableName, name: 'y') }
       let(:smelly_code) { 'def x() y = 4; end' }
 
       it 'is truthy' do
@@ -76,8 +76,8 @@ RSpec.describe Reek::Spec::ShouldReekOf do
     context 'no smell_type is matching' do
       let(:smelly_code) { 'def dummy() y = 4; end' }
 
-      let(:falsey_matcher) { Reek::Spec::ShouldReekOf.new(:FeatureEnvy, name: 'y') }
-      let(:truthy_matcher) { Reek::Spec::ShouldReekOf.new(:UncommunicativeVariableName, name: 'y') }
+      let(:falsey_matcher) { described_class.new(:FeatureEnvy, name: 'y') }
+      let(:truthy_matcher) { described_class.new(:UncommunicativeVariableName, name: 'y') }
 
       it 'is falsey' do
         expect(falsey_matcher.matches?(smelly_code)).to be_falsey
@@ -100,7 +100,7 @@ RSpec.describe Reek::Spec::ShouldReekOf do
 
     context 'smell type is matching but smell details are not' do
       let(:smelly_code) { 'def double_thing() @other.thing.foo + @other.thing.foo end' }
-      let(:matcher) { Reek::Spec::ShouldReekOf.new(:DuplicateMethodCall, name: 'foo', count: 15) }
+      let(:matcher) { described_class.new(:DuplicateMethodCall, name: 'foo', count: 15) }
 
       it 'is falsey' do
         expect(matcher.matches?(smelly_code)).to be_falsey
@@ -130,15 +130,20 @@ RSpec.describe Reek::Spec::ShouldReekOf do
     end
   end
 
-  it 'enables the smell detector to match automatically' do
-    default_config = Reek::Smells::UnusedPrivateMethod.default_config
-    expect(default_config[Reek::Smells::SmellConfiguration::ENABLED_KEY]).to be_falsy
+  context 'for a smell that is disabled by default' do
+    before do
+      default_config = Reek::Smells::UnusedPrivateMethod.default_config
+      expect(default_config[Reek::Smells::SmellConfiguration::ENABLED_KEY]).to be_falsy
+    end
 
-    expect('class C; private; def foo; end; end').to reek_of(:UnusedPrivateMethod)
+    it 'enables the smell detector to match automatically' do
+      src = 'class C; private; def foo; end; end'
+      expect(src).to reek_of(:UnusedPrivateMethod)
+    end
   end
 
   describe '#with_config' do
-    let(:matcher) { Reek::Spec::ShouldReekOf.new(:UncommunicativeVariableName) }
+    let(:matcher) { described_class.new(:UncommunicativeVariableName) }
     let(:configured_matcher) { matcher.with_config('accept' => 'x') }
 
     it 'uses the passed-in configuration for matching' do

data/spec/reek/spec/should_reek_only_of_spec.rb

@@ -2,14 +2,14 @@ require_relative '../../spec_helper'
 require_lib 'reek/spec'
 
 RSpec.describe Reek::Spec::ShouldReekOnlyOf do
-  let(:examiner) { double('examiner').as_null_object }
+  let(:examiner) { instance_double('Reek::Examiner').as_null_object }
   let(:expected_context_name) { 'SmellyClass#big_method' }
   let(:expected_smell_type) { :NestedIterators }
-  let(:matcher) { Reek::Spec::ShouldReekOnlyOf.new(expected_smell_type) }
+  let(:matcher) { described_class.new(expected_smell_type) }
   let(:matcher_matches) { matcher.matches_examiner?(examiner) }
 
   before do
-    expect(examiner).to receive(:smells) { smells }
+    allow(examiner).to receive(:smells) { smells }
     matcher_matches
   end
 
@@ -21,7 +21,7 @@ RSpec.describe Reek::Spec::ShouldReekOnlyOf do
     context 'when a match was expected' do
       let(:source) { 'the_path/to_a/source_file.rb' }
 
-      before { expect(examiner).to receive(:description).and_return(source) }
+      before { allow(examiner).to receive(:description).and_return(source) }
 
       it 'reports the source' do
         expect(matcher.failure_message).to match(source)
@@ -91,7 +91,7 @@ RSpec.describe Reek::Spec::ShouldReekOnlyOf do
 
     it 'reports the source when no match was expected' do
       source = 'the_path/to_a/source_file.rb'
-      expect(examiner).to receive(:description).and_return(source)
+      allow(examiner).to receive(:description).and_return(source)
       expect(matcher.failure_message_when_negated).to match(source)
     end
   end

data/spec/reek/spec/should_reek_spec.rb

@@ -3,7 +3,7 @@ require_lib 'reek/spec'
 
 RSpec.describe Reek::Spec::ShouldReek do
   describe 'checking code in a string' do
-    let(:matcher) { Reek::Spec::ShouldReek.new }
+    let(:matcher) { described_class.new }
     let(:clean_code) { 'def good() true; end' }
     let(:smelly_code) { 'def x() y = 4; end' }
 
@@ -23,7 +23,7 @@ RSpec.describe Reek::Spec::ShouldReek do
 
   describe 'checking code in a File' do
     context 'matcher without masking' do
-      let(:matcher) { Reek::Spec::ShouldReek.new }
+      let(:matcher) { described_class.new }
 
       it 'matches a smelly File' do
         expect(matcher.matches?(SMELLY_FILE)).to be_truthy
@@ -42,7 +42,7 @@ RSpec.describe Reek::Spec::ShouldReek do
     context 'matcher without masking' do
       let(:path) { CONFIG_PATH.join('full_mask.reek') }
       let(:configuration) { test_configuration_for(path) }
-      let(:matcher) { Reek::Spec::ShouldReek.new(configuration: configuration) }
+      let(:matcher) { described_class.new(configuration: configuration) }
 
       it 'masks smells using the relevant configuration' do
         expect(matcher.matches?(SMELLY_FILE)).to be_falsey

data/spec/reek/tree_dresser_spec.rb

@@ -33,13 +33,15 @@ RSpec.describe Reek::TreeDresser do
     end
 
     it 'dresses `def` nodes properly' do
-      expect(def_node).to be_a Reek::AST::SexpExtensions::DefNode
-      expect(def_node).to be_a Reek::AST::SexpExtensions::MethodNodeBase
+      expect(def_node).
+        to be_a(Reek::AST::SexpExtensions::DefNode).
+        and be_a(Reek::AST::SexpExtensions::MethodNodeBase)
     end
 
     it 'dresses `args` nodes properly' do
-      expect(args_node).to be_a Reek::AST::SexpExtensions::ArgsNode
-      expect(args_node).to be_a Reek::AST::SexpExtensions::NestedAssignables
+      expect(args_node).
+        to be_a(Reek::AST::SexpExtensions::ArgsNode).
+        and be_a(Reek::AST::SexpExtensions::NestedAssignables)
     end
 
     it 'dresses `send` nodes properly' do

data/spec/spec_helper.rb

@@ -81,6 +81,7 @@ RSpec.configure do |config|
 
   config.mock_with :rspec do |mocks|
     mocks.verify_partial_doubles = true
+    mocks.verify_doubled_constant_names = true
   end
 
   # Avoid infinitely running tests. This is mainly useful when running mutant.
@@ -93,6 +94,8 @@ RSpec.configure do |config|
   end
 end
 
+RSpec::Matchers.define_negated_matcher :not_reek_of, :reek_of
+
 private
 
 def require_lib(path)

data/tasks/rubocop.rake

@@ -1,5 +1,11 @@
-require 'rubocop/rake_task'
+begin
+  require 'rubocop/rake_task'
 
-RuboCop::RakeTask.new do |task|
-  task.options << '--display-cop-names'
+  RuboCop::RakeTask.new do |task|
+    task.options << '--display-cop-names'
+  end
+rescue LoadError
+  task :rubocop do
+    puts 'Install rubocop to run its rake tasks'
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: reek
 version: !ruby/object:Gem::Version
-  version: 4.4.1
+  version: 4.4.2
 platform: ruby
 authors:
 - Kevin Rutherford
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-13 00:00:00.000000000 Z
+date: 2016-09-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: codeclimate-engine-rb
@@ -155,6 +155,7 @@ files:
 - features/configuration_files/reject_setting.feature
 - features/configuration_files/unused_private_method.feature
 - features/configuration_loading.feature
+- features/configuration_via_source_comments/erroneous_source_comments.feature
 - features/programmatic_access.feature
 - features/rake_task/rake_task.feature
 - features/reports/json.feature
@@ -219,6 +220,7 @@ files:
 - lib/reek/context/statement_counter.rb
 - lib/reek/context/visibility_tracker.rb
 - lib/reek/context_builder.rb
+- lib/reek/errors.rb
 - lib/reek/examiner.rb
 - lib/reek/rake/task.rb
 - lib/reek/report.rb