reek 6.0.1 → 6.0.5

data/spec/reek/configuration/excluded_paths_spec.rb

@@ -1,16 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/errors/config_file_error'
-require_lib 'reek/configuration/excluded_paths'
-
-RSpec.describe Reek::Configuration::ExcludedPaths do
-  describe '#add' do
-    let(:exclusions) { [].extend(described_class) }
-    let(:paths) { ['smelly/sources'] }
-    let(:expected_exclude_paths) { [Pathname('smelly/sources')] }
-
-    it 'adds the given paths as Pathname' do
-      exclusions.add(paths)
-      expect(exclusions).to eq expected_exclude_paths
-    end
-  end
-end

data/spec/reek/configuration/rake_task_converter_spec.rb

@@ -1,33 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/configuration/rake_task_converter'
-
-RSpec.describe Reek::Configuration::RakeTaskConverter do
-  describe 'convert' do
-    let(:configuration_for_smell_detector) do
-      {
-        'exclude' => [/Klass#foobar$/, /^Klass#omg$/],
-        'reject'  => [/^[a-z]$/, /[0-9]$/, /[A-Z]/],
-        'accept'  => [/^_$/]
-      }
-    end
-
-    let(:expected_exclude) { ['/Klass#foobar$/', '/^Klass#omg$/'] }
-    let(:expected_reject) { ['/^[a-z]$/', '/[0-9]$/', '/[A-Z]/'] }
-    let(:expected_accept) { ['/^_$/'] }
-
-    it 'converts exclude regexes to strings' do
-      converted_configuration = described_class.convert configuration_for_smell_detector
-      expect(converted_configuration['exclude']).to eq(expected_exclude)
-    end
-
-    it 'converts reject regexes to strings' do
-      converted_configuration = described_class.convert configuration_for_smell_detector
-      expect(converted_configuration['reject']).to eq(expected_reject)
-    end
-
-    it 'converts accept regexes to strings' do
-      converted_configuration = described_class.convert configuration_for_smell_detector
-      expect(converted_configuration['accept']).to eq(expected_accept)
-    end
-  end
-end

data/spec/reek/configuration/schema_validator_spec.rb

@@ -1,165 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/configuration/schema_validator'
-require_lib 'reek/errors/config_file_error'
-
-RSpec.describe Reek::Configuration::SchemaValidator do
-  describe 'validate' do
-    subject(:validator) { described_class.new configuration }
-
-    context 'when configuration is valid' do
-      let(:configuration) do
-        {
-          Reek::DETECTORS_KEY => {
-            'UncommunicativeVariableName' => { 'enabled' => false },
-            'UncommunicativeMethodName'   => { 'enabled' => false }
-          }
-        }
-      end
-
-      it 'returns nil' do
-        expect(validator.validate).to eq(nil)
-      end
-    end
-
-    context 'when detector is invalid' do
-      let(:configuration) do
-        {
-          Reek::DETECTORS_KEY => {
-            'DoesNotExist' => { 'enabled' => false }
-          }
-        }
-      end
-
-      it 'raises an error' do
-        message = %r{\[/detectors/DoesNotExist\] key 'DoesNotExist:' is undefined}
-        expect { validator.validate }.to raise_error(Reek::Errors::ConfigFileError, message)
-      end
-    end
-
-    context 'when `enabled` has a non-boolean value' do
-      let(:configuration) do
-        {
-          Reek::DETECTORS_KEY => {
-            'FeatureEnvy' => { 'enabled' => 'foo' }
-          }
-        }
-      end
-
-      it 'raises an error' do
-        message = %r{\[/detectors/FeatureEnvy/enabled\] 'foo': not a boolean}
-        expect { validator.validate }.to raise_error(Reek::Errors::ConfigFileError, message)
-      end
-    end
-
-    context 'when detector has an unknown option' do
-      let(:configuration) do
-        {
-          Reek::DETECTORS_KEY => {
-            'DataClump' => { 'does_not_exist' => 42 }
-          }
-        }
-      end
-
-      it 'raises an error' do
-        message = %r{\[/detectors/DataClump/does_not_exist\] key 'does_not_exist:' is undefined}
-        expect { validator.validate }.to raise_error(Reek::Errors::ConfigFileError, message)
-      end
-    end
-
-    context 'when `exclude`, `reject` and `accept`' do
-      %w(exclude reject accept).each do |attribute|
-        context 'when a scalar' do
-          let(:configuration) do
-            {
-              Reek::DETECTORS_KEY => {
-                'UncommunicativeMethodName' => { attribute => 42 }
-              }
-            }
-          end
-
-          it 'raises an error' do
-            message = %r{\[/detectors/UncommunicativeMethodName/#{attribute}\] '42': not a sequence}
-            expect { validator.validate }.to raise_error(Reek::Errors::ConfigFileError, message)
-          end
-        end
-
-        context 'when types are mixed' do
-          let(:configuration) do
-            {
-              Reek::DETECTORS_KEY => {
-                'UncommunicativeMethodName' => { attribute => [42, 'foo'] }
-              }
-            }
-          end
-
-          it 'raises an error' do
-            message = %r{\[/detectors/UncommunicativeMethodName/#{attribute}/0\] '42': not a string}
-            expect { validator.validate }.to raise_error(Reek::Errors::ConfigFileError, message)
-          end
-        end
-      end
-    end
-
-    context 'when `exclude_paths` is a scalar' do
-      let(:configuration) do
-        {
-          Reek::EXCLUDE_PATHS_KEY => 42
-        }
-      end
-
-      it 'raises an error' do
-        message = %r{\[/exclude_paths\] '42': not a sequence}
-        expect { validator.validate }.to raise_error(Reek::Errors::ConfigFileError, message)
-      end
-    end
-
-    context 'when `exclude_paths` mixes types' do
-      let(:configuration) do
-        {
-          Reek::EXCLUDE_PATHS_KEY => [42, 'foo']
-        }
-      end
-
-      it 'raises an error' do
-        message = %r{\[/exclude_paths/0\] '42': not a string}
-        expect { validator.validate }.to raise_error(Reek::Errors::ConfigFileError, message)
-      end
-    end
-
-    context 'with directory directives' do
-      context 'when bad detector' do
-        let(:configuration) do
-          {
-            Reek::DIRECTORIES_KEY => {
-              'web_app/app/helpers' => {
-                'Bar' => { 'enabled' => false }
-              }
-            }
-          }
-        end
-
-        it 'raises an error' do
-          message = %r{\[/directories/web_app/app/helpers/Bar\] key 'Bar:' is undefined}
-          expect { validator.validate }.to raise_error(Reek::Errors::ConfigFileError, message)
-        end
-      end
-
-      context 'when unknown attribute' do
-        let(:configuration) do
-          {
-            Reek::DIRECTORIES_KEY => {
-              'web_app/app/controllers' => {
-                'NestedIterators' => { 'foo' => false }
-              }
-            }
-          }
-        end
-
-        it 'raises an error' do
-          message = %r{\[/directories/web_app/app/controllers/NestedIterators/foo\] key 'foo:' is undefined}
-          expect { validator.validate }.to raise_error(Reek::Errors::ConfigFileError, message)
-        end
-      end
-    end
-  end
-end

data/spec/reek/context/code_context_spec.rb

@@ -1,192 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/context/method_context'
-require_lib 'reek/context/module_context'
-
-RSpec.describe Reek::Context::CodeContext do
-  describe '#full_name' do
-    let(:ctx)       { described_class.new(exp) }
-    let(:exp)       { instance_double('Reek::AST::SexpExtensions::ModuleNode') }
-    let(:exp_name)  { 'random_name' }
-    let(:full_name) { "::::::::::::::::::::#{exp_name}" }
-
-    before do
-      allow(exp).to receive(:name).and_return(exp_name)
-      allow(exp).to receive(:full_name).and_return(full_name)
-    end
-
-    it 'creates the correct full name' do
-      expect(ctx.full_name).to eq(full_name)
-    end
-
-    context 'when there is an outer' do
-      let(:outer_name) { 'another_random sting' }
-      let(:outer)      { described_class.new(instance_double('Reek::AST::Node')) }
-
-      before do
-        ctx.register_with_parent outer
-        allow(outer).to receive(:full_name).at_least(:once).and_return(outer_name)
-      end
-
-      it 'creates the correct full name' do
-        expect(ctx.full_name).to eq(full_name)
-      end
-
-      it 'passes the outer name to exp#full_name' do
-        ctx.full_name
-        expect(exp).to have_received(:full_name).with outer_name
-      end
-    end
-  end
-
-  describe '#name' do
-    let(:ctx)       { described_class.new(exp) }
-    let(:exp)       { instance_double('Reek::AST::SexpExtensions::ModuleNode') }
-    let(:exp_name)  { 'random_name' }
-
-    before do
-      allow(exp).to receive(:name).and_return(exp_name)
-    end
-
-    it 'gets its short name from the exp' do
-      expect(ctx.name).to eq(exp_name)
-    end
-  end
-
-  describe '#matches?' do
-    let(:ctx)       { described_class.new(exp) }
-    let(:exp)       { instance_double('Reek::AST::SexpExtensions::ModuleNode') }
-    let(:exp_name)  { 'random_name' }
-    let(:full_name) { "::::::::::::::::::::#{exp_name}" }
-
-    before do
-      allow(exp).to receive(:name).and_return(exp_name)
-      allow(exp).to receive(:full_name).and_return(full_name)
-    end
-
-    it 'does not match an empty list' do
-      expect(ctx.matches?([])).to eq(false)
-    end
-
-    it 'does not match when its own short name is not given' do
-      expect(ctx.matches?(['banana'])).to eq(false)
-    end
-
-    it 'does not let pipe-ended Strings make matching ignore the rest' do
-      expect(ctx.matches?(['banana|'])).to eq(false)
-    end
-
-    it 'recognises its own short name' do
-      expect(ctx.matches?([exp_name])).to eq(true)
-    end
-
-    it 'recognises its own short name in a list' do
-      expect(ctx.matches?(['banana', exp_name])).to eq(true)
-    end
-
-    it 'recognises its short name as a regex' do
-      expect(ctx.matches?([/#{exp_name}/])).to eq(true)
-    end
-
-    it 'does not blow up on []-ended Strings' do
-      expect(ctx.matches?(['banana[]', exp_name])).to eq(true)
-    end
-
-    it 'recognises its own full name' do
-      expect(ctx.matches?(['banana', full_name])).to eq(true)
-    end
-
-    it 'recognises its full name as a regex' do
-      expect(ctx.matches?([/banana/, /#{full_name}/])).to eq(true)
-    end
-
-    context 'when there is an outer' do
-      let(:outer_name) { 'another_random sting' }
-      let(:outer)      { described_class.new(instance_double('Reek::AST::Node')) }
-
-      before do
-        ctx.register_with_parent outer
-        allow(outer).to receive(:full_name).at_least(:once).and_return(outer_name)
-      end
-
-      it 'recognises its own full name' do
-        expect(ctx.matches?(['banana', full_name])).to eq(true)
-      end
-
-      it 'recognises its full name as a regex' do
-        expect(ctx.matches?([/banana/, /#{full_name}/])).to eq(true)
-      end
-    end
-  end
-
-  describe '#config_for' do
-    let(:src) do
-      <<-RUBY
-        # :reek:DuplicateMethodCall { allow_calls: [ puts ] }')
-        def repeated_greeting
-          puts 'Hello!'
-          puts 'Hello!'
-        end
-      RUBY
-    end
-    let(:expression) { Reek::Source::SourceCode.from(src).syntax_tree }
-    let(:outer) { nil }
-    let(:context) { described_class.new(expression) }
-    let(:sniffer) { class_double('Reek::SmellDetectors::BaseDetector') }
-
-    before do
-      context.register_with_parent(outer)
-      allow(sniffer).to receive(:smell_type).and_return('DuplicateMethodCall')
-    end
-
-    context 'when there is no outer context' do
-      it 'gets its configuration from the expression comments' do
-        expect(context.config_for(sniffer)).to eq('allow_calls' => ['puts'])
-      end
-    end
-
-    context 'when there is an outer context' do
-      let(:outer) { described_class.new(instance_double('Reek::AST::Node')) }
-
-      before do
-        allow(outer).to receive(:config_for).with(sniffer).and_return(
-          'max_calls' => 2)
-      end
-
-      it 'merges the outer config with its own configuration' do
-        expect(context.config_for(sniffer)).to eq('allow_calls' => ['puts'],
-                                                  'max_calls' => 2)
-      end
-    end
-  end
-
-  describe '#register_with_parent' do
-    let(:context) { described_class.new(instance_double('Reek::AST::Node')) }
-    let(:first_child) { described_class.new(instance_double('Reek::AST::Node')) }
-    let(:second_child) { described_class.new(instance_double('Reek::AST::Node')) }
-
-    it "appends the element to the parent context's list of children" do
-      first_child.register_with_parent context
-      second_child.register_with_parent context
-
-      expect(context.children).to eq [first_child, second_child]
-    end
-  end
-
-  describe '#each' do
-    let(:context) { described_class.new(instance_double('Reek::AST::Node')) }
-    let(:first_child) { described_class.new(instance_double('Reek::AST::Node')) }
-    let(:second_child) { described_class.new(instance_double('Reek::AST::Node')) }
-
-    it 'yields each child' do
-      first_child.register_with_parent context
-      second_child.register_with_parent context
-
-      result = []
-      context.each do |ctx|
-        result << ctx
-      end
-
-      expect(result).to eq [context, first_child, second_child]
-    end
-  end
-end

data/spec/reek/context/ghost_context_spec.rb

@@ -1,60 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/context/code_context'
-require_lib 'reek/context/ghost_context'
-
-RSpec.describe Reek::Context::GhostContext do
-  let(:exp) { instance_double('Reek::AST::Node') }
-  let(:parent) { Reek::Context::CodeContext.new(exp) }
-
-  describe '#register_with_parent' do
-    it 'does not append itself to its parent' do
-      ghost = described_class.new(nil)
-      ghost.register_with_parent(parent)
-      expect(parent.children).not_to include ghost
-    end
-  end
-
-  describe '#append_child_context' do
-    let(:ghost) { described_class.new(nil) }
-
-    before do
-      ghost.register_with_parent(parent)
-    end
-
-    it 'appends the child to the grandparent context' do
-      child = Reek::Context::CodeContext.new(sexp(:foo))
-      child.register_with_parent(ghost)
-
-      expect(parent.children).to include child
-    end
-
-    it "sets the child's parent to the grandparent context" do
-      child = Reek::Context::CodeContext.new(sexp(:foo))
-      child.register_with_parent(ghost)
-
-      expect(child.parent).to eq parent
-    end
-
-    it 'appends the child to the list of children' do
-      child = Reek::Context::CodeContext.new(sexp(:foo))
-      child.register_with_parent(ghost)
-
-      expect(ghost.children).to include child
-    end
-
-    context 'when the grandparent is also a ghost' do
-      let(:child_ghost) { described_class.new(nil) }
-
-      before do
-        child_ghost.register_with_parent(ghost)
-      end
-
-      it 'sets the childs parent to its remote ancestor' do
-        child = Reek::Context::CodeContext.new(sexp(:foo))
-        child.register_with_parent(child_ghost)
-
-        expect(child.parent).to eq parent
-      end
-    end
-  end
-end