reek 1.2.6 → 1.2.8

data/spec/reek/code_context_spec.rb

@@ -1,182 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper.rb'
-
-require 'reek/block_context'
-require 'reek/if_context'
-require 'reek/class_context'
-require 'reek/module_context'
-require 'reek/method_context'
-require 'reek/stop_context'
-
-include Reek
-
-describe CodeContext do
-  context 'full_name' do
-    it "reports the full context" do
-      element = StopContext.new
-      element = ModuleContext.new(element, Name.new(:mod), s(:module, :mod, nil))
-      element = ClassContext.new(element, [0, :klass], s())
-      element = MethodContext.new(element, [0, :bad])
-      element = BlockContext.new(element, s(nil, nil))
-      element.full_name.should match(/bad/)
-      element.full_name.should match(/klass/)
-      element.full_name.should match(/mod/)
-    end
-
-    it 'reports the method name via if context' do
-      element1 = StopContext.new
-      element2 = MethodContext.new(element1, [0, :bad])
-      element3 = IfContext.new(element2, [0,1])
-      BlockContext.new(element3, s(nil, nil)).full_name.should match(/bad/)
-    end
-
-    it 'reports the method name via nested blocks' do
-      element1 = StopContext.new
-      element2 = MethodContext.new(element1, [0, :bad])
-      element3 = BlockContext.new(element2, s(nil, nil))
-      BlockContext.new(element3, s(nil, nil)).full_name.should match(/bad/)
-    end
-    it 'includes the enclosing context name' do
-      outer_name = 'randomstring'
-      outer = mock('outer')
-      outer.should_receive(:full_name).and_return(outer_name)
-      ifc = IfContext.new(outer, s(:if, s()))
-      ifc.full_name.should == outer_name
-    end
-  end
-
-  context 'instance variables' do
-    it 'should pass instance variables down to the first class' do
-      element = StopContext.new
-      element = ModuleContext.new(element, Name.new(:mod), s(:module, :mod, nil))
-      class_element = ClassContext.new(element, [0, :klass], s())
-      element = MethodContext.new(class_element, [0, :bad])
-      element = BlockContext.new(element, s(nil, nil))
-      element.record_instance_variable(:fred)
-      class_element.variable_names.size.should == 1
-      class_element.variable_names.should include(Name.new(:fred))
-    end
-  end
-
-  context 'generics' do
-    it 'should pass unknown method calls down the stack' do
-      stop = StopContext.new
-      def stop.bananas(arg1, arg2) arg1 + arg2 + 43 end
-      element = ModuleContext.new(stop, Name.new(:mod), s(:module, :mod, nil))
-      class_element = ClassContext.new(element, [0, :klass], s())
-      element = MethodContext.new(class_element, [0, :bad])
-      element = BlockContext.new(element, s(nil, nil))
-      element.bananas(17, -5).should == 55
-    end
-  end
-
-  context 'name matching' do
-    it 'should recognise itself in a collection of names' do
-      element = StopContext.new
-      element = ModuleContext.new(element, Name.new(:mod), s(:module, :mod, nil))
-      element.matches?(['banana', 'mod']).should == true
-    end
-
-    it 'should recognise itself in a collection of REs' do
-      element = StopContext.new
-      element = ModuleContext.new(element, Name.new(:mod), s(:module, :mod, nil))
-      element.matches?([/banana/, /mod/]).should == true
-    end
-
-    it 'should recognise its fq name in a collection of names' do
-      element = StopContext.new
-      element = ModuleContext.new(element, Name.new(:mod), s(:module, :mod, nil))
-      element = ClassContext.create(element, s(:class, :klass))
-      element.matches?(['banana', 'mod']).should == true
-      element.matches?(['banana', 'mod::klass']).should == true
-    end
-
-    it 'should recognise its fq name in a collection of names' do
-      element = StopContext.new
-      element = ModuleContext.new(element, Name.new(:mod), s(:module, :mod, nil))
-      element = ClassContext.create(element, s(:class, :klass))
-      element.matches?([/banana/, /mod/]).should == true
-      element.matches?([/banana/, /mod::klass/]).should == true
-    end
-  end
-
-  context 'enumerating syntax elements' do
-    context 'in an empty module' do
-      before :each do
-        @module_name = 'Emptiness'
-        src = "module #{@module_name}; end"
-        ast = src.to_reek_source.syntax_tree
-        @ctx = CodeContext.new(nil, ast)
-      end
-      it 'yields no calls' do
-        @ctx.each_node(:call, []) {|exp| raise "#{exp} yielded by empty module!"}
-      end
-      it 'yields one module' do
-        mods = 0
-        @ctx.each_node(:module, []) {|exp| mods += 1}
-        mods.should == 1
-      end
-      it "yields the module's full AST" do
-        @ctx.each_node(:module, []) {|exp| exp[1].should == @module_name.to_sym}
-      end
-
-      context 'with no block' do
-        it 'returns an empty array of ifs' do
-          @ctx.each_node(:if, []).should be_empty
-        end
-      end
-    end
-
-    context 'with a nested element' do
-      before :each 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)
-      end
-      it 'yields no ifs' do
-        @ctx.each_node(:if, []) {|exp| raise "#{exp} yielded by empty module!"}
-      end
-      it 'yields one module' do
-        @ctx.each_node(:module, []).length.should == 1
-      end
-      it "yields the module's full AST" do
-        @ctx.each_node(:module, []) {|exp| exp[1].should == @module_name.to_sym}
-      end
-      it 'yields one method' do
-        @ctx.each_node(:defn, []).length.should == 1
-      end
-      it "yields the method's full AST" do
-        @ctx.each_node(:defn, []) {|exp| exp[1].should == @method_name.to_sym}
-      end
-
-      context 'pruning the traversal' do
-        it 'ignores the call inside the method' do
-          @ctx.each_node(:call, [:defn]).should be_empty
-        end
-      end
-    end
-
-    it 'finds 3 ifs in a class' do
-      src = <<EOS
-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
-EOS
-
-      ast = src.to_reek_source.syntax_tree
-      ctx = CodeContext.new(nil, ast)
-      ctx.each_node(:if, []).length.should == 3
-    end
-  end
-end

data/spec/reek/configuration_spec.rb

@@ -1,12 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper.rb'
-
-require 'reek/configuration'
-
-include Reek
-
-describe SmellConfiguration do
-  it 'returns the default value when key not found' do
-    cf = SmellConfiguration.new({})
-    cf.value('fred', nil, 27).should == 27
-  end
-end

data/spec/reek/if_context_spec.rb

@@ -1,17 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper.rb'
-
-require 'reek/if_context'
-
-include Reek
-
-describe IfContext do
-  it 'finds a class within top-level code' do
-    'unless jim; class Array; end; end'.should_not reek
-  end
-
-  it 'finds class within top-level code' do
-    stopctx = StopContext.new
-    ifctx = IfContext.new(stopctx, [:if, [:vcall, :jim]])
-    ifctx.find_module(Name.new(:Array)).should_not be_nil
-  end
-end

data/spec/reek/masking_collection_spec.rb

@@ -1,236 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper.rb'
-
-require 'reek/masking_collection'
-
-include Reek
-
-describe MaskingCollection do
-  before(:each) do
-    @collection = MaskingCollection.new
-  end
-
-  context 'when empty' do
-    it 'has no visible items' do
-      @collection.num_visible_items.should == 0
-    end
-    it 'has no masked items' do
-      @collection.num_masked_items.should == 0
-    end
-    it 'yields no items' do
-      count = 0
-      @collection.each_item {|item| count+= 1}
-      count.should == 0
-    end
-    it 'yields no visible items' do
-      count = 0
-      @collection.each_visible_item {|item| count+= 1}
-      count.should == 0
-    end
-  end
-
-  shared_examples_for 'one visible item' do
-    it 'has one visible item' do
-      @collection.num_visible_items.should == 1
-    end
-    it 'has no masked items' do
-      @collection.num_masked_items.should == 0
-    end
-    it 'yields one item' do
-      count = 0
-      @collection.each_item do |item|
-        item.should == @item
-        count+= 1
-      end
-      count.should == 1
-    end
-    it 'yields one visible item' do
-      count = 0
-      @collection.each_visible_item do |item|
-        item.should == @item
-        count+= 1
-      end
-      count.should == 1
-    end
-  end
-
-  shared_examples_for 'one masked item' do
-    it 'has no visible items' do
-      @collection.num_visible_items.should == 0
-    end
-    it 'has one masked item' do
-      @collection.num_masked_items.should == 1
-    end
-    it 'yields one item' do
-      count = 0
-      @collection.each_item do |item|
-        item.should == @item
-        count+= 1
-      end
-      count.should == 1
-    end
-    it 'yields no visible items' do
-      count = 0
-      @collection.each_visible_item { |item| count+= 1 }
-      count.should == 0
-    end
-  end
-
-  context 'with one visible item' do
-    before :each do
-      @item = "hello"
-      @collection.found_smell(@item)
-    end
-    it_should_behave_like 'one visible item'
-  end
-
-  context 'with one masked item' do
-    before :each do
-      @item = "hiding!"
-      @collection.found_masked_smell(@item)
-    end
-    it_should_behave_like 'one masked item'
-  end
-
-  context 'with one masked and one visible' do
-    before :each do
-      @visible = "visible"
-      @masked = "masked"
-      @collection.found_masked_smell(@masked)
-      @collection.found_smell(@visible)
-    end
-    it 'has one visible item' do
-      @collection.num_visible_items.should == 1
-    end
-    it 'has one masked item' do
-      @collection.num_masked_items.should == 1
-    end
-    it 'yields both items' do
-      yielded_items = []
-      @collection.each_item { |item| yielded_items << item }
-      yielded_items.length.should == 2
-      yielded_items.should include(@visible)
-      yielded_items.should include(@masked)
-    end
-    it 'yields one visible item' do
-      count = 0
-      @collection.each_visible_item do |item|
-        item.should == @visible
-        count+= 1
-      end
-      count.should == 1
-    end
-    it 'yields the items in sort order' do
-      yielded_items = []
-      @collection.each_item { |item| yielded_items << item }
-      yielded_items.length.should == 2
-      yielded_items[0].should == @masked
-      yielded_items[1].should == @visible
-    end
-  end
-
-  context 'with one visible item added twice' do
-    before :each do
-      @item = "hello"
-      @collection.found_smell(@item)
-      @collection.found_smell(@item)
-    end
-    it_should_behave_like 'one visible item'
-  end
-
-  context 'with one masked item added twice' do
-    before :each do
-      @item = "hello"
-      @collection.found_masked_smell(@item)
-      @collection.found_masked_smell(@item)
-    end
-    it_should_behave_like 'one masked item'
-  end
-
-  context 'with two different visible items' do
-    before :each do
-      @first_item = "hello"
-      @second_item = "goodbye"
-      @collection.found_smell(@first_item)
-      @collection.found_smell(@second_item)
-    end
-    it 'has 2 visible items' do
-      @collection.num_visible_items.should == 2
-    end
-    it 'has no masked items' do
-      @collection.num_masked_items.should == 0
-    end
-    it 'yields both items' do
-      yielded_items = []
-      @collection.each_item { |item| yielded_items << item }
-      yielded_items.length.should == 2
-      yielded_items.should include(@first_item)
-      yielded_items.should include(@second_item)
-    end
-    it 'yields both visible items' do
-      yielded_items = []
-      @collection.each_visible_item { |item| yielded_items << item }
-      yielded_items.length.should == 2
-      yielded_items.should include(@first_item)
-      yielded_items.should include(@second_item)
-    end
-    it 'yields the items in sort order' do
-      yielded_items = []
-      @collection.each_visible_item { |item| yielded_items << item }
-      yielded_items.length.should == 2
-      yielded_items[0].should == @second_item
-      yielded_items[1].should == @first_item
-    end
-  end
-
-  context 'with two different masked items' do
-    before :each do
-      @first_item = "hello"
-      @second_item = "goodbye"
-      @collection.found_masked_smell(@first_item)
-      @collection.found_masked_smell(@second_item)
-    end
-    it 'has 0 visible items' do
-      @collection.num_visible_items.should == 0
-    end
-    it 'has 2 masked items' do
-      @collection.num_masked_items.should == 2
-    end
-    it 'yields both items' do
-      yielded_items = []
-      @collection.each_item { |item| yielded_items << item }
-      yielded_items.length.should == 2
-      yielded_items.should include(@first_item)
-      yielded_items.should include(@second_item)
-    end
-    it 'yields no visible items' do
-      count = 0
-      @collection.each_visible_item { |item| count+= 1 }
-      count.should == 0
-    end
-    it 'yields the items in sort order' do
-      yielded_items = []
-      @collection.each_item { |item| yielded_items << item }
-      yielded_items.length.should == 2
-      yielded_items[0].should == @second_item
-      yielded_items[1].should == @first_item
-    end
-  end
-
-  context 'with one masked item later made visible' do
-    before :each do
-      @item = "hello"
-      @collection.found_masked_smell(@item)
-      @collection.found_smell(@item)
-    end
-    it_should_behave_like 'one visible item'
-  end
-
-  context 'with one visible item later masked' do
-    before :each do
-      @item = "hello"
-      @collection.found_smell(@item)
-      @collection.found_masked_smell(@item)
-    end
-    it_should_behave_like 'one visible item'
-  end
-end

data/spec/reek/module_context_spec.rb

@@ -1,46 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper.rb'
-require 'reek/module_context'
-require 'reek/stop_context'
-
-include Reek
-
-describe ModuleContext do
-  it 'should report module name for smell in method' do
-    'module Fred; def simple(x) true; end; end'.should reek_of(:UncommunicativeName, /x/, /simple/, /Fred/)
-  end
-
-  it 'should not report module with empty class' do
-    'module Fred; class Jim; end; end'.should_not reek
-  end
-
-  it 'should handle module with empty class' do
-    stop = StopContext.new
-    modctx = ModuleContext.create(stop, [:module, :Fred, []])
-    modctx.find_module(Name.new(:Jim)).should be_nil
-  end
-end
-
-describe ModuleContext do
-  it 'should recognise global constant' do
-    'module ::Global class Inside; end; end'.should_not reek
-  end
-
-  it 'should not find missing global constant' do
-    element = ModuleContext.create(StopContext.new, [:module, [:colon3, :Global], nil])
-    element.myself.should be_nil
-  end
-
-  it 'should find global constant' do
-    module ::GlobalTestModule; end
-    element = ModuleContext.create(StopContext.new, [:module, [:colon3, :GlobalTestModule], nil])
-    element.myself.name.should == 'GlobalTestModule'
-  end
-
-  context 'full_name' do
-    it "reports full context" do
-      element = StopContext.new
-      element = ModuleContext.new(element, Name.new(:mod), s(:module, :mod, nil))
-      element.full_name.should == 'mod'
-    end
-  end
-end

data/spec/reek/name_spec.rb

@@ -1,37 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper.rb'
-require 'reek/name'
-
-include Reek
-
-describe Name, 'resolving symbols' do
-  it 'finds fq loaded class' do
-    exp = [:class, :"Reek::Smells::LargeClass", nil]
-    ctx = StopContext.new
-    res = Name.resolve(exp[1], ctx)
-    res[1].should == "LargeClass"
-  end
-end
-
-describe Name do
-  it 'compares correctly' do
-    a1 = [Name.new('conts'), Name.new('p1'), Name.new('p2'), Name.new('p3')]
-    a2 = [Name.new('name'), Name.new('windowH'), Name.new('windowW')]
-    (a1 & a2).should == []
-  end
-
-  it do
-    [Name.new(:fred)].should include(Name.new(:fred))
-  end
-
-  it do
-    set = Set.new
-    set << Name.new(:fred)
-    set.should include(Name.new(:fred))
-  end
-
-  it do
-    fred = Name.new(:fred)
-    fred.should eql(fred)
-    fred.should eql(Name.new(:fred))
-  end
-end

data/spec/reek/object_source_spec.rb

@@ -1,23 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper.rb'
-
-include Reek
-
-describe Dir do
-  it 'reports correct smells via the Dir matcher' do
-    Dir['spec/samples/two_smelly_files/*.rb'].should reek
-    Dir['spec/samples/two_smelly_files/*.rb'].should reek_of(:UncommunicativeName)
-  end
-
-  it 'reports correct smells via Dir' do
-    sniffer = Dir['spec/samples/two_smelly_files/*.rb'].sniff
-    sniffer.has_smell?(:UncommunicativeName).should be_true
-  end
-
-  it 'copes with daft file specs' do
-    Dir["spec/samples/two_smelly_files/*/.rb"].should_not reek
-  end
-
-  it 'copes with empty array' do
-    [].should_not reek
-  end
-end

data/spec/reek/reek_command_spec.rb

@@ -1,45 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper.rb'
-
-require 'reek/reek_command'
-
-include Reek
-
-describe ReekCommand do
-  before :each do
-    @view = mock('view', :null_object => true)
-  end
-
-  context 'with smells' do
-    before :each do
-      src = 'def x(); end'
-      @cmd = ReekCommand.new(src, QuietReport, false)
-    end
-
-    it 'displays the correct text on the view' do
-      @view.should_receive(:output).with(/Uncommunicative Name/)
-      @cmd.execute(@view)
-    end
-
-    it 'tells the view it succeeded' do
-      @view.should_receive(:report_smells)
-      @cmd.execute(@view)
-    end
-  end
-
-  context 'with no smells' do
-    before :each do
-      src = 'def clean(); end'
-      @cmd = ReekCommand.new(src, QuietReport, false)
-    end
-
-    it 'displays nothing on the view' do
-      @view.should_receive(:output).with('')
-      @cmd.execute(@view)
-    end
-
-    it 'tells the view it succeeded' do
-      @view.should_receive(:report_success)
-      @cmd.execute(@view)
-    end
-  end
-end

data/spec/reek/singleton_method_context_spec.rb

@@ -1,16 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper.rb'
-
-require 'reek/module_context'
-require 'reek/singleton_method_context'
-require 'reek/stop_context'
-
-include Reek
-
-describe SingletonMethodContext do
-  it "reports full context" do
-    element = StopContext.new
-    element = ModuleContext.new(element, Name.new(:mod), s(:module, :mod, nil))
-    element = SingletonMethodContext.new(element, s(:defs, s(:call, nil, :a, s(:arglist)), :b, s(:args)))
-    element.full_name.should match(/mod#a\.b/)
-  end
-end

data/spec/reek/smells/smell_detector_spec.rb

@@ -1,36 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-require 'reek/configuration'
-require 'reek/smells/duplication'
-require 'reek/smells/large_class'
-require 'reek/smells/long_method'
-
-include Reek
-include Reek::Smells
-
-describe SmellDetector, 'configuration' do
-  before:each do
-    @detector = LongMethod.new
-  end
-
-  it 'adopts new max_statements value' do
-    @detector.configure_with(LongMethod::MAX_ALLOWED_STATEMENTS_KEY => 25)
-    @detector.value(LongMethod::MAX_ALLOWED_STATEMENTS_KEY, nil, 0).should == 25
-  end
-end
-
-describe SmellDetector, 'configuration' do
-#  it 'stays enabled when not disabled' do
-#    @detector = LargeClass.new
-#    @detector.should be_enabled
-#    @detector.configure({'LargeClass' => {'max_methods' => 50}})
-#    @detector.should be_enabled
-#  end
-
-  it 'becomes disabled when disabled' do
-    @detector = LargeClass.new
-    @detector.should be_enabled
-    @detector.configure({'LargeClass' => {SmellConfiguration::ENABLED_KEY => false}})
-    @detector.should_not be_enabled
-  end
-end