reek 6.0.1 → 6.0.5

data/spec/quality/reek_source_spec.rb

@@ -1,11 +0,0 @@
-require_relative '../spec_helper'
-
-RSpec.describe 'Reek source code' do
-  Pathname.glob('lib/**/*.rb').each do |pathname|
-    describe pathname do
-      it 'has no smells' do
-        expect(pathname).not_to reek
-      end
-    end
-  end
-end

data/spec/reek/ast/node_spec.rb

@@ -1,211 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/ast/node'
-
-RSpec.describe Reek::AST::Node do
-  describe '#each_node' do
-    context 'with an empty module' do
-      let(:ast) do
-        src = 'module Emptiness; end'
-        Reek::Source::SourceCode.from(src).syntax_tree
-      end
-
-      it 'yields no calls' do
-        ast.each_node(:send, []) { |exp| raise "#{exp} yielded by empty module!" }
-      end
-
-      it 'yields one module' do
-        mods = 0
-        ast.each_node(:module, []) { |_exp| mods += 1 }
-        expect(mods).to eq(1)
-      end
-
-      it "yields the module's full AST" do
-        ast.each_node(:module, []) do |exp|
-          expect(exp).to eq(sexp(:module, sexp(:const, nil, :Emptiness), nil))
-        end
-      end
-
-      it 'returns an enumerator when no block is passed' do
-        expect(ast.each_node(:if)).to be_instance_of Enumerator
-      end
-    end
-
-    context 'with a nested element' do
-      let(:ast) do
-        src = "module Loneliness; def calloo; puts('hello') end; end"
-        Reek::Source::SourceCode.from(src).syntax_tree
-      end
-
-      it 'yields no ifs' do
-        ast.each_node(:if) { |exp| raise "#{exp} yielded by empty module!" }
-      end
-
-      it 'yields one module' do
-        expect(ast.each_node(:module).to_a.length).to eq(1)
-      end
-
-      it "yields the module's full AST" do
-        ast.each_node(:module) do |exp|
-          expect(exp).to eq sexp(:module,
-                                 sexp(:const, nil, :Loneliness),
-                                 sexp(:def, :calloo,
-                                      sexp(:args),
-                                      sexp(:send, nil, :puts, sexp(:str, 'hello'))))
-        end
-      end
-
-      it 'yields one method' do
-        expect(ast.each_node(:def).to_a.length).to eq(1)
-      end
-
-      it "yields the method's full AST" do
-        ast.each_node(:def, []) { |exp| expect(exp.children.first).to eq(:calloo) }
-      end
-
-      it 'ignores the call inside the method if the traversal is pruned' do
-        expect(ast.each_node(:send, [:def]).to_a).to be_empty
-      end
-    end
-
-    it 'finds 3 ifs in a class' do
-      src = <<-RUBY
-        class Scrunch
-          def first
-            return @field == :sym ? 0 : 3;
-          end
-          def second
-            if @field == :sym
-              @other += " quarts"
-            end
-          end
-          def third
-            raise 'flu!' unless @field == :sym
-          end
-        end
-      RUBY
-      ast = Reek::Source::SourceCode.from(src).syntax_tree
-      expect(ast.each_node(:if).to_a.length).to eq(3)
-    end
-  end
-
-  describe '#format_to_ruby' do
-    it 'returns #to_s if location is not present' do
-      ast = sexp(:self)
-      expect(ast.format_to_ruby).to eq ast.to_s
-    end
-
-    it 'gives the right result for self' do
-      ast = Reek::Source::SourceCode.from('self').syntax_tree
-      expect(ast.format_to_ruby).to eq 'self'
-    end
-
-    it 'gives the right result for a simple expression' do
-      ast = Reek::Source::SourceCode.from('foo').syntax_tree
-      expect(ast.format_to_ruby).to eq 'foo'
-    end
-
-    it 'gives the right result for a more complex expression' do
-      ast = Reek::Source::SourceCode.from('foo(bar)').syntax_tree
-      result = ast.format_to_ruby
-      expect(result).to eq 'foo(bar)'
-    end
-
-    it 'gives te right result for send with a receiver' do
-      ast = Reek::Source::SourceCode.from('baz.foo(bar)').syntax_tree
-      expect(ast.format_to_ruby).to eq 'baz.foo(bar)'
-    end
-
-    it 'gives the right result for if' do
-      source = <<-SRC
-        if foo
-          bar
-        else
-          baz
-          qux
-        end
-      SRC
-
-      ast = Reek::Source::SourceCode.from(source).syntax_tree
-      expect(ast.format_to_ruby).to eq 'if foo ... end'
-    end
-
-    it 'gives the right result for def with no body' do
-      source = "def my_method\nend"
-      ast = Reek::Source::SourceCode.from(source).syntax_tree
-      expect(ast.format_to_ruby).to eq 'def my_method; end'
-    end
-
-    it 'gives the right result for ivar' do
-      source = '@foo'
-      ast = Reek::Source::SourceCode.from(source).syntax_tree
-      expect(ast.format_to_ruby).to eq '@foo'
-    end
-  end
-
-  describe '#hash' do
-    it 'hashes equal for equal sexps' do
-      node1 = sexp(:def, :jim, sexp(:args), sexp(:send, sexp(:int, 4), :+, sexp(:send, nil, :fred)))
-      node2 = sexp(:def, :jim, sexp(:args), sexp(:send, sexp(:int, 4), :+, sexp(:send, nil, :fred)))
-      expect(node1.hash).to eq(node2.hash)
-    end
-
-    it 'hashes diferent for diferent sexps' do
-      node1 = sexp(:def, :jim, sexp(:args), sexp(:send, sexp(:int, 4), :+, sexp(:send, nil, :fred)))
-      node2 = sexp(:def, :jim, sexp(:args), sexp(:send, sexp(:int, 3), :+, sexp(:send, nil, :fred)))
-      expect(node1.hash).not_to eq(node2.hash)
-    end
-  end
-
-  describe '#length' do
-    it 'counts itself as representing one statement' do
-      expect(sexp(:foo).length).to eq 1
-    end
-  end
-
-  describe '#line' do
-    context 'with source from a file' do
-      let(:file) { SMELLY_FILE }
-      let(:ast) { Reek::Source::SourceCode.from(file).syntax_tree }
-
-      it 'returns the right line number' do
-        expect(ast.line).to eq(2)
-      end
-    end
-
-    context 'with source from a string' do
-      let(:source) { File.read(SMELLY_FILE) }
-      let(:ast) { Reek::Source::SourceCode.from(source).syntax_tree }
-
-      it 'returns the right line number' do
-        expect(ast.line).to eq(2)
-      end
-    end
-  end
-
-  describe '#source' do
-    context 'with source from a file' do
-      let(:file) { SMELLY_FILE }
-      let(:ast) { Reek::Source::SourceCode.from(file).syntax_tree }
-
-      it 'returns the file name' do
-        expect(ast.source).to eq(SMELLY_FILE.to_s)
-      end
-    end
-
-    context 'with source from a string' do
-      let(:source) { File.read SMELLY_FILE }
-      let(:ast) { Reek::Source::SourceCode.from(source).syntax_tree }
-
-      it 'returns "string"' do
-        expect(ast.source).to eq('string')
-      end
-    end
-  end
-
-  describe '#name' do
-    it 'returns #to_s if no override is present' do
-      ast = sexp(:foo)
-      expect(ast.name).to eq ast.to_s
-    end
-  end
-end

data/spec/reek/ast/object_refs_spec.rb

@@ -1,83 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/ast/object_refs'
-
-RSpec.describe Reek::AST::ObjectRefs do
-  let(:refs) { described_class.new }
-
-  context 'when empty' do
-    it 'reports no refs to self' do
-      expect(refs.references_to(:self)).to be_empty
-    end
-  end
-
-  context 'with many refs to self' do
-    before do
-      refs.record_reference(name: :self)
-      refs.record_reference(name: :self)
-      refs.record_reference(name: :a)
-      refs.record_reference(name: :self)
-      refs.record_reference(name: :b)
-      refs.record_reference(name: :a)
-      refs.record_reference(name: :self)
-    end
-
-    it 'reports all refs to self' do
-      expect(refs.references_to(:self).size).to eq(4)
-    end
-
-    it 'reports self among the max' do
-      expect(refs.most_popular).to include(:self)
-    end
-
-    it 'reports self as the max' do
-      expect(refs.self_is_max?).to eq(true)
-    end
-  end
-
-  context 'when self is not the only max' do
-    before do
-      refs.record_reference(name: :a)
-      refs.record_reference(name: :self)
-      refs.record_reference(name: :self)
-      refs.record_reference(name: :b)
-      refs.record_reference(name: :a)
-    end
-
-    it 'reports all refs to self' do
-      expect(refs.references_to(:self).size).to eq(2)
-    end
-
-    it 'reports self among the max' do
-      expect(refs.most_popular).to include(:self)
-    end
-
-    it 'reports the other max among the max' do
-      expect(refs.most_popular).to include(:a)
-    end
-
-    it 'reports self as the max' do
-      expect(refs.self_is_max?).to eq(true)
-    end
-  end
-
-  context 'when self is not recorded' do
-    before do
-      refs.record_reference(name: :a)
-      refs.record_reference(name: :b)
-      refs.record_reference(name: :a)
-      refs.record_reference(name: :b)
-    end
-
-    it 'reports no refs to self' do
-      expect(refs.references_to(:self).size).to eq(0)
-    end
-
-    it 'does not report self among the max' do
-      expect(refs.most_popular).not_to include(:self)
-    end
-
-    it 'does not report self as the max' do
-      expect(refs.self_is_max?).to eq(false)
-    end
-  end
-end

data/spec/reek/ast/reference_collector_spec.rb

@@ -1,47 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/ast/reference_collector'
-
-RSpec.describe Reek::AST::ReferenceCollector do
-  describe '#num_refs_to_self' do
-    def refs_to_self(src)
-      syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
-      described_class.new(syntax_tree).num_refs_to_self
-    end
-
-    it 'with no refs to self' do
-      expect(refs_to_self('def no_envy(arga) arga.barg end')).to eq(0)
-    end
-
-    it 'counts a call to super' do
-      expect(refs_to_self('def simple() super; end')).to eq(1)
-    end
-
-    it 'counts a call to super with arguments' do
-      expect(refs_to_self('def simple() super(); end')).to eq(1)
-    end
-
-    it 'counts a local call' do
-      expect(refs_to_self('def simple() to_s; end')).to eq(1)
-    end
-
-    it 'counts a use of self' do
-      expect(refs_to_self('def simple() lv = self; end')).to eq(1)
-    end
-
-    it 'counts a call with self as receiver' do
-      expect(refs_to_self('def simple() self.to_s; end')).to eq(1)
-    end
-
-    it 'counts uses of an ivar' do
-      expect(refs_to_self('def no_envy() @item.to_a; @item = 4; @item end')).to eq(3)
-    end
-
-    it 'counts an ivar passed to a method' do
-      expect(refs_to_self('def no_envy(arga) arga.barg(@item); arga end')).to eq(1)
-    end
-
-    it 'ignores global variables' do
-      expect(refs_to_self('def no_envy(arga) $s2.to_a; $s2[arga] end')).to eq(0)
-    end
-  end
-end

data/spec/reek/ast/sexp_extensions_spec.rb

@@ -1,498 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/ast/sexp_extensions'
-
-RSpec.describe Reek::AST::SexpExtensions::DefNode do
-  context 'with no parameters' do
-    let(:node) { sexp(:def, :hello, sexp(:args)) }
-
-    it 'has no arg names' do
-      expect(node.arg_names).to eq []
-    end
-
-    it 'has no parameter names' do
-      expect(node.parameter_names).to eq []
-    end
-
-    it 'includes outer scope in its full name' do
-      expect(node.full_name('Fred')).to eq 'Fred#hello'
-    end
-
-    it 'includes no marker in its full name with empty outer scope' do
-      expect(node.full_name('')).to eq 'hello'
-    end
-  end
-
-  context 'with 1 parameter' do
-    let(:node) do
-      sexp(:def, :hello,
-           sexp(:args, sexp(:arg, :parameter)))
-    end
-
-    it 'has 1 arg name' do
-      expect(node.arg_names).to eq [:parameter]
-    end
-
-    it 'has 1 parameter name' do
-      expect(node.parameter_names).to eq [:parameter]
-    end
-
-    it 'includes outer scope in its full name' do
-      expect(node.full_name('Fred')).to eq 'Fred#hello'
-    end
-
-    it 'includes no marker in its full name with empty outer scope' do
-      expect(node.full_name('')).to eq 'hello'
-    end
-  end
-
-  context 'with a block parameter' do
-    let(:node) do
-      sexp(:def, :hello,
-           sexp(:args,
-                sexp(:arg, :parameter),
-                sexp(:blockarg, :blk)))
-    end
-
-    it 'has 1 arg name' do
-      expect(node.arg_names).to eq [:parameter]
-    end
-
-    it 'has 2 parameter names' do
-      expect(node.parameter_names).to eq [:parameter, :blk]
-    end
-
-    it 'includes outer scope in its full name' do
-      expect(node.full_name('Fred')).to eq 'Fred#hello'
-    end
-
-    it 'includes no marker in its full name with empty outer scope' do
-      expect(node.full_name('')).to eq 'hello'
-    end
-  end
-
-  context 'with 1 defaulted parameter' do
-    let(:node) do
-      sexp(:def, :hello,
-           sexp(:args,
-                sexp(:optarg, :parameter, sexp(:array))))
-    end
-
-    it 'has 1 arg name' do
-      expect(node.arg_names).to eq [:parameter]
-    end
-
-    it 'has 1 parameter name' do
-      expect(node.parameter_names).to eq [:parameter]
-    end
-
-    it 'includes outer scope in its full name' do
-      expect(node.full_name('Fred')).to eq 'Fred#hello'
-    end
-
-    it 'includes no marker in its full name with empty outer scope' do
-      expect(node.full_name('')).to eq 'hello'
-    end
-  end
-
-  context 'with a body with 2 statements' do
-    let(:node) do
-      sexp(:def, :hello, sexp(:args),
-           sexp(:begin,
-                sexp(:first),
-                sexp(:second)))
-    end
-
-    it 'has 2 body statements' do
-      expect(node.body).to eq sexp(:begin, sexp(:first), sexp(:second))
-    end
-
-    it 'finds nodes in the body with #body_nodes' do
-      expect(node.body_nodes([:first]).to_a).to eq [sexp(:first)]
-    end
-  end
-
-  context 'with no body' do
-    let(:node) { sexp(:def, :hello, sexp(:args), nil) }
-
-    it 'has a body that is nil' do
-      expect(node.body).to be_nil
-    end
-
-    it 'finds no nodes in the body' do
-      expect(node.body_nodes([:foo])).to eq []
-    end
-  end
-end
-
-RSpec.describe Reek::AST::SexpExtensions::CSendNode do
-  let(:node) { Reek::Source::SourceCode.from('1&.foo(true)').syntax_tree }
-
-  it 'has a class including SendNode' do
-    expect(node.class.included_modules).to include(Reek::AST::SexpExtensions::SendNode)
-  end
-
-  it 'has a receiver' do
-    expect(node.receiver).to eq(sexp(:int, 1))
-  end
-
-  it 'has a name' do
-    expect(node.name).to eq(:foo)
-  end
-
-  it 'has arguments' do
-    expect(node.args).to eq([sexp(:true)])
-  end
-end
-
-RSpec.describe Reek::AST::SexpExtensions::DefsNode do
-  context 'with no parameters' do
-    let(:node) { sexp(:defs, sexp(:lvar, :obj), :hello, sexp(:args)) }
-
-    it 'has no arg names' do
-      expect(node.arg_names).to eq []
-    end
-
-    it 'has no parameter names' do
-      expect(node.parameter_names).to eq []
-    end
-
-    it 'includes outer scope in its full name' do
-      expect(node.full_name('Fred')).to eq 'Fred#obj.hello'
-    end
-
-    it 'includes no marker in its full name with empty outer scope' do
-      expect(node.full_name('')).to eq 'obj.hello'
-    end
-  end
-
-  context 'with 1 parameter' do
-    let(:node) do
-      sexp(:defs, sexp(:lvar, :obj), :hello,
-           sexp(:args, sexp(:arg, :parameter)))
-    end
-
-    it 'has 1 arg name' do
-      expect(node.arg_names).to eq [:parameter]
-    end
-
-    it 'has 1 parameter name' do
-      expect(node.parameter_names).to eq [:parameter]
-    end
-
-    it 'includes outer scope in its full name' do
-      expect(node.full_name('Fred')).to eq 'Fred#obj.hello'
-    end
-
-    it 'includes no marker in its full name with empty outer scope' do
-      expect(node.full_name('')).to eq 'obj.hello'
-    end
-  end
-
-  context 'with a block' do
-    let(:node) do
-      sexp(:defs, sexp(:lvar, :obj), :hello,
-           sexp(:args,
-                sexp(:arg, :parameter),
-                sexp(:blockarg, :blk)))
-    end
-
-    it 'has 1 arg name' do
-      expect(node.arg_names).to eq [:parameter]
-    end
-
-    it 'has 2 parameter names' do
-      expect(node.parameter_names).to eq [:parameter, :blk]
-    end
-
-    it 'includes outer scope in its full name' do
-      expect(node.full_name('Fred')).to eq 'Fred#obj.hello'
-    end
-
-    it 'includes no marker in its full name with empty outer scope' do
-      expect(node.full_name('')).to eq 'obj.hello'
-    end
-  end
-
-  context 'with 1 defaulted parameter' do
-    let(:node) do
-      sexp(:defs, sexp(:lvar, :obj), :hello,
-           sexp(:args,
-                sexp(:optarg, :parameter, sexp(:array))))
-    end
-
-    it 'has 1 arg name' do
-      expect(node.arg_names).to eq [:parameter]
-    end
-
-    it 'has 1 parameter name' do
-      expect(node.parameter_names).to eq [:parameter]
-    end
-
-    it 'includes outer scope in its full name' do
-      expect(node.full_name('Fred')).to eq 'Fred#obj.hello'
-    end
-
-    it 'includes no marker in its full name with empty outer scope' do
-      expect(node.full_name('')).to eq 'obj.hello'
-    end
-  end
-
-  context 'with a body with 2 statements' do
-    let(:node) do
-      sexp(:defs, sexp(:self), :hello, sexp(:args),
-           sexp(:begin,
-                sexp(:first),
-                sexp(:second)))
-    end
-
-    it 'has 2 body statements' do
-      expect(node.body).to eq sexp(:begin, sexp(:first), sexp(:second))
-    end
-  end
-end
-
-RSpec.describe Reek::AST::SexpExtensions::LvarNode do
-  let(:node) { sexp(:lvar, :foo) }
-
-  describe '#var_name' do
-    it 'returns the lvar’s name' do
-      expect(node.var_name).to eq(:foo)
-    end
-  end
-end
-
-RSpec.describe Reek::AST::SexpExtensions::ConstNode do
-  describe '#name' do
-    it 'returns the fully qualified name' do
-      node = sexp(:const, sexp(:const, sexp(:cbase), :Parser), :AST)
-
-      expect(node.name).to eq "#{sexp(:const, sexp(:cbase), :Parser)}::AST"
-    end
-
-    it 'returns only the name in case of no namespace' do
-      node = sexp(:const, nil, :AST)
-
-      expect(node.name).to eq 'AST'
-    end
-  end
-
-  describe '#simple_name' do
-    it 'returns the name' do
-      node = sexp(:const, sexp(:const, nil, :Rake), :TaskLib)
-
-      expect(node.simple_name).to eq :TaskLib
-    end
-  end
-
-  describe '#namespace' do
-    it 'returns the namespace' do
-      node = sexp(:const, :Parser, :AST)
-
-      expect(node.namespace).to eq :Parser
-    end
-
-    it 'returns nil in case of no namespace' do
-      node = sexp(:const, nil, :AST)
-
-      expect(node.namespace).to be_nil
-    end
-  end
-end
-
-RSpec.describe Reek::AST::SexpExtensions::SendNode do
-  context 'with no parameters' do
-    let(:node) { sexp(:send, nil, :hello) }
-
-    it 'is not considered to be a writable attr' do
-      expect(sexp(:send, nil, :attr)).not_to be_attr_with_writable_flag
-    end
-  end
-
-  context 'when it’s ‘new’ with no parameters and no receiver' do
-    let(:bare_new) { sexp(:send, nil, :new) }
-
-    it 'is not considered to be a module creation call' do
-      expect(bare_new).not_to be_module_creation_call
-    end
-
-    it 'is not considered to have a module creation receiver' do
-      expect(bare_new).not_to be_module_creation_receiver
-    end
-
-    it 'is considered to be an object creation call' do
-      expect(bare_new).to be_object_creation_call
-    end
-  end
-
-  context 'when it’s ‘new’ with a complex receiver' do
-    let(:node) { Reek::Source::SourceCode.from('(foo ? bar : baz).new').syntax_tree }
-
-    it 'is not considered to be a module creation call' do
-      expect(node).not_to be_module_creation_call
-    end
-
-    it 'is not considered to have a module creation receiver' do
-      expect(node).not_to be_module_creation_receiver
-    end
-
-    it 'is considered to be an object creation call' do
-      expect(node).to be_object_creation_call
-    end
-  end
-end
-
-RSpec.describe Reek::AST::SexpExtensions::BlockNode do
-  context 'with no parameters' do
-    let(:node) { sexp(:block, sexp(:send, nil, :map), sexp(:args), nil) }
-
-    it 'has no parameter names' do
-      expect(node.parameter_names).to eq []
-    end
-
-    it 'has a name' do
-      expect(node.simple_name).to eq(:block)
-    end
-  end
-
-  context 'with 1 parameter' do
-    let(:node) { sexp(:block, sexp(:send, nil, :map), sexp(:args, :parameter), nil) }
-
-    it 'has 1 parameter name' do
-      expect(node.parameter_names).to eq [:parameter]
-    end
-  end
-
-  context 'with 2 parameters' do
-    let(:node) { sexp(:block, sexp(:send, nil, :map), sexp(:args, :x, :y), nil) }
-
-    it 'has 2 parameter names' do
-      expect(node.parameter_names).to eq [:x, :y]
-    end
-  end
-end
-
-RSpec.describe Reek::AST::SexpExtensions::LambdaNode do
-  let(:node) { sexp(:lambda) }
-
-  describe '#name' do
-    it 'returns :lambda' do
-      expect(node.name).to eq 'lambda'
-    end
-  end
-end
-
-RSpec.describe Reek::AST::SexpExtensions::ModuleNode do
-  context 'with a simple name' do
-    let(:exp) do
-      Reek::Source::SourceCode.from('module Fred; end').syntax_tree
-    end
-
-    it 'has the correct #name' do
-      expect(exp.name).to eq 'Fred'
-    end
-
-    it 'has the correct #simple_name' do
-      expect(exp.simple_name).to eq 'Fred'
-    end
-
-    it 'has a simple full_name' do
-      expect(exp.full_name('')).to eq 'Fred'
-    end
-
-    it 'has a fq full_name' do
-      expect(exp.full_name('Blimey::O::Reilly')).to eq 'Blimey::O::Reilly::Fred'
-    end
-  end
-
-  context 'with a scoped name' do
-    let(:exp) do
-      Reek::Source::SourceCode.from('module Foo::Bar; end').syntax_tree
-    end
-
-    it 'has the correct #name' do
-      expect(exp.name).to eq 'Foo::Bar'
-    end
-
-    it 'has the correct #simple_name' do
-      expect(exp.simple_name).to eq 'Bar'
-    end
-
-    it 'has a simple full_name' do
-      expect(exp.full_name('')).to eq 'Foo::Bar'
-    end
-
-    it 'has a fully qualified full_name' do
-      expect(exp.full_name('Blimey::O::Reilly')).to eq 'Blimey::O::Reilly::Foo::Bar'
-    end
-  end
-
-  context 'with a name scoped in a namespace that is not a constant' do
-    let(:exp) do
-      Reek::Source::SourceCode.from('module foo::Bar; end').syntax_tree
-    end
-
-    it 'has the correct #name' do
-      expect(exp.name).to eq 'foo::Bar'
-    end
-
-    it 'has the correct #simple_name' do
-      expect(exp.simple_name).to eq 'Bar'
-    end
-  end
-end
-
-RSpec.describe Reek::AST::SexpExtensions::CasgnNode do
-  describe '#defines_module?' do
-    it 'is false for single assignment' do
-      exp = sexp(:casgn, nil, :Foo)
-      expect(exp).not_to be_defines_module
-    end
-
-    it 'is false for implicit receiver to new' do
-      exp = sexp(:casgn, nil, :Foo, sexp(:send, nil, :new))
-      expect(exp).not_to be_defines_module
-    end
-
-    it 'is true for explicit receiver to new' do
-      exp = Reek::Source::SourceCode.from('Foo = Class.new(Bar)').syntax_tree
-      expect(exp).to be_defines_module
-    end
-
-    it 'is false for assigning a lambda to a constant' do
-      exp = Reek::Source::SourceCode.from('C = ->{}').syntax_tree
-      expect(exp).not_to be_defines_module
-    end
-
-    it 'is false for assigning a string to a constant' do
-      exp = Reek::Source::SourceCode.from('C = "hello"').syntax_tree
-      expect(exp).not_to be_defines_module
-    end
-  end
-
-  describe '#superclass' do
-    it 'returns the superclass from the class definition' do
-      exp = Reek::Source::SourceCode.from('Foo = Class.new(Bar)').syntax_tree
-      expect(exp.superclass).to eq sexp(:const, nil, :Bar)
-    end
-
-    it 'returns nil in case of no class definition' do
-      exp = Reek::Source::SourceCode.from('Foo = 23').syntax_tree
-      expect(exp.superclass).to be_nil
-    end
-
-    it 'returns nil in case of no superclass' do
-      exp = Reek::Source::SourceCode.from('Foo = Class.new').syntax_tree
-      expect(exp.superclass).to be_nil
-    end
-
-    it 'returns nothing for a class definition using Struct.new' do
-      exp = Reek::Source::SourceCode.from('Foo = Struct.new("Bar")').syntax_tree
-      expect(exp.superclass).to be_nil
-    end
-
-    it 'returns nothing for a constant assigned with a bare method call' do
-      exp = Reek::Source::SourceCode.from('Foo = foo("Bar")').syntax_tree
-      expect(exp.superclass).to be_nil
-    end
-  end
-end