reek 1.2.6 → 1.2.7

data/spec/reek/class_context_spec.rb

@@ -1,161 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper.rb'
-
-require 'reek/class_context'
-require 'reek/stop_context'
-require 'reek/smells/feature_envy'
-
-include Reek
-include Reek::Smells
-
-describe ClassContext do
-  it 'should report Long Parameter List' do
-    ruby = 'class Inner; def simple(arga, argb, argc, argd) f(3);true end end'
-    ruby.should reek_of(:LongParameterList, /Inner/, /simple/, /4 parameters/)
-  end
-
-  it 'should report two different methods' do
-    src = <<EOEX
-class Fred
-  def simple(arga, argb, argc, argd) f(3);true end
-  def simply(arga, argb, argc, argd) f(3);false end
-end
-EOEX
-
-    src.should reek_of(:LongParameterList, /Fred/, /simple/)
-    src.should reek_of(:LongParameterList, /Fred/, /simply/)
-  end
-
-  it 'should report many different methods' do
-    src = <<EOEX
-class Fred
-    def textile_bq(tag, atts, cite, content) f(3);end
-    def textile_p(tag, atts, cite, content) f(3);end
-    def textile_fn_(tag, num, atts, cite, content) f(3);end
-    def textile_popup_help(name, windowW, windowH) f(3);end
-end
-EOEX
-    
-    src.should reek_of(:LongParameterList, /Fred/, /textile_bq/)
-    src.should reek_of(:LongParameterList, /Fred/, /textile_fn_/)
-    src.should reek_of(:LongParameterList, /Fred/, /textile_p/)
-  end
-end
-
-class Above
-  def above() end
-  def both() end
-end
-
-class Below < Above
-  def both() end
-  def below() end
-end
-
-describe ClassContext, 'overridden methods' do
-  describe 'of loaded class' do
-    before :each do
-      @ctx = ClassContext.create(StopContext.new, [0, :Below])
-    end
-
-    it 'should recognise non-overridden method' do
-      @ctx.is_overriding_method?('below').should == false
-      @ctx.is_overriding_method?('above').should == false
-    end
-
-    it 'should recognise overridden method' do
-      @ctx.is_overriding_method?('both').should == true
-    end
-    
-    it 'should recognise methods in current codebase' do
-      ctx = ClassContext.create(StopContext.new, [0, :FeatureEnvy])
-      ctx.is_overriding_method?('examine_context').should == true
-    end
-  end
-  
-  describe 'of non-loaded class' do
-    before :each do
-      @ctx = ClassContext.create(StopContext.new, [0, :Missing])
-    end
-
-    it 'should recognise non-overridden method' do
-      @ctx.is_overriding_method?('below').should == false
-      @ctx.is_overriding_method?('above').should == false
-    end
-
-    it 'should recognise overridden method' do
-      @ctx.is_overriding_method?('both').should == false
-    end
-  end
-end
-
-describe 'Integration defect:' do
-  it 'should not report UtilityFunction for FeatureEnvy#examine_context' do
-    kelement = ClassContext.create(StopContext.new, [0, :FeatureEnvy, s(:const, :SmellDetector)])
-    meth = Name.new(:examine_context)
-    kelement.is_overriding_method?(meth).should == true
-    melement = MethodContext.new(kelement, [0, :examine_context])
-    melement.is_overriding_method?(meth).should == true
-    melement.depends_on_instance?.should == true
-  end
-end
-
-module Mod1
-  class Klass1
-    module Mod2
-      class Klass2
-      end
-    end
-  end
-end
-
-describe CodeContext, 'find class' do
-  before :each do
-    @stop = StopContext.new
-    @mod1 = ModuleContext.create(@stop, [0, :Mod1])
-    @klass1 = ClassContext.create(@mod1, [0, :Klass1])
-    @mod2 = ModuleContext.create(@klass1, [0, :Mod2])
-    @klass2 = ClassContext.create(@mod2, [0, :Klass2])
-  end
-  
-  describe ModuleContext do
-    it 'should find local name' do
-      @mod1.find_module('Klass1').name.should == 'Mod1::Klass1'
-      @mod2.find_module('Klass2').name.should == 'Mod1::Klass1::Mod2::Klass2'
-    end
-    
-    it 'should not find deeper class' do
-      @mod1.find_module('Klass2').should == nil
-    end
-    
-    it 'should find own Module' do
-      @mod1.myself.name.should == 'Mod1'
-      @mod2.myself.name.should == 'Mod1::Klass1::Mod2'
-    end
-  end
-  
-  describe ClassContext do
-    it 'should find local module' do
-      @klass1.find_module('Mod2').name.should == 'Mod1::Klass1::Mod2'
-    end
-    
-    it 'should not find deeper module' do
-      @klass1.find_module('Klass2').should == nil
-    end
-    
-    it 'should find own Class' do
-      @klass1.myself.name.should == 'Mod1::Klass1'
-      @klass2.myself.name.should == 'Mod1::Klass1::Mod2::Klass2'
-    end
-  end
-end
-
-describe ClassContext do
-  it 'does not report empty class in another module' do
-    'class Treetop::Runtime::SyntaxNode; end'.should_not reek
-  end
-
-  it 'deals with :: scoped names' do
-    element = ClassContext.create(StopContext.new, [:colon2, [:colon2, [:const, :Treetop], :Runtime], :SyntaxNode])
-    element.num_methods.should == 0
-  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/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/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

data/spec/reek/smells/uncommunicative_name_spec.rb

@@ -1,146 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-require 'reek/method_context'
-require 'reek/smells/uncommunicative_name'
-
-include Reek
-include Reek::Smells
-
-describe UncommunicativeName, "method name" do
-  it 'should not report one-word method name' do
-    'def help(fred) basics(17) end'.should_not reek
-  end
-  it 'should report one-letter method name' do
-    'def x(fred) basics(17) end'.should reek_only_of(:UncommunicativeName, /x/)
-  end
-  it 'should report name of the form "x2"' do
-    'def x2(fred) basics(17) end'.should reek_only_of(:UncommunicativeName, /x2/)
-  end
-  it 'should report long name ending in a number' do
-    'def method2(fred) basics(17) end'.should reek_only_of(:UncommunicativeName, /method2/)
-  end
-end
-
-describe UncommunicativeName, "field name" do
-  it 'should not report one-word field name' do
-    'class Thing; def help(fred) @simple end end'.should_not reek
-  end
-  it 'should report one-letter fieldname' do
-    'class Thing; def simple(fred) @x end end'.should reek_only_of(:UncommunicativeName, /@x/, /Thing/, /variable name/)
-  end
-  it 'should report name of the form "x2"' do
-    'class Thing; def simple(fred) @x2 end end'.should reek_only_of(:UncommunicativeName, /@x2/, /Thing/, /variable name/)
-  end
-  it 'should report long name ending in a number' do
-    'class Thing; def simple(fred) @field12 end end'.should reek_only_of(:UncommunicativeName, /@field12/, /Thing/, /variable name/)
-  end
-  it 'should report one-letter fieldname in assignment' do
-    'class Thing; def simple(fred) @x = fred end end'.should reek_only_of(:UncommunicativeName, /@x/, /Thing/, /variable name/)
-  end
-end
-
-describe UncommunicativeName, "local variable name" do
-  it 'should not report one-word variable name' do
-    'def help(fred) simple = jim(45) end'.should_not reek
-  end
-  it 'should report one-letter variable name' do
-    'def simple(fred) x = jim(45) end'.should reek_only_of(:UncommunicativeName, /x/, /variable name/)
-  end
-  it 'should report name of the form "x2"' do
-    'def simple(fred) x2 = jim(45) end'.should reek_only_of(:UncommunicativeName, /x2/, /variable name/)
-  end
-  it 'should report long name ending in a number' do
-    'def simple(fred) var123 = jim(45) end'.should reek_only_of(:UncommunicativeName, /var123/, /variable name/)
-  end
-  it 'should report variable name only once' do
-    'def simple(fred) x = jim(45); x = y end'.should reek_only_of(:UncommunicativeName, /x/)
-  end
-
-  it 'should report a bad name inside a block' do
-    src = 'def clean(text) text.each { q2 = 3 } end'
-    src.should reek_of(:UncommunicativeName, /q2/)
-  end
-end
-
-describe UncommunicativeName, "parameter name" do
-  it 'should not recognise *' do
-    'def help(xray, *) basics(17) end'.should_not reek
-  end
-  it "should report parameter's name" do
-    'def help(x) basics(17) end'.should reek_only_of(:UncommunicativeName, /x/, /variable name/)
-  end
-  it 'should report name of the form "x2"' do
-    'def help(x2) basics(17) end'.should reek_only_of(:UncommunicativeName, /x2/, /variable name/)
-  end
-  it 'should report long name ending in a number' do
-    'def help(param1) basics(17) end'.should reek_only_of(:UncommunicativeName, /param1/, /variable name/)
-  end
-end
-
-describe UncommunicativeName, "block parameter name" do
-  it "should report parameter's name" do
-    'def help() @stuff.each {|x|} end'.should reek_only_of(:UncommunicativeName, /x/, /block/, /variable name/)
-  end
-
-  it "should report method name via if context" do
-    src = <<EOS
-def bad
-  unless @mod then
-    @sig.each { |x| x.to_s }
-  end
-end
-EOS
-
-    src.should reek_only_of(:UncommunicativeName, /'x'/)
-  end
-end
-
-describe UncommunicativeName, "several names" do
-
-  it 'should report all bad names' do
-    ruby = 'class Oof; def y(x) @z = x end end'.sniff
-    ruby.should reek_of(:UncommunicativeName, /'x'/)
-    ruby.should reek_of(:UncommunicativeName, /'y'/)
-    ruby.should reek_of(:UncommunicativeName, /'@z'/)
-  end
-
-  it 'should report all bad block parameters' do
-    source =<<EOS
-class Thing
-  def bad(fred)
-    @fred.each {|x| 4 - x }
-    @jim.each {|y| y - 4 }
-  end
-end
-EOS
-
-    source.should reek_of(:UncommunicativeName, /'x'/)
-    source.should reek_of(:UncommunicativeName, /'y'/)
-  end
-end
-
-describe UncommunicativeName do
-  before :each do
-    @detector = UncommunicativeName.new
-  end
-
-  context '#examine' do
-    it 'should return true when reporting a smell' do
-      mc = MethodContext.new(StopContext.new, s(:defn, :x, s(:args)))
-      @detector.examine(mc).should == true
-    end
-
-    it 'should return false when not reporting a smell' do
-      mc = MethodContext.new(StopContext.new, s(:defn, :not_bad, s(:args)))
-      @detector.examine(mc).should == false
-    end
-  end
-
-  context 'accepting names' do
-    it 'accepts Inline::C' do
-      ctx = mock('context')
-      ctx.should_receive(:full_name).and_return('Inline::C')
-      @detector.accept?(ctx).should == true
-    end
-  end
-end