reek 6.0.2 → 6.1.0

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