reek 2.0.4 → 3.0.0

data/spec/reek/cli/options_spec.rb

@@ -0,0 +1,19 @@
+require_relative '../../spec_helper'
+
+require_relative '../../../lib/reek/cli/options'
+
+RSpec.describe Reek::CLI::Options do
+  describe '#initialize' do
+    it 'should enable colors when stdout is a TTY' do
+      allow($stdout).to receive_messages(tty?: false)
+      options = Reek::CLI::Options.new.parse
+      expect(options.colored).to be false
+    end
+
+    it 'should not enable colors when stdout is not a TTY' do
+      allow($stdout).to receive_messages(tty?: true)
+      options = Reek::CLI::Options.new.parse
+      expect(options.colored).to be true
+    end
+  end
+end

data/spec/reek/cli/warning_collector_spec.rb

@@ -0,0 +1,28 @@
+require_relative '../../spec_helper'
+require_relative '../../../lib/reek/cli/warning_collector'
+require_relative '../../../lib/reek/smells/smell_warning'
+
+RSpec.describe Reek::CLI::WarningCollector do
+  before(:each) do
+    @collector = described_class.new
+  end
+
+  context 'when empty' do
+    it 'reports no warnings' do
+      expect(@collector.warnings).to eq([])
+    end
+  end
+
+  context 'with one warning' do
+    before :each do
+      @warning = Reek::Smells::SmellWarning.new(Reek::Smells::FeatureEnvy.new(''),
+                                                context: 'fred',
+                                                lines:   [1, 2, 3],
+                                                message: 'hello')
+      @collector.found_smell(@warning)
+    end
+    it 'reports that warning' do
+      expect(@collector.warnings).to eq([@warning])
+    end
+  end
+end

data/spec/reek/{source/code_comment_spec.rb → code_comment_spec.rb}

@@ -1,12 +1,10 @@
-require 'spec_helper'
-require 'reek/source/code_comment'
+require_relative '../spec_helper'
+require_relative '../../lib/reek/code_comment'
 
-include Reek::Source
-
-describe CodeComment do
+RSpec.describe Reek::CodeComment do
   context 'with an empty comment' do
     before :each do
-      @comment = CodeComment.new('')
+      @comment = described_class.new('')
     end
     it 'is not descriptive' do
       expect(@comment).not_to be_descriptive
@@ -18,34 +16,37 @@ describe CodeComment do
 
   context 'comment checks' do
     it 'rejects an empty comment' do
-      expect(CodeComment.new('#')).not_to be_descriptive
+      expect(described_class.new('#')).not_to be_descriptive
     end
     it 'rejects a 1-word comment' do
-      expect(CodeComment.new("# fred\n#  ")).not_to be_descriptive
+      expect(described_class.new("# fred\n#  ")).not_to be_descriptive
     end
     it 'accepts a 2-word comment' do
-      expect(CodeComment.new('# fred here  ')).to be_descriptive
+      expect(described_class.new('# fred here  ')).to be_descriptive
     end
     it 'accepts a multi-word comment' do
-      expect(CodeComment.new("# fred here \n# with \n   # biscuits ")).to be_descriptive
+      comment = "# fred here \n# with \n   # biscuits "
+      expect(described_class.new(comment)).to be_descriptive
     end
   end
 
   context 'comment config' do
     it 'parses hashed options' do
-      config = CodeComment.new('# :reek:Duplication: { enabled: false }').config
+      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 'parses hashed options with ruby names' do
-      config = CodeComment.new('# :reek:nested_iterators: { enabled: true }').config
+      comment = '# :reek:nested_iterators: { enabled: true }'
+      config = described_class.new(comment).config
       expect(config).to include('NestedIterators')
       expect(config['NestedIterators']).to include('enabled')
       expect(config['NestedIterators']['enabled']).to be_truthy
     end
     it 'parses multiple hashed options' do
-      config = CodeComment.new('
+      config = described_class.new('
         # :reek:Duplication: { enabled: false }
         :reek:nested_iterators: { enabled: true }
       ').config
@@ -56,7 +57,7 @@ describe CodeComment do
       expect(config['NestedIterators']['enabled']).to be_truthy
     end
     it 'parses multiple hashed options on the same line' do
-      config = CodeComment.new('
+      config = described_class.new('
         #:reek:Duplication: { enabled: false } and :reek:nested_iterators: { enabled: true }
       ').config
       expect(config).to include('Duplication', 'NestedIterators')
@@ -66,7 +67,8 @@ describe CodeComment do
       expect(config['NestedIterators']['enabled']).to be_truthy
     end
     it 'parses multiple unhashed options on the same line' do
-      config = CodeComment.new('# :reek:Duplication and :reek:nested_iterators').config
+      comment = '# :reek:Duplication and :reek:nested_iterators'
+      config = described_class.new(comment).config
       expect(config).to include('Duplication', 'NestedIterators')
       expect(config['Duplication']).to include('enabled')
       expect(config['Duplication']['enabled']).to be_falsey
@@ -74,13 +76,13 @@ describe CodeComment do
       expect(config['NestedIterators']['enabled']).to be_falsey
     end
     it 'disables the smell if no options are specifed' do
-      config = CodeComment.new('# :reek:Duplication').config
+      config = described_class.new('# :reek:Duplication').config
       expect(config).to include('Duplication')
       expect(config['Duplication']).to include('enabled')
       expect(config['Duplication']['enabled']).to be_falsey
     end
     it 'ignores smells after a space' do
-      config = CodeComment.new('# :reek: Duplication').config
+      config = described_class.new('# :reek: Duplication').config
       expect(config).not_to include('Duplication')
     end
   end

data/spec/reek/configuration/app_configuration_spec.rb

@@ -1,12 +1,9 @@
-require 'spec_helper'
-require 'reek/configuration/app_configuration'
-require 'reek/core/smell_repository'
+require_relative '../../spec_helper'
+require_relative '../../../lib/reek/configuration/app_configuration'
+require_relative '../../../lib/reek/smells/smell_repository'
 
-include Reek::Configuration
-include Reek::Core
-
-describe AppConfiguration do
-  let(:sample_configuration_path) { 'spec/samples/simple_configuration.reek' }
+RSpec.describe Reek::Configuration::AppConfiguration do
+  let(:sample_configuration_path) { 'spec/samples/configuration/simple_configuration.reek' }
   let(:sample_configuration_loaded) do
     {
       'UncommunicativeVariableName' => { 'enabled' => false },
@@ -15,31 +12,32 @@ describe AppConfiguration do
   end
   let(:default_configuration) { Hash.new }
 
-  after(:each) { AppConfiguration.reset }
+  after(:each) { described_class.reset }
 
   describe '.initialize_with' do
     it 'loads a configuration file if it can find one' do
-      allow(ConfigurationFileFinder).to receive(:find).and_return sample_configuration_path
-      expect(AppConfiguration.configuration).to eq(default_configuration)
+      finder = Reek::Configuration::ConfigurationFileFinder
+      allow(finder).to receive(:find).and_return sample_configuration_path
+      expect(described_class.configuration).to eq(default_configuration)
 
-      AppConfiguration.initialize_with(nil)
-      expect(AppConfiguration.configuration).to eq(sample_configuration_loaded)
+      described_class.initialize_with(nil)
+      expect(described_class.configuration).to eq(sample_configuration_loaded)
     end
 
     it 'leaves the default configuration untouched if it can\'t find one' do
-      allow(ConfigurationFileFinder).to receive(:find).and_return nil
-      expect(AppConfiguration.configuration).to eq(default_configuration)
+      allow(Reek::Configuration::ConfigurationFileFinder).to receive(:find).and_return nil
+      expect(described_class.configuration).to eq(default_configuration)
 
-      AppConfiguration.initialize_with(nil)
-      expect(AppConfiguration.configuration).to eq(default_configuration)
+      described_class.initialize_with(nil)
+      expect(described_class.configuration).to eq(default_configuration)
     end
   end
 
   describe '.configure_smell_repository' do
     it 'should configure a given smell_repository' do
-      AppConfiguration.load_from_file(sample_configuration_path)
-      smell_repository = SmellRepository.new('def m; end')
-      AppConfiguration.configure_smell_repository smell_repository
+      described_class.load_from_file(sample_configuration_path)
+      smell_repository = Reek::Smells::SmellRepository.new('def m; end')
+      described_class.configure_smell_repository smell_repository
 
       expect(smell_repository.detectors[Reek::Smells::DataClump]).to be_enabled
       expect(smell_repository.detectors[Reek::Smells::UncommunicativeVariableName]).
@@ -48,20 +46,33 @@ describe AppConfiguration do
     end
   end
 
+  describe '.exclude_paths' do
+    let(:config_path) { 'spec/samples/configuration/with_excluded_paths.reek' }
+
+    it 'should return all paths to exclude' do
+      with_test_config(config_path) do
+        expect(described_class.exclude_paths).to eq [
+          'spec/samples/source_with_exclude_paths/ignore_me',
+          'spec/samples/source_with_exclude_paths/nested/ignore_me_as_well'
+        ]
+      end
+    end
+  end
+
   describe '.load_from_file' do
     it 'loads the configuration from given file' do
-      AppConfiguration.load_from_file(sample_configuration_path)
-      expect(AppConfiguration.configuration).to eq(sample_configuration_loaded)
+      described_class.load_from_file(sample_configuration_path)
+      expect(described_class.configuration).to eq(sample_configuration_loaded)
     end
   end
 
   describe '.reset' do
     it 'resets the configuration' do
-      AppConfiguration.load_from_file(sample_configuration_path)
+      described_class.load_from_file(sample_configuration_path)
 
-      expect(AppConfiguration.configuration).to eq(sample_configuration_loaded)
-      AppConfiguration.reset
-      expect(AppConfiguration.configuration).to eq(default_configuration)
+      expect(described_class.configuration).to eq(sample_configuration_loaded)
+      described_class.reset
+      expect(described_class.configuration).to eq(default_configuration)
     end
   end
 end

data/spec/reek/configuration/configuration_file_finder_spec.rb

@@ -1,34 +1,80 @@
-require 'spec_helper'
-require 'reek/cli/application'
+# encoding: UTF-8
 
-include Reek::Cli
-include Reek::Configuration
+require 'fileutils'
+require 'pathname'
+require 'tmpdir'
+require_relative '../../spec_helper'
 
-describe ConfigurationFileFinder do
+RSpec.describe Reek::Configuration::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_with_config_file) { double(config_file: sample_config_path) }
-    let(:options_without_config_file) { double(config_file: nil) }
+    it 'returns the config_file if it’s set' do
+      config_file = double
+      options = double(config_file: config_file)
+      found = described_class.find(options: options)
+      expect(found).to eq(config_file)
+    end
+
+    it 'returns the file in current dir if config_file is nil' do
+      options = double(config_file: nil)
+      current = Pathname.new('spec/samples')
+      found = described_class.find(options: options, current: current)
+      expect(found).to eq(Pathname.new('spec/samples/exceptions.reek'))
+    end
+
+    it 'returns the file in current dir if options is nil' do
+      current = Pathname.new('spec/samples')
+      found = described_class.find(current: current)
+      expect(found).to eq(Pathname.new('spec/samples/exceptions.reek'))
+    end
 
-    it 'should return the config file we passed as cli option if given' do
-      expect(ConfigurationFileFinder.find(options_with_config_file)).to eq(sample_config_path)
+    it 'returns the file in a parent dir if none in current dir' do
+      current = Pathname.new('spec/samples/no_config_file')
+      found = described_class.find(current: current)
+      expect(found).to eq(Pathname.new('spec/samples/exceptions.reek'))
     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
+    it 'returns the file even if it’s just ‘.reek’' do
+      current = Pathname.new('spec/samples/masked_by_dotfile')
+      found = described_class.find(current: current)
+      expect(found).to eq(Pathname.new('spec/samples/masked_by_dotfile/.reek'))
+    end
+
+    it 'returns the file in home if traversing from the current dir fails' do
+      skip_if_a_config_in_tempdir
+      Dir.mktmpdir do |tempdir|
+        current = Pathname.new(tempdir)
+        home    = Pathname.new('spec/samples')
+        found = described_class.find(current: current, home: home)
+        expect(found).to eq(Pathname.new('spec/samples/exceptions.reek'))
+      end
+    end
+
+    it 'returns nil when there are no files to find' do
+      skip_if_a_config_in_tempdir
+      Dir.mktmpdir do |tempdir|
+        current = Pathname.new(tempdir)
+        home    = Pathname.new(tempdir)
+        found = described_class.find(current: current, home: home)
+        expect(found).to be_nil
+      end
+    end
 
-      expect(ConfigurationFileFinder.find(options_without_config_file)).
-        to eq(config_path_same_level)
+    it 'works with paths that need escaping' do
+      Dir.mktmpdir("ma\ngic d*r") do |tempdir|
+        config = Pathname.new("#{tempdir}/ma\ngic f*le.reek")
+        subdir = Pathname.new("#{tempdir}/ma\ngic subd*r")
+        FileUtils.touch config
+        FileUtils.mkdir subdir
+        found = described_class.find(current: subdir)
+        expect(found).to eq(config)
+      end
     end
 
-    it 'should look in the HOME directory lastly' do
-      allow(ConfigurationFileFinder).to receive(:configuration_by_cli).and_return nil
-      allow(ConfigurationFileFinder).to receive(:configuration_in_file_system).and_return nil
-      expect(ConfigurationFileFinder).to receive(:configuration_in_home_directory).once
+    private
 
-      ConfigurationFileFinder.find nil
+    def skip_if_a_config_in_tempdir
+      found = described_class.find(current: Pathname.new(Dir.tmpdir))
+      skip "skipped: #{found} exists and would fail this test" if found
     end
   end
 end

data/spec/reek/{core → context}/code_context_spec.rb

@@ -1,11 +1,9 @@
-require 'spec_helper'
-require 'reek/core/method_context'
-require 'reek/core/module_context'
-require 'reek/core/stop_context'
+require_relative '../../spec_helper'
+require_relative '../../../lib/reek/context/method_context'
+require_relative '../../../lib/reek/context/module_context'
+require_relative '../../../lib/reek/context/root_context'
 
-include Reek::Core
-
-describe CodeContext do
+RSpec.describe Reek::Context::CodeContext do
   context 'name recognition' do
     before :each do
       @exp_name = 'random_name'    # SMELL: could use a String.random here
@@ -13,8 +11,7 @@ describe CodeContext do
       @exp = double('exp')
       allow(@exp).to receive(:name).and_return(@exp_name)
       allow(@exp).to receive(:full_name).and_return(@full_name)
-      allow(@exp).to receive(:comments).and_return('')
-      @ctx = CodeContext.new(nil, @exp)
+      @ctx = Reek::Context::CodeContext.new(nil, @exp)
     end
     it 'gets its short name from the exp' do
       expect(@ctx.name).to eq(@exp_name)
@@ -44,7 +41,7 @@ describe CodeContext do
         @outer_name = 'another_random sting'
         allow(outer).to receive(:full_name).at_least(:once).and_return(@outer_name)
         allow(outer).to receive(:config).and_return({})
-        @ctx = CodeContext.new(outer, @exp)
+        @ctx = Reek::Context::CodeContext.new(outer, @exp)
       end
       it 'creates the correct full name' do
         expect(@ctx.full_name).to eq("#{@full_name}")
@@ -60,10 +57,10 @@ describe CodeContext do
 
   context 'generics' do
     it 'should pass unknown method calls down the stack' do
-      stop = StopContext.new
+      stop = Reek::Context::RootContext.new
       def stop.bananas(arg1, arg2) arg1 + arg2 + 43 end
-      element = ModuleContext.new(stop, s(:module, :mod, nil))
-      element = MethodContext.new(element, s(:def, :bad, s(:args), nil))
+      element = Reek::Context::ModuleContext.new(stop, s(:module, :mod, nil))
+      element = Reek::Context::MethodContext.new(element, s(:def, :bad, s(:args), nil))
       expect(element.bananas(17, -5)).to eq(55)
     end
   end
@@ -73,8 +70,8 @@ describe CodeContext do
       before :each do
         @module_name = 'Emptiness'
         src = "module #{@module_name}; end"
-        ast = src.to_reek_source.syntax_tree
-        @ctx = CodeContext.new(nil, ast)
+        ast = Reek::Source::SourceCode.from(src).syntax_tree
+        @ctx = Reek::Context::CodeContext.new(nil, ast)
       end
 
       it 'yields no calls' do
@@ -105,8 +102,8 @@ describe CodeContext do
         @module_name = 'Loneliness'
         @method_name = 'calloo'
         src = "module #{@module_name}; def #{@method_name}; puts('hello') end; end"
-        ast = src.to_reek_source.syntax_tree
-        @ctx = CodeContext.new(nil, ast)
+        ast = Reek::Source::SourceCode.from(src).syntax_tree
+        @ctx = Reek::Context::CodeContext.new(nil, ast)
       end
       it 'yields no ifs' do
         @ctx.each_node(:if, []) { |exp| raise "#{exp} yielded by empty module!" }
@@ -157,8 +154,8 @@ class Scrunch
 end
 EOS
 
-      ast = src.to_reek_source.syntax_tree
-      ctx = CodeContext.new(nil, ast)
+      ast = Reek::Source::SourceCode.from(src).syntax_tree
+      ctx = Reek::Context::CodeContext.new(nil, ast)
       expect(ctx.each_node(:if, []).length).to eq(3)
     end
   end
@@ -166,12 +163,12 @@ EOS
   describe '#config_for' do
     let(:expression) { double('exp') }
     let(:outer) { nil }
-    let(:context) { CodeContext.new(outer, expression) }
+    let(:context) { Reek::Context::CodeContext.new(outer, expression) }
     let(:sniffer) { double('sniffer') }
 
     before :each do
       allow(sniffer).to receive(:smell_type).and_return('DuplicateMethodCall')
-      allow(expression).to receive(:comments).and_return(
+      allow(expression).to receive(:full_comment).and_return(
         ':reek:DuplicateMethodCall: { allow_calls: [ puts ] }')
     end
 

data/spec/reek/{core → context}/method_context_spec.rb

@@ -1,14 +1,12 @@
-require 'spec_helper'
-require 'reek/core/method_context'
-require 'reek/core/stop_context'
+require_relative '../../spec_helper'
+require_relative '../../../lib/reek/context/method_context'
+require_relative '../../../lib/reek/context/root_context'
 
-include Reek::Core
-
-describe MethodContext, 'matching' do
+RSpec.describe Reek::Context::MethodContext, 'matching' do
   before :each do
     exp = double('exp').as_null_object
     expect(exp).to receive(:full_name).at_least(:once).and_return('mod')
-    @element = MethodContext.new(StopContext.new, exp)
+    @element = Reek::Context::MethodContext.new(Reek::Context::RootContext.new, exp)
   end
 
   it 'should recognise itself in a collection of names' do
@@ -22,33 +20,41 @@ describe MethodContext, 'matching' do
   end
 end
 
-describe MethodContext do
-  it 'should record ivars as refs to self' do
-    mctx = MethodContext.new(StopContext.new, s(:def, :feed, s(:args), nil))
-    expect(mctx.envious_receivers).to eq([])
-    mctx.record_call_to(s(:send, s(:ivar, :@cow), :feed_to))
-    expect(mctx.envious_receivers).to eq([])
+RSpec.describe Reek::Context::MethodContext do
+  let(:mc) do
+    sexp = s(:def, :foo, s(:args, s(:arg, :bar)), nil)
+    Reek::Context::MethodContext.new(Reek::Context::RootContext.new, sexp)
   end
 
-  it 'should count calls to self' do
-    mctx = MethodContext.new(StopContext.new, s(:def, :equals, s(:args), nil))
-    mctx.refs.record_reference_to([:lvar, :other])
-    mctx.record_call_to(s(:send, s(:self), :thing))
-    expect(mctx.envious_receivers).to be_empty
-  end
+  describe '#envious_receivers' do
+    it 'should ignore ivars as refs to self' do
+      mc.record_call_to s(:send, s(:ivar, :@cow), :feed_to)
+      expect(mc.envious_receivers).to be_empty
+    end
+
+    it 'should ignore explicit calls to self' do
+      mc.refs.record_reference_to [:lvar, :other]
+      mc.record_call_to s(:send, s(:self), :thing)
+      expect(mc.envious_receivers).to be_empty
+    end
+
+    it 'should ignore implicit calls to self' do
+      mc.record_call_to s(:send, s(:lvar, :text), :each, s(:arglist))
+      mc.record_call_to s(:send, nil, :shelve, s(:arglist))
+      expect(mc.envious_receivers).to be_empty
+    end
 
-  it 'should recognise a call on self' do
-    mc = MethodContext.new(StopContext.new, s(:def, :deep, s(:args), nil))
-    mc.record_call_to(s(:send, s(:lvar, :text), :each, s(:arglist)))
-    mc.record_call_to(s(:send, nil, :shelve, s(:arglist)))
-    expect(mc.envious_receivers).to be_empty
+    it 'should record envious calls' do
+      mc.record_call_to s(:send, s(:lvar, :bar), :baz)
+      expect(mc.envious_receivers).to eq(bar: 1)
+    end
   end
 end
 
-describe MethodParameters, 'default assignments' do
+RSpec.describe Reek::Context::MethodParameters, 'default assignments' do
   def assignments_from(src)
-    exp = src.to_reek_source.syntax_tree
-    ctx = MethodContext.new(StopContext.new, exp)
+    exp = Reek::Source::SourceCode.from(src).syntax_tree
+    ctx = Reek::Context::MethodContext.new(Reek::Context::RootContext.new, exp)
     ctx.parameters.default_assignments
   end
 

data/spec/reek/{core → context}/module_context_spec.rb

@@ -1,10 +1,8 @@
-require 'spec_helper'
-require 'reek/core/module_context'
-require 'reek/core/stop_context'
+require_relative '../../spec_helper'
+require_relative '../../../lib/reek/context/module_context'
+require_relative '../../../lib/reek/context/root_context'
 
-include Reek::Core
-
-describe ModuleContext do
+RSpec.describe Reek::Context::ModuleContext do
   it 'should report module name for smell in method' do
     expect('
       module Fred
@@ -21,7 +19,7 @@ module Fred
   end
 end
 
-describe ModuleContext do
+RSpec.describe Reek::Context::ModuleContext do
   it 'should recognise global constant' do
     expect('# module for test
 module ::Global

data/spec/reek/context/root_context_spec.rb

@@ -0,0 +1,14 @@
+require_relative '../../spec_helper'
+require_relative '../../../lib/reek/context/root_context'
+
+RSpec.describe Reek::Context::RootContext do
+  before :each do
+    @root = Reek::Context::RootContext.new
+  end
+
+  context 'full_name' do
+    it 'reports full context' do
+      expect(@root.full_name).to eq('')
+    end
+  end
+end

data/spec/reek/context/singleton_method_context_spec.rb

@@ -0,0 +1,17 @@
+require_relative '../../spec_helper'
+require_relative '../../../lib/reek/context/singleton_method_context'
+require_relative '../../../lib/reek/context/root_context'
+
+RSpec.describe Reek::Context::SingletonMethodContext do
+  let(:smc) do
+    sexp = s(:def, :foo, s(:args, s(:arg, :bar)), nil)
+    Reek::Context::SingletonMethodContext.new(Reek::Context::RootContext.new, sexp)
+  end
+
+  describe '#envious_receivers' do
+    it 'should not record envious calls' do
+      smc.record_call_to s(:send, s(:lvar, :bar), :baz)
+      expect(smc.envious_receivers).to be_empty
+    end
+  end
+end