reek 1.3.4 → 1.3.5

data/spec/reek/source/sexp_node_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+require 'reek/source/sexp_node'
+
+include Reek::Source
+
+describe SexpNode do
+  context 'format' do
+    it 'formats self' do
+      @node = s(:self)
+      @node.extend(SexpNode)
+      @node.format_ruby.should == 'self'
+    end
+  end
+
+  context 'hash' do
+    it 'hashes equal for equal sexps' do
+      node1 = ast(:defn, s(:const2, :Fred, :jim), s(:call, :+, s(:lit, 4), :fred))
+      node2 = ast(:defn, s(:const2, :Fred, :jim), s(:call, :+, s(:lit, 4), :fred))
+      node1.hash.should == node2.hash
+    end
+    it 'hashes diferent for diferent sexps' do
+      node1 = ast(:defn, s(:const2, :Fred, :jim), s(:call, :+, s(:lit, 4), :fred))
+      node2 = ast(:defn, s(:const2, :Fred, :jim), s(:call, :+, s(:lit, 3), :fred))
+      node1.hash.should_not == node2.hash
+    end
+  end
+end
+

data/spec/reek/source/source_code_spec.rb

@@ -6,33 +6,73 @@ include Reek::Source
 
 describe SourceCode do
   context 'when the parser fails' do
+    let(:source_name) { 'Test source' }
+    let(:error_message) { 'Error message' }
+    let(:parser) { double('parser') }
+    let(:src) { SourceCode.new('', source_name, parser) }
+
     before :each do
       @catcher = StringIO.new
       @old_err_io = (SourceCode.err_io = @catcher)
-      parser = double('parser')
-      @error_message = 'Error message'
-      parser.should_receive(:parse).and_raise(SyntaxError.new(@error_message))
-      @source_name = 'Test source'
-      @src = SourceCode.new('', @source_name, parser)
-    end
-    it 'raises a SyntaxError' do
-      @src.syntax_tree
     end
-    it 'returns an empty syntax tree' do
-      @src.syntax_tree.should == s()
+
+    shared_examples_for "handling and recording the error" do
+      it 'does not raise an error' do
+        src.syntax_tree
+      end
+
+      it 'returns an empty syntax tree' do
+        src.syntax_tree.should == s()
+      end
+
+      it 'records the syntax error' do
+        src.syntax_tree
+        @catcher.string.should match(error_class.name)
+      end
+
+      it 'records the source name' do
+        src.syntax_tree
+        @catcher.string.should match(source_name)
+      end
+
+      it 'records the error message' do
+        src.syntax_tree
+        @catcher.string.should match(error_message)
+      end
     end
-    it 'records the syntax error' do
-      @src.syntax_tree
-      @catcher.string.should match(SyntaxError.name)
+
+    context "with a RubyParser::SyntaxError" do
+      let(:error_class) { RubyParser::SyntaxError }
+
+      before do
+        parser.stub(:parse).and_raise(error_class.new(error_message))
+      end
+
+      it_should_behave_like "handling and recording the error"
     end
-    it 'records the source name' do
-      @src.syntax_tree
-      @catcher.string.should match(@source_name)
+
+    context "with a Racc::ParseError" do
+      let(:error_class) { Racc::ParseError }
+
+      before do
+        parser.stub(:parse).and_raise(error_class.new(error_message))
+      end
+
+      it_should_behave_like "handling and recording the error"
     end
-    it 'records the error message' do
-      @src.syntax_tree
-      @catcher.string.should match(@error_message)
+
+    context "with a generic error" do
+      let(:error_class) { RuntimeError }
+
+      before do
+        parser.stub(:parse).and_raise(error_class.new(error_message))
+      end
+
+      it 'raises the error' do
+        expect { src.syntax_tree }.to raise_error
+      end
     end
+
     after :each do
       SourceCode.err_io = @old_err_io
     end

data/spec/reek/source/tree_dresser_spec.rb

@@ -4,322 +4,15 @@ require 'reek/source/tree_dresser'
 include Reek::Source
 
 describe TreeDresser do
-  before(:each) do
-    @dresser = TreeDresser.new
-  end
-  it 'maps :if to IfNode' do
-    @dresser.extensions_for(:if).should == 'IfNode'
-  end
-  it 'maps :call to CallNode' do
-    @dresser.extensions_for(:call).should == 'CallNode'
-  end
-end
-
-describe SexpNode do
-  context 'format' do
-    it 'formats self' do
-      @node = s(:self)
-      @node.extend(SexpNode)
-      @node.format_ruby.should == 'self'
-    end
-  end
-
-  context 'hash' do
-    it 'hashes equal for equal sexps' do
-      node1 = ast(:defn, s(:const2, :Fred, :jim), s(:call, :+, s(:lit, 4), :fred))
-      node2 = ast(:defn, s(:const2, :Fred, :jim), s(:call, :+, s(:lit, 4), :fred))
-      node1.hash.should == node2.hash
-    end
-    it 'hashes diferent for diferent sexps' do
-      node1 = ast(:defn, s(:const2, :Fred, :jim), s(:call, :+, s(:lit, 4), :fred))
-      node2 = ast(:defn, s(:const2, :Fred, :jim), s(:call, :+, s(:lit, 3), :fred))
-      node1.hash.should_not == node2.hash
-    end
-  end
-end
-
-describe SexpExtensions::DefnNode do
-  context 'with no parameters' do
-    before :each do
-      @node = s(:defn, :hello, s(:args))
-      @node.extend(SexpExtensions::DefnNode)
-    end
-    it 'has no arg names' do
-      @node.arg_names.should == s()
-    end
-    it 'has no parameter names' do
-      @node.parameter_names.should == s()
-    end
-    it 'includes outer scope in its full name' do
-      @node.full_name('Fred').should == 'Fred#hello'
-    end
-    it 'includes no marker in its full name with empty outer scope' do
-      @node.full_name('').should == 'hello'
-    end
-  end
-
-  context 'with 1 parameter' do
-    before :each do
-      @node = s(:defn, :hello, s(:args, :param))
-      @node.extend(SexpExtensions::DefnNode)
-    end
-    it 'has 1 arg name' do
-      @node.arg_names.should == s(:param)
-    end
-    it 'has 1 parameter name' do
-      @node.parameter_names.should == s(:param)
-    end
-    it 'includes outer scope in its full name' do
-      @node.full_name('Fred').should == 'Fred#hello'
-    end
-    it 'includes no marker in its full name with empty outer scope' do
-      @node.full_name('').should == 'hello'
-    end
-  end
-
-  context 'with a block' do
-    before :each do
-      @node = s(:defn, :hello, s(:args, :param, :"&blk"))
-      @node.extend(SexpExtensions::DefnNode)
-    end
-    it 'has 1 arg name' do
-      @node.arg_names.should == s(:param)
-    end
-    it 'has 2 parameter names' do
-      @node.parameter_names.should == s(:param, :"&blk")
-    end
-    it 'includes outer scope in its full name' do
-      @node.full_name('Fred').should == 'Fred#hello'
-    end
-    it 'includes no marker in its full name with empty outer scope' do
-      @node.full_name('').should == 'hello'
-    end
-  end
-
-  context 'with 1 defaulted parameter' do
-    before :each do
-      @node = s(:defn, :hello, s(:args, s(:lasgn, :param, s(:array))))
-      @node.extend(SexpExtensions::DefnNode)
-    end
-    it 'has 1 arg name' do
-      @node.arg_names.should == s(:param)
-    end
-    it 'has 1 parameter name' do
-      @node.parameter_names.should == s(:param)
-    end
-    it 'includes outer scope in its full name' do
-      @node.full_name('Fred').should == 'Fred#hello'
-    end
-    it 'includes no marker in its full name with empty outer scope' do
-      @node.full_name('').should == 'hello'
-    end
-  end
-
-  context 'with a body with 2 statements' do
-    before :each do
-      @node = s(:defn, :hello, s(:args), s(:first), s(:second))
-      @node.extend(SexpExtensions::DefnNode)
-    end
-
-    it 'has 2 body statements' do
-      @node.body.should == s(s(:first), s(:second))
-    end
-
-    it 'has a body extended with SexpNode' do
-      b = @node.body
-      (class << b; self; end).ancestors.first.should == SexpNode
-    end
-  end
-end
-
-describe SexpExtensions::DefsNode do
-  context 'with no parameters' do
-    before :each do
-      @node = s(:defs, :obj, :hello, s(:args))
-      @node.extend(SexpExtensions::DefsNode)
-    end
-    it 'has no arg names' do
-      @node.arg_names.should == s()
-    end
-    it 'has no parameter names' do
-      @node.parameter_names.should == s()
-    end
-    it 'includes outer scope in its full name' do
-      @node.full_name('Fred').should == 'Fred#obj.hello'
-    end
-    it 'includes no marker in its full name with empty outer scope' do
-      @node.full_name('').should == 'obj.hello'
-    end
-  end
-
-  context 'with 1 parameter' do
-    before :each do
-      @node = s(:defs, :obj, :hello, s(:args, :param))
-      @node.extend(SexpExtensions::DefsNode)
-    end
-    it 'has 1 arg name' do
-      @node.arg_names.should == s(:param)
-    end
-    it 'has 1 parameter name' do
-      @node.parameter_names.should == s(:param)
-    end
-    it 'includes outer scope in its full name' do
-      @node.full_name('Fred').should == 'Fred#obj.hello'
-    end
-    it 'includes no marker in its full name with empty outer scope' do
-      @node.full_name('').should == 'obj.hello'
-    end
-  end
-
-  context 'with a block' do
-    before :each do
-      @node = s(:defs, :obj, :hello, s(:args, :param, :"&blk"))
-      @node.extend(SexpExtensions::DefsNode)
-    end
-    it 'has 1 arg name' do
-      @node.arg_names.should == s(:param)
-    end
-    it 'has 2 parameter names' do
-      @node.parameter_names.should == s(:param, :"&blk")
-    end
-    it 'includes outer scope in its full name' do
-      @node.full_name('Fred').should == 'Fred#obj.hello'
-    end
-    it 'includes no marker in its full name with empty outer scope' do
-      @node.full_name('').should == 'obj.hello'
-    end
-  end
-
-  context 'with 1 defaulted parameter' do
-    before :each do
-      @node = s(:defs, :obj, :hello, s(:args, s(:lasgn, :param, s(:array))))
-      @node.extend(SexpExtensions::DefsNode)
-    end
-    it 'has 1 arg name' do
-      @node.arg_names.should == s(:param)
-    end
-    it 'has 1 parameter name' do
-      @node.parameter_names.should == s(:param)
-    end
-    it 'includes outer scope in its full name' do
-      @node.full_name('Fred').should == 'Fred#obj.hello'
-    end
-    it 'includes no marker in its full name with empty outer scope' do
-      @node.full_name('').should == 'obj.hello'
-    end
-  end
-
-  context 'with a body with 2 statements' do
-    before :each do
-      @node = s(:defs, s(:self), :hello, s(:args), s(:first), s(:second))
-      @node.extend(SexpExtensions::DefsNode)
-    end
-
-    it 'has 2 body statements' do
-      @node.body.should == s(s(:first), s(:second))
-    end
-
-    it 'has a body extended with SexpNode' do
-      b = @node.body
-      (class << b; self; end).ancestors.first.should == SexpNode
-    end
-  end
-end
-
-describe SexpExtensions::CallNode do
-  context 'with no parameters' do
-    before :each do
-      @node = s(:call, nil, :hello)
-      @node.extend(SexpExtensions::CallNode)
-    end
-    it 'has no parameter names' do
-      @node.parameter_names.should == nil
-    end
-  end
-
-  context 'with 1 literal parameter' do
-    before :each do
-      @node = s(:call, nil, :hello, s(:lit, :param))
-      @node.extend(SexpExtensions::CallNode)
-    end
-    it 'has 1 argument name' do
-      @node.arg_names.should == [:param]
-    end
-  end
-
-  context 'with 2 literal parameters' do
-    before :each do
-      @node = s(:call, nil, :hello, s(:lit, :x), s(:lit, :y))
-      @node.extend(SexpExtensions::CallNode)
-    end
-    it 'has 2 argument names' do
-      @node.arg_names.should == [:x, :y]
-    end
-  end
-end
-
-describe SexpExtensions::IterNode do
-  context 'with no parameters' do
-    before :each do
-      @node = s(:iter, s(), s(:args), s())
-      @node.extend(SexpExtensions::IterNode)
-    end
-    it 'has no parameter names' do
-      @node.parameter_names.should == []
-    end
-  end
-
-  context 'with 1 parameter' do
-    before :each do
-      @node = s(:iter, s(), s(:args, :param), s())
-      @node.extend(SexpExtensions::IterNode)
-    end
-    it 'has 1 parameter name' do
-      @node.parameter_names.should == s(:param)
-    end
-  end
-
-  context 'with 2 parameters' do
-    before :each do
-      @node = s(:iter, s(), s(:args, :x, :y), s())
-      @node.extend(SexpExtensions::IterNode)
-    end
-    it 'has 2 parameter names' do
-      @node.parameter_names.should == [:x, :y]
-    end
-  end
-end
+  let(:ifnode) { Sexp.new(:if) }
+  let(:callnode) { Sexp.new(:call) }
+  let(:dresser) { TreeDresser.new }
 
-describe SexpExtensions::ModuleNode do
-  context 'with a simple name' do
-    subject do
-      mod = ast(:module, :Fred, nil)
-      mod
-    end
-    its(:name) { should == :Fred }
-    its(:simple_name) { should == :Fred }
-    its(:text_name) { should == 'Fred' }
-    it 'has a simple full_name' do
-      subject.full_name('').should == 'Fred'
-    end
-    it 'has a fq full_name' do
-      subject.full_name('Blimey::O::Reilly').should == 'Blimey::O::Reilly::Fred'
-    end
+  it 'dresses :if sexp with IfNode' do
+    dresser.dress(ifnode).should be_a Reek::Source::SexpExtensions::IfNode
   end
 
-  context 'with a scoped name' do
-    subject do
-      mod = ast(:module, s(:colon2, s(:const, :Foo), :Bar), nil)
-      mod
-    end
-    its(:name) { should == s(:colon2, s(:const, :Foo), :Bar) }
-    its(:simple_name) { should == :Bar }
-    its(:text_name) { should == 'Foo::Bar' }
-    it 'has a simple full_name' do
-      subject.full_name('').should == 'Foo::Bar'
-    end
-    it 'has a fq full_name' do
-      subject.full_name('Blimey::O::Reilly').should == 'Blimey::O::Reilly::Foo::Bar'
-    end
+  it 'dresses :call sexp with CallNode' do
+    dresser.dress(callnode).should be_a Reek::Source::SexpExtensions::CallNode
   end
 end