reek 1.2.2 → 1.2.3

data/spec/reek/block_context_spec.rb

@@ -9,37 +9,37 @@ describe BlockContext do
 
   it "should record single parameter" do
     element = StopContext.new
-    element = BlockContext.new(element, s(s(:lasgn, :x), nil))
+    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(s(:lasgn, :x), nil))
+    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(s(:masgn, s(:array, s(:lasgn, :x), s(:lasgn, :y))), nil))
+    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(s(:lasgn, :x)))
+    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, nil)
+    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(:iasgn, :@list), s(:self)])
+    scope = BlockContext.new(StopContext.new, s(:iter, nil, s(:iasgn, :@list), s(:self)))
     scope.record_instance_variable(:@list)
     scope.variable_names.should == [:@list]
   end

data/spec/reek/class_context_spec.rb

@@ -150,33 +150,12 @@ describe CodeContext, 'find class' do
 end
 
 describe ClassContext do
-  it 'should not report empty class in another module' do
+  it 'does not report empty class in another module' do
     'class Treetop::Runtime::SyntaxNode; end'.should_not reek
   end
 
-  it 'should deal with :: scoped names' do
+  it 'deals with :: scoped names' do
     element = ClassContext.create(StopContext.new, [:colon2, [:colon2, [:const, :Treetop], :Runtime], :SyntaxNode])
     element.num_methods.should == 0
   end
-
-  it 'counts conditionals correctly' 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
-
-    ctx = ClassContext.from_s(src)
-    ctx.conditionals.length.should == 3
-  end
 end

data/spec/reek/code_context_spec.rb

@@ -9,85 +9,167 @@ require 'reek/stop_context'
 
 include Reek
 
-describe CodeContext, 'to_s' do
-
-  it "should report full context" do
-    element = StopContext.new
-    element = ModuleContext.new(element, Name.new(:mod))
-    element = ClassContext.new(element, [0, :klass])
-    element = MethodContext.new(element, [0, :bad])
-    element = BlockContext.new(element, nil)
-    element.to_s.should match(/bad/)
-    element.to_s.should match(/klass/)
-    element.to_s.should match(/mod/)
-  end
+describe CodeContext do
+  context 'to_s' 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.to_s.should match(/bad/)
+      element.to_s.should match(/klass/)
+      element.to_s.should match(/mod/)
+    end
 
-  it "should report method name via if context" do
-    element1 = StopContext.new
-    element2 = MethodContext.new(element1, [0, :bad])
-    element3 = IfContext.new(element2, [0,1])
-    BlockContext.new(element3, nil).to_s.should match(/bad/)
-  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)).to_s.should match(/bad/)
+    end
 
-  it "should report method name via nested blocks" do
-    element1 = StopContext.new
-    element2 = MethodContext.new(element1, [0, :bad])
-    element3 = BlockContext.new(element2, nil)
-    BlockContext.new(element3, nil).to_s.should match(/bad/)
+    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)).to_s.should match(/bad/)
+    end
   end
-end
 
-describe CodeContext, 'instance variables' do
-  it 'should pass instance variables down to the first class' do
-    element = StopContext.new
-    element = ModuleContext.new(element, Name.new(:mod))
-    class_element = ClassContext.new(element, [0, :klass])
-    element = MethodContext.new(class_element, [0, :bad])
-    element = BlockContext.new(element, nil)
-    element.record_instance_variable(:fred)
-    class_element.variable_names.size.should == 1
-    class_element.variable_names.should include(Name.new(:fred))
+  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
-end
 
-describe CodeContext, '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))
-    class_element = ClassContext.new(element, [0, :klass])
-    element = MethodContext.new(class_element, [0, :bad])
-    element = BlockContext.new(element, nil)
-    element.bananas(17, -5).should == 55
+  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
-end
 
-describe CodeContext do
-  it 'should recognise itself in a collection of names' do
-    element = StopContext.new
-    element = ModuleContext.new(element, Name.new(:mod))
-    element.matches?(['banana', 'mod']).should == true
-  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 itself in a collection of REs' do
-    element = StopContext.new
-    element = ModuleContext.new(element, Name.new(:mod))
-    element.matches?([/banana/, /mod/]).should == true
+    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
 
-  it 'should recognise its fq name in a collection of names' do
-    element = StopContext.new
-    element = ModuleContext.new(element, Name.new(:mod))
-    element = ClassContext.create(element, [0, :klass])
-    element.matches?(['banana', 'mod']).should == true
-    element.matches?(['banana', 'mod::klass']).should == true
+  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(:call, []) {|exp| raise "#{exp} yielded by empty module!"}
+      end
+      it 'yields one module' do
+        mods = 0
+        @ctx.each(:module, []) {|exp| mods += 1}
+        mods.should == 1
+      end
+      it "yields the module's full AST" do
+        @ctx.each(: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(: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(:if, []) {|exp| raise "#{exp} yielded by empty module!"}
+      end
+      it 'yields one module' do
+        @ctx.each(:module, []).length.should == 1
+      end
+      it "yields the module's full AST" do
+        @ctx.each(:module, []) {|exp| exp[1].should == @module_name.to_sym}
+      end
+      it 'yields one method' do
+        @ctx.each(:defn, []).length.should == 1
+      end
+      it "yields the method's full AST" do
+        @ctx.each(: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(: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
 
-  it 'should recognise its fq name in a collection of names' do
-    element = StopContext.new
-    element = ModuleContext.new(element, Name.new(:mod))
-    element = ClassContext.create(element, [0, :klass])
-    element.matches?([/banana/, /mod/]).should == true
-    element.matches?([/banana/, /mod::klass/]).should == true
+      ast = src.to_reek_source.syntax_tree
+      ctx = CodeContext.new(nil, ast)
+      ctx.each(:if, []).length.should == 3
+    end
   end
 end

data/spec/reek/code_parser_spec.rb

@@ -39,108 +39,6 @@ describe CodeParser do
 end
 
 describe CodeParser do
-  context 'with no class variables' do
-    it 'records nothing in the class' do
-      klass = ClassContext.from_s('class Fred; end')
-      klass.class_variables.should be_empty
-    end
-    it 'records nothing in the module' do
-      ctx = ModuleContext.from_s('module Fred; end')
-      ctx.class_variables.should be_empty
-    end
-  end
-
-  context 'with one class variable' do
-    shared_examples_for 'one variable found' do
-      it 'records the class variable' do
-        @ctx.class_variables.should include(Name.new(:@@tools))
-      end
-      it 'records only that class variable' do
-        @ctx.class_variables.length.should == 1
-      end
-    end
-
-    context 'declared in a class' do
-      before :each do
-        @ctx = ClassContext.from_s('class Fred; @@tools = {}; end')
-      end
-
-      it_should_behave_like 'one variable found'
-    end
-
-    context 'used in a class' do
-      before :each do
-        @ctx = ClassContext.from_s('class Fred; def jim() @@tools = {}; end; end')
-      end
-
-      it_should_behave_like 'one variable found'
-    end
-
-    context 'indexed in a class' do
-      before :each do
-        @ctx = ClassContext.from_s('class Fred; def jim() @@tools[mash] = {}; end; end')
-      end
-
-      it_should_behave_like 'one variable found'
-    end
-
-    context 'declared and used in a class' do
-      before :each do
-        @ctx = ClassContext.from_s('class Fred; @@tools = {}; def jim() @@tools = {}; end; end')
-      end
-
-      it_should_behave_like 'one variable found'
-    end
-
-    context 'used twice in a class' do
-      before :each do
-        @ctx = ClassContext.from_s('class Fred; def jeff() @@tools = {}; end; def jim() @@tools = {}; end; end')
-      end
-
-      it_should_behave_like 'one variable found'
-    end
-
-    context 'declared in a module' do
-      before :each do
-        @ctx = ClassContext.from_s('module Fred; @@tools = {}; end')
-      end
-
-      it_should_behave_like 'one variable found'
-    end
-
-    context 'used in a module' do
-      before :each do
-        @ctx = ClassContext.from_s('module Fred; def jim() @@tools = {}; end; end')
-      end
-
-      it_should_behave_like 'one variable found'
-    end
-
-    context 'indexed in a module' do
-      before :each do
-        @ctx = ClassContext.from_s('module Fred; def jim() @@tools[mash] = {}; end; end')
-      end
-
-      it_should_behave_like 'one variable found'
-    end
-
-    context 'declared and used in a module' do
-      before :each do
-        @ctx = ClassContext.from_s('module Fred; @@tools = {}; def jim() @@tools = {}; end; end')
-      end
-
-      it_should_behave_like 'one variable found'
-    end
-
-    context 'used twice in a module' do
-      before :each do
-        @ctx = ClassContext.from_s('module Fred; def jeff() @@tools = {}; end; def jim() @@tools = {}; end; end')
-      end
-
-      it_should_behave_like 'one variable found'
-    end
-  end
-
   context 'with no attributes' do
     it 'records nothing in the class' do
       klass = ClassContext.from_s('class Fred; end')

data/spec/reek/method_context_spec.rb

@@ -7,7 +7,7 @@ include Reek
 
 describe MethodContext, 'matching' do
   before :each do
-    @element = MethodContext.new(StopContext.new, [0, :mod])
+    @element = MethodContext.new(StopContext.new, s(0, :mod), s(:module, :mod, nil))
   end
 
   it 'should recognise itself in a collection of names' do
@@ -24,9 +24,9 @@ end
 describe MethodContext, 'matching fq names' do
   before :each do
     element = StopContext.new
-    element = ModuleContext.new(element, Name.new(:mod))
-    element = ClassContext.new(element, Name.new(:klass))
-    @element = MethodContext.new(element, [0, :meth])
+    element = ModuleContext.new(element, Name.new(:mod), s(:module, :mod, nil))
+    element = ClassContext.new(element, Name.new(:klass), s())
+    @element = MethodContext.new(element, s(0, :meth))
   end
 
   it 'should recognise itself in a collection of names' do

data/spec/reek/singleton_method_context_spec.rb

@@ -10,7 +10,7 @@ describe SingletonMethodContext, 'outer_name' do
 
   it "should report full context" do
     element = StopContext.new
-    element = ModuleContext.new(element, Name.new(:mod))
+    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.outer_name.should match(/mod::a\.b/)
   end