reek 1.2.6 → 1.2.8

data/lib/reek/tree_dresser.rb

@@ -1,82 +0,0 @@
-module Reek
-
-  #
-  # Extensions to +Sexp+ to allow +CodeParser+ to navigate the abstract
-  # syntax tree more easily.
-  #
-  module SexpNode
-    def is_language_node?
-      first.class == Symbol
-    end
-
-    def has_type?(type)
-      is_language_node? and first == type
-    end
-
-    #
-    # Carries out a depth-first traversal of this syntax tree, yielding
-    # every Sexp of type +target_type+. The traversal ignores any node
-    # whose type is listed in the Array +ignoring+.
-    #
-    def look_for(target_type, ignoring, &blk)
-      each do |elem|
-        if Sexp === elem then
-          elem.look_for(target_type, ignoring, &blk) unless ignoring.include?(elem.first)
-        end
-      end
-      blk.call(self) if first == target_type
-    end
-  end
-
-  module SexpExtensions
-    module CaseNode
-      def condition
-        self[1]
-      end
-    end
-
-    module CallNode
-      def receiver() self[1] end
-      def method_name() self[2] end
-      def args() self[3] end
-      def arg_names
-        args[1..-1].map {|arg| arg[1]}
-      end
-    end
-
-    module CvarNode
-      def name() self[1] end
-    end
-
-    CvasgnNode = CvarNode
-    CvdeclNode = CvarNode
-
-    module DefnNode
-      def method_name() self[1] end
-      def parameters() self[2] end
-    end
-
-    module IfNode
-      def condition
-        self[1]
-      end
-    end
-  end
-
-  class TreeDresser
-
-    def dress(sexp)
-      sexp.extend(SexpNode)
-      module_name = extensions_for(sexp.sexp_type)
-      if Reek::SexpExtensions.const_defined?(module_name)
-        sexp.extend(Reek::SexpExtensions.const_get(module_name))
-      end
-      sexp[0..-1].each { |sub| dress(sub) if Array === sub }
-      sexp
-    end
-
-    def extensions_for(node_type)
-      "#{node_type.to_s.capitalize}Node"
-    end
-  end
-end

data/lib/reek/version_command.rb

@@ -1,14 +0,0 @@
-
-module Reek
-
-  class VersionCommand
-    def initialize(progname)
-      @progname = progname
-    end
-    def execute(view)
-      view.output("#{@progname} #{Reek::VERSION}")
-      view.report_success
-    end
-  end
-
-end

data/lib/reek/yield_call_context.rb

@@ -1,12 +0,0 @@
-require 'reek/code_context'
-
-module Reek
-  class YieldCallContext < CodeContext
-    attr_reader :parameters
-
-    def initialize(outer, exp)
-      super
-      @parameters = exp[1..-1]
-    end
-  end
-end

data/spec/reek/adapters/report_spec.rb

@@ -1,31 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-require 'reek/adapters/core_extras'
-require 'reek/adapters/report'
-require 'reek/adapters/source'
-require 'reek/smells/feature_envy'
-
-include Reek
-
-describe ReportSection, " when empty" do
-  before(:each) do
-    @rpt = ReportSection.new(''.sniff, false)
-  end
-
-  it 'has an empty quiet_report' do
-    @rpt.quiet_report.should == ''
-  end
-end
-
-describe ReportSection, "smell_list" do
-  before(:each) do
-    rpt = ReportSection.new('def simple(a) a[3] end'.sniff, false)
-    @lines = rpt.smell_list.split("\n")
-  end
-
-  it 'should mention every smell name' do
-    @lines.should have_at_least(2).lines
-    @lines[0].should match(/[Utility Function]/)
-    @lines[1].should match(/[Feature Envy]/)
-  end
-end

data/spec/reek/adapters/should_reek_of_spec.rb

@@ -1,138 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-require 'reek/adapters/report'
-require 'reek/adapters/spec'
-
-include Reek
-include Reek::Spec
-
-# belongs in its own spec file
-describe ReekMatcher do
-  before :each do
-    smelly_code = Dir['spec/samples/two_smelly_files/*.rb']
-    @sniffers = smelly_code.sniff.sniffers
-    @full = VerboseReport.new(@sniffers, false).report
-  end
-
-  it 'reports quietly' do
-    ReekMatcher.create_reporter(@sniffers).should_not == @full
-  end
-end
-
-describe ShouldReekOf do
-  context 'rdoc demo example' do
-    before :each do
-      @ruby = 'def double_thing() @other.thing.foo + @other.thing.foo end'
-    end
-
-    shared_examples_for 'reek as documented' do
-      it 'reports duplicate calls to @other.thing' do
-        @ruby.should reek_of(:Duplication, /@other.thing[^\.]/)
-      end
-      it 'reports duplicate calls to @other.thing.foo' do
-        @ruby.should reek_of(:Duplication, /@other.thing.foo/)
-      end
-      it 'does not report any feature envy' do
-        @ruby.should_not reek_of(:FeatureEnvy)
-      end
-    end
-
-    context 'using source code' do
-      it_should_behave_like 'reek as documented'
-    end
-
-    context 'using a sniffer' do
-      before :each do
-        @ruby = @ruby.sniff
-      end
-
-      it_should_behave_like 'reek as documented'
-    end
-  end
-
-  context 'checking code in a string' do
-    before :each do
-      @clean_code = 'def good() true; end'
-      @smelly_code = 'def x() y = 4; end'
-      @expected_report = Reek::Spec::ReekMatcher::create_reporter(@smelly_code.sniff).report
-      @matcher = ShouldReekOf.new(:UncommunicativeName, [/x/, /y/])
-    end
-
-    it 'matches a smelly String' do
-      @matcher.matches?(@smelly_code).should be_true
-    end
-
-    it 'doesnt match a fragrant String' do
-      @matcher.matches?(@clean_code).should be_false
-    end
-
-    it 'reports the smells when should_not fails' do
-      @matcher.matches?(@smelly_code).should be_true
-      @matcher.failure_message_for_should_not.should include(@expected_report)
-    end
-  end
-
-  context 'checking code in a Dir' do
-    before :each do
-      @clean_dir = Dir['spec/samples/three_clean_files/*.rb']
-      @smelly_dir = Dir['spec/samples/two_smelly_files/*.rb']
-      @matcher = ShouldReekOf.new(:UncommunicativeName, [/Dirty/, /@s/])
-    end
-
-    it 'matches a smelly String' do
-      @matcher.matches?(@smelly_dir).should be_true
-    end
-
-    it 'doesnt match a fragrant String' do
-      @matcher.matches?(@clean_dir).should be_false
-    end
-
-    it 'reports the smells when should_not fails' do
-      @matcher.matches?(@smelly_dir).should be_true
-      @matcher.failure_message_for_should_not.should include(QuietReport.new(@smelly_dir.sniff.sniffers, '%m%c %w (%s)').report)
-    end
-  end
-
-  context 'checking code in a File' do
-    before :each do
-      @clean_file = File.new(Dir['spec/samples/three_clean_files/*.rb'][0])
-      @smelly_file = File.new(Dir['spec/samples/two_smelly_files/*.rb'][0])
-      @matcher = ShouldReekOf.new(:UncommunicativeName, [/Dirty/, /@s/])
-    end
-
-    it 'matches a smelly String' do
-      @matcher.matches?(@smelly_file).should be_true
-    end
-
-    it 'doesnt match a fragrant String' do
-      @matcher.matches?(@clean_file).should be_false
-    end
-
-    it 'reports the smells when should_not fails' do
-      @matcher.matches?(@smelly_file).should be_true
-      @matcher.failure_message_for_should_not.should include(QuietReport.new(@smelly_file.sniff, '%m%c %w (%s)').report)
-    end
-  end
-
-  context 'report formatting' do
-    before :each do
-      sn_clean = 'def clean() @thing = 4; end'.sniff
-      sn_dirty = 'def dirty() thing.cool + thing.cool; end'.sniff
-      sniffers = SnifferSet.new([sn_clean, sn_dirty], '')
-      @matcher = ShouldReekOf.new(:UncommunicativeName, [/Dirty/, /@s/])
-      @matcher.matches?(sniffers)
-      @lines = @matcher.failure_message_for_should_not.split("\n").map {|str| str.chomp}
-      @error_message = @lines.shift
-      @smells = @lines.grep(/^  /)
-      @headers = (@lines - @smells)
-    end
-
-    it 'mentions every smell in the report' do
-      @smells.should have(2).warnings
-    end
-
-    it 'doesnt mention the clean source' do
-      @headers.should have(1).headers
-    end
-  end
-end

data/spec/reek/adapters/should_reek_only_of_spec.rb

@@ -1,87 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-require 'reek/adapters/report'
-require 'reek/adapters/spec'
-
-include Reek
-include Reek::Spec
-
-describe ShouldReekOnlyOf, 'checking code in a string' do
-  before :each do
-    @clean_code = 'def good() true; end'
-    @smelly_code = 'def fine() y = 4; end'
-    @matcher = ShouldReekOnlyOf.new(:UncommunicativeName, [/y/])
-  end
-
-  it 'matches a smelly String' do
-    @matcher.matches?(@smelly_code).should be_true
-  end
-
-  it 'doesnt match a fragrant String' do
-    @matcher.matches?(@clean_code).should be_false
-  end
-
-  it 'reports the smells when should_not fails' do
-    @matcher.matches?(@smelly_code).should be_true
-    @matcher.failure_message_for_should_not.should include('UncommunicativeName')
-  end
-end
-
-describe ShouldReekOnlyOf, 'checking code in a Dir' do
-  before :each do
-    @clean_dir = Dir['spec/samples/three_clean_files/*.rb']
-    @smelly_dir = Dir['spec/samples/all_but_one_masked/*.rb']
-    @matcher = ShouldReekOnlyOf.new(:NestedIterators, [/Dirty\#a/])
-  end
-
-  it 'matches a smelly String' do
-    @matcher.matches?(@smelly_dir).should be_true
-  end
-
-  it 'doesnt match a fragrant String' do
-    @matcher.matches?(@clean_dir).should be_false
-  end
-
-  it 'reports the smells when should_not fails' do
-    @matcher.matches?(@smelly_dir).should be_true
-    @matcher.failure_message_for_should.should include(QuietReport.new(@smelly_dir.sniff.sniffers).report)
-  end
-end
-
-describe ShouldReekOnlyOf, 'checking code in a File' do
-  before :each do
-    @clean_file = File.new(Dir['spec/samples/three_clean_files/*.rb'][0])
-    @smelly_file = File.new(Dir['spec/samples/all_but_one_masked/d*.rb'][0])
-    @matcher = ShouldReekOnlyOf.new(:NestedIterators, [/Dirty\#a/])
-  end
-
-  it 'matches a smelly String' do
-    @matcher.matches?(@smelly_file).should be_true
-  end
-
-  it 'doesnt match a fragrant String' do
-    @matcher.matches?(@clean_file).should be_false
-  end
-
-  it 'reports the smells when should_not fails' do
-    @matcher.matches?(@smelly_file).should be_true
-    @matcher.failure_message_for_should.should include(QuietReport.new(@smelly_file.sniff).report)
-  end
-end
-
-describe ShouldReekOnlyOf, 'report formatting' do
-  before :each do
-    @smelly_dir = Dir['spec/samples/all_but_one_masked/*.rb']
-    @matcher = ShouldReekOnlyOf.new(:NestedIterators, [/Dirty\#a/])
-    @matcher.matches?(@smelly_dir)
-    @lines = @matcher.failure_message_for_should.split("\n").map {|str| str.chomp}
-    @error_message = @lines.shift
-    @smells = @lines.grep(/^  /)
-    @headers = (@lines - @smells)
-  end
-
-  it 'doesnt mention the clean files' do
-    @headers.should have(1).header
-    @headers.should_not include('clean')
-  end
-end

data/spec/reek/block_context_spec.rb

@@ -1,65 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper.rb'
-
-require 'reek/block_context'
-require 'reek/method_context'
-
-include Reek
-
-describe BlockContext do
-
-  it "should record single parameter" do
-    element = StopContext.new
-    element = BlockContext.new(element, s(:iter, nil, s(:lasgn, :x), nil))
-    element.variable_names.should == [Name.new(:x)]
-  end
-
-  it "should record single parameter within a method" do
-    element = StopContext.new
-    element = MethodContext.new(element, s(:defn, :help))
-    element = BlockContext.new(element, s(:iter, nil, s(:lasgn, :x), nil))
-    element.variable_names.should == [Name.new(:x)]
-  end
-
-  it "records multiple parameters" do
-    element = StopContext.new
-    element = BlockContext.new(element, s(:iter, nil, s(:masgn, s(:array, s(:lasgn, :x), s(:lasgn, :y))), nil))
-    element.variable_names.should == [Name.new(:x), Name.new(:y)]
-  end
-
-  it "should not pass parameters upward" do
-    mc = MethodContext.new(StopContext.new, s(:defn, :help, s(:args)))
-    element = BlockContext.new(mc, s(:iter, nil, s(:lasgn, :x)))
-    mc.variable_names.should be_empty
-  end
-
-  it 'records local variables' do
-    bctx = BlockContext.new(StopContext.new, s(nil, nil))
-    bctx.record_local_variable(:q2)
-    bctx.variable_names.should include(Name.new(:q2))
-  end
-
-  it 'copes with a yield to an ivar' do
-    scope = BlockContext.new(StopContext.new, s(:iter, nil, s(:iasgn, :@list), s(:self)))
-    scope.record_instance_variable(:@list)
-    scope.variable_names.should == [:@list]
-  end
-
-  context 'full_name' do
-    it "reports full context" do
-      bctx = BlockContext.new(StopContext.new, s(nil, nil))
-      bctx.full_name.should == 'block'
-    end
-    it 'uses / to connect to the class name' do
-      element = StopContext.new
-      element = ClassContext.new(element, :Fred, s(:class, :Fred))
-      element = BlockContext.new(element, s(:iter, nil, s(:lasgn, :x), nil))
-      element.full_name.should == 'Fred/block'
-    end
-    it 'uses / to connect to the module name' do
-      element = StopContext.new
-      element = ModuleContext.new(element, :Fred, s(:module, :Fred))
-      element = BlockContext.new(element, s(:iter, nil, s(:lasgn, :x), nil))
-      element.full_name.should == 'Fred/block'
-    end
-  end
-end

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