reek 6.0.2 → 6.1.4

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

data/spec/reek/context/method_context_spec.rb

@@ -1,72 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/context/method_context'
-
-RSpec.describe Reek::Context::MethodContext do
-  let(:method_context) { described_class.new(exp, nil) }
-
-  describe '#matches?' do
-    let(:exp) { instance_double('Reek::AST::SexpExtensions::ModuleNode').as_null_object }
-
-    before do
-      allow(exp).to receive(:full_name).at_least(:once).and_return('mod')
-    end
-
-    it 'recognises itself in a collection of names' do
-      expect(method_context.matches?(['banana', 'mod'])).to eq(true)
-    end
-
-    it 'does not recognise itself in a collection of names that does not include it' do
-      expect(method_context.matches?(['banana'])).to eq(false)
-    end
-
-    it 'recognises itself in a collection of regular expressions' do
-      expect(method_context.matches?([/banana/, /mod/])).to eq(true)
-    end
-
-    it 'does not recognise itself in a collection of regular expressions that do not match it' do
-      expect(method_context.matches?([/banana/])).to eq(false)
-    end
-  end
-
-  describe '#default_assignments' do
-    def assignments_from(src)
-      exp = Reek::Source::SourceCode.from(src).syntax_tree
-      ctx = Reek::Context::MethodContext.new(exp, nil)
-      ctx.default_assignments
-    end
-
-    context 'with no defaults' do
-      it 'returns an empty hash' do
-        src = 'def meth(arga, argb, &blk) end'
-        expect(assignments_from(src)).to be_empty
-      end
-    end
-
-    context 'with 1 default' do
-      let(:defaults) { assignments_from('def meth(arga, argb=456, &blk) end') }
-
-      it 'returns the param-value pair' do
-        expect(defaults[0]).to eq [:argb, sexp(:int, 456)]
-      end
-
-      it 'returns the nothing else' do
-        expect(defaults.length).to eq(1)
-      end
-    end
-
-    context 'with 2 defaults' do
-      let(:defaults) do
-        assignments_from('def meth(arga=123, argb=456, &blk) end')
-      end
-
-      it 'returns both param-value pairs' do
-        expect(defaults).to eq [[:arga, sexp(:int, 123)],
-                                [:argb, sexp(:int, 456)]]
-      end
-
-      it 'returns nothing else' do
-        expect(defaults.length).to eq(2)
-      end
-    end
-  end
-end

data/spec/reek/context/module_context_spec.rb

@@ -1,55 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/context/module_context'
-require_lib 'reek/context/root_context'
-
-RSpec.describe Reek::Context::ModuleContext do
-  it 'reports module name for smell in method' do
-    expect('
-      module Fred
-        def simple(x) x + 1; end
-      end
-    ').to reek_of(:UncommunicativeParameterName, name: 'x', context: 'Fred#simple')
-  end
-
-  it 'does not report module with empty class' do
-    expect('
-      # module for test
-      module Fred
-        # module for test
-        class Jim; end; end').not_to reek
-  end
-
-  it 'recognises global constant' do
-    expect('
-      # module for test
-      module ::Global
-        # module for test
-        class Inside; end; end').not_to reek
-  end
-
-  describe '#track_visibility' do
-    let(:main_exp) { instance_double('Reek::AST::Node') }
-    let(:first_def) { instance_double('Reek::AST::SexpExtensions::DefNode', name: :foo) }
-    let(:second_def) { instance_double('Reek::AST::SexpExtensions::DefNode') }
-
-    let(:context) { described_class.new(main_exp) }
-    let(:first_child) { Reek::Context::MethodContext.new(first_def, main_exp) }
-    let(:second_child) { Reek::Context::MethodContext.new(second_def, main_exp) }
-
-    it 'sets visibility on subsequent child contexts' do
-      context.append_child_context first_child
-      context.track_visibility :private, []
-      context.append_child_context second_child
-      expect(first_child.visibility).to eq :public
-      expect(second_child.visibility).to eq :private
-    end
-
-    it 'sets visibility on specifically mentioned child contexts' do
-      context.append_child_context first_child
-      context.track_visibility :private, [first_child.name]
-      context.append_child_context second_child
-      expect(first_child.visibility).to eq :private
-      expect(second_child.visibility).to eq :public
-    end
-  end
-end

data/spec/reek/context/root_context_spec.rb

@@ -1,12 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/context/root_context'
-
-RSpec.describe Reek::Context::RootContext do
-  describe '#full_name' do
-    it 'reports full context' do
-      ast = Reek::Source::SourceCode.from('foo = 1').syntax_tree
-      root = described_class.new(ast)
-      expect(root.full_name).to eq('')
-    end
-  end
-end

data/spec/reek/context/statement_counter_spec.rb

@@ -1,24 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/context/statement_counter'
-
-RSpec.describe Reek::Context::StatementCounter do
-  let(:counter) { described_class.new }
-
-  describe '#increase_by' do
-    it 'does not increase if passed a falsy value' do
-      counter.increase_by(nil)
-      expect(counter.value).to eq 0
-    end
-
-    it 'increase by the lengh of the passed in argument' do
-      counter.increase_by([1, 2, 3])
-      expect(counter.value).to eq 3
-    end
-
-    it 'accumulates increases' do
-      counter.increase_by([1, 2, 3])
-      counter.increase_by([1, 2, 3])
-      expect(counter.value).to eq 6
-    end
-  end
-end