wool 0.5.1

data/spec/analysis_specs/protocol_registry_spec.rb

@@ -0,0 +1,58 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'ostruct'
+
+describe ProtocolRegistry do
+  before(:each) do
+    @backup_all = ProtocolRegistry.protocols.dup
+    @backup_map = ProtocolRegistry.class_protocols.dup
+    
+    ProtocolRegistry.protocols = []
+    ProtocolRegistry.class_protocols = {}
+  end
+  
+  after(:each) do
+    ProtocolRegistry.protocols = @backup_all
+    ProtocolRegistry.class_protocols = @backup_map
+  end
+  
+  context '#add_protocol' do
+    it 'adds a protocol to the main protocol list' do
+      x = Object.new
+      ProtocolRegistry.add_protocol x
+      ProtocolRegistry.protocols.should include(x)
+    end
+  end
+  
+  context '#add_class_protocol' do
+    it 'adds a protocol to the main protocol list, and adds a shortcut in the class map' do
+      x = OpenStruct.new
+      x.class_used = OpenStruct.new
+      x.class_used.path = 'SuperPath'
+      ProtocolRegistry.add_class_protocol x
+      ProtocolRegistry.protocols.should include(x)
+      ProtocolRegistry.class_protocols['SuperPath'].should == x
+    end
+  end
+  
+  context '#[]' do
+    it 'looks up quick queries by class path' do
+      x = OpenStruct.new
+      x.class_used = OpenStruct.new
+      x.class_used.path = 'SuperPath'
+      ProtocolRegistry.add_class_protocol x
+      ProtocolRegistry['SuperPath'].should == [x]
+    end
+  end
+  
+  context '#query' do
+    context 'with :class_path specified' do
+      it 'finds the classes in the registry with the given path' do
+        x = OpenStruct.new
+        x.class_used = OpenStruct.new
+        x.class_used.path = 'SuperPath'
+        ProtocolRegistry.add_class_protocol x
+        ProtocolRegistry.query(:class_path => 'SuperPath').should == [x]
+      end
+    end
+  end
+end

data/spec/analysis_specs/protocols_spec.rb

@@ -0,0 +1,49 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Protocols::ClassProtocol do
+  before do
+    a = WoolClass.new('A')
+    @a_proto = a.protocol
+    b = WoolClass.new('B') do |b|
+      b.add_method(WoolMethod.new('foo') do |method|
+        method.add_signature(@a_proto, [])
+        method.add_signature(b.protocol, [@a_proto])
+      end)
+      b.add_method(WoolMethod.new('bar') do |method|
+        method.add_signature(b.protocol, [@a_proto, b.protocol])
+      end)
+    end
+    @b_proto = b.protocol
+  end
+  
+  context '#signatures' do
+    it 'returns an empty list when no methods are declared' do
+      @a_proto.signatures.should be_empty
+    end
+    
+    it "gets its class's signatures when they are specified, which are its methods' signatures" do
+      @b_proto.signatures.should include(Signature.new('foo', @a_proto, []))
+      @b_proto.signatures.should include(Signature.new('foo', @b_proto, [@a_proto]))
+      @b_proto.signatures.should include(Signature.new('bar', @b_proto, [@a_proto, @b_proto]))
+    end
+  end
+end
+
+describe Protocols::UnionProtocol do
+  before do
+    @first, @second, @third = mock(:proto1), mock(:proto2), mock(:proto3)
+    @union = Protocols::UnionProtocol.new([@first, @second, @third])
+  end
+  
+  context '#signatures' do
+    it "returns the union of all the protocols' signatures" do
+      sigs = mock(:sig1), mock(:sig2), mock(:sig3), mock(:sig4), mock(:sig5), mock(:sig6)
+      [@first, @second, @third].each_with_index do |proto, idx|
+        proto.should_receive(:signatures).and_return(sigs[idx * 2, 3])
+      end
+      final_sigs = @union.signatures
+      sigs.each {|sig| final_sigs.should include(sig)}
+    end
+  end
+end
+    

data/spec/analysis_specs/scope_spec.rb

@@ -0,0 +1,20 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Scope::GlobalScope do
+  it 'is a Scope object' do
+    Scope::GlobalScope.should be_a(Scope)
+  end
+  
+  it 'has no parent' do
+    Scope::GlobalScope.parent.should be_nil
+  end
+  
+  it 'has a self pointer that is an Object' do
+    # self_ptr is a Symbol
+    Scope::GlobalScope.self_ptr.class_used.path.should == 'Object'
+  end
+  
+  it 'has Object in its constants table' do
+    Scope::GlobalScope.constants['Object'].should_not be_nil
+  end
+end

data/spec/analysis_specs/sexp_analysis_spec.rb

@@ -0,0 +1,134 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe SexpAnalysis do
+  describe Sexp do
+    before do
+      @sexp = Sexp.new([:if, [:abc, 2, 3], [:def, 4, 5], nil])
+    end
+    
+    describe '#type' do
+      it 'returns the type of the sexp' do
+        @sexp.type.should == :if
+        @sexp[1].type.should == :abc
+        @sexp[2].type.should == :def
+      end
+    end
+    
+    describe '#children' do
+      it 'returns the children of a normal sexp' do
+        @sexp.children.should == [[:abc, 2, 3], [:def, 4, 5], nil]
+        @sexp[1].children.should == [2, 3]
+        @sexp[2].children.should == [4, 5]
+      end
+      
+      it 'returns everything in an array if a whole-array sexp' do
+        Sexp.new([[:abc], 2, 3, [:def, 3, 4]]).children.should == [[:abc], 2, 3, [:def, 3, 4]]
+      end
+    end
+    
+    context 'with annotations' do
+      describe '#initialize' do
+        before do
+          annotator_1, annotator_2 = Object.new, Object.new
+          def annotator_1.annotate!(node)
+            x = node[0]
+            def x.weird_thing!
+              "silly!"
+            end
+            def x.weird_thing_2!
+              "hello"
+            end
+          end
+          def annotator_2.annotate!(node)
+            x = node[0]
+            def x.weird_thing_2!
+              "world"
+            end
+          end
+          @old_annotations, Sexp.annotations = Sexp.annotations, [annotator_1, annotator_2]
+        end
+        
+        after do
+          Sexp.annotations = @old_annotations
+        end
+        
+        it 'runs the annotators in order' do
+          x = Object.new
+          def x.name; "x"; end
+          result = Sexp.new([x])
+          x.weird_thing!.should == "silly!"
+          x.weird_thing_2!.should == "world"
+        end
+      end
+      
+      context '#eval_as_constant' do
+        it 'converts :var_ref constants' do
+          result = mock
+          scope = Scope.new(nil, nil, {'B' => result})
+          sexp = Sexp.new([:var_ref, [:@const, 'B', [1, 17]]])
+          sexp.eval_as_constant(scope).should == result
+        end
+
+        it 'converts :const_ref constants' do
+          result = mock
+          scope = Scope.new(nil, nil, {'C' => result})
+          sexp = Sexp.new([:const_ref, [:@const, 'C', [4, 17]]])
+          sexp.eval_as_constant(scope).should == result
+        end
+        
+        it 'converts :top_const_ref constants' do
+          result = mock
+          Scope::GlobalScope.constants['__testing_ref__'] = result
+          sexp = Sexp.new([:top_const_ref, [:@const, '__testing_ref__', [4, 17]]])
+          sexp.eval_as_constant(nil).should == result
+        end
+        
+        it 'converts :const_path_ref constants' do
+          input = [:const_path_ref, [:const_path_ref, [:const_path_ref, [:const_path_ref,
+                   [:var_ref, [:@const, "B", [1, 7]]], [:@const, "M", [1, 10]]],
+                   [:@const, "C", [1, 13]]], [:@const, "D", [1, 16]]], [:@const, "E", [1, 19]]]
+          global, b_sym, m_sym, c_sym, d_sym, e_sym = mock, mock, mock, mock, mock, mock
+          b_scope, m_scope, c_scope, d_scope = mock, mock, mock, mock
+          global.should_receive(:constants).and_return({'B' => b_sym})
+          b_sym.should_receive(:scope).and_return(b_scope)
+          b_scope.should_receive(:constants).and_return({'M' => m_sym})
+          m_sym.should_receive(:scope).and_return(m_scope)
+          m_scope.should_receive(:constants).and_return({'C' => c_sym})
+          c_sym.should_receive(:scope).and_return(c_scope)
+          c_scope.should_receive(:constants).and_return({'D' => d_sym})
+          d_sym.should_receive(:scope).and_return(d_scope)
+          d_scope.should_receive(:constants).and_return({'E' => e_sym})
+          sexp = Sexp.new(input)
+          sexp.eval_as_constant(global).should == e_sym
+        end
+      end
+    end
+  end
+  
+  before do
+    @class = Class.new do
+      include SexpAnalysis
+      attr_accessor :body
+      def initialize(body)
+        self.body = body
+      end
+    end
+  end
+
+  context '#parse' do
+    it 'parses its body' do
+      @class.new('a').parse.should ==
+          [:program, [[:var_ref, [:@ident, "a", [1, 0]]]]]
+    end
+  end
+
+  context '#find_sexps' do
+    it 'searches its body' do
+      @class.new('a + b').find_sexps(:binary).should_not be_empty
+    end
+
+    it 'returns an empty array if no sexps are found' do
+      @class.new('a + b').find_sexps(:rescue).should be_empty
+    end
+  end
+end

data/spec/analysis_specs/spec_helper.rb

@@ -0,0 +1,2 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+include SexpAnalysis

data/spec/analysis_specs/visitor_spec.rb

@@ -0,0 +1,53 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Visitor do
+  before do
+    @class = Class.new do
+      include Visitor
+      def visit_foo(node)
+        node.visited = node[1]
+      end
+      def visit_bar(node)
+        node.product = node[1] * node[2]
+      end
+    end
+  end
+  
+  context '#visit' do
+    it 'runs the matching method when one is defined' do
+      a = Sexp.new([:foo, true])
+      a.should_receive(:visited=).with(true)
+      @class.new.visit(a)
+      b = Sexp.new([:bar, 3, 2])
+      b.should_receive(:product=).with(6)
+      @class.new.visit(b)
+    end
+    
+    it 'automatically DFSs the tree to visit nodes when they are not handled' do
+      a = Sexp.new([:a, [:b, [:foo, false], 2, 3], [:c, [:bar, 19, 22], [:bar, 23, 2]]])
+      a[1][1].should_receive(:visited=).with(false)
+      a[2][1].should_receive(:product=).with(19 * 22)
+      a[2][2].should_receive(:product=).with(46)
+      @class.new.visit(a)
+    end
+    
+    it 'calls #default_visit when it encounters an unknown AST node' do
+      klass = Class.new do
+        include Visitor
+        def default_visit(node)
+          node.count = (@count ||= 1)
+          @count += 1
+          node.children.select {|x| Sexp === x}.each {|x| visit(x)}
+        end
+        def visit_bar(node)
+        end
+      end
+      a = Sexp.new([:a, [:b, [:foo, false], 2, 3], [:c, [:bar, 19, 22], [:bar, 23, 2]]])
+      a.should_receive(:count=).with(1)
+      a[1].should_receive(:count=).with(2)
+      a[1][1].should_receive(:count=).with(3)
+      a[2].should_receive(:count=).with(4)
+      klass.new.visit(a)
+    end
+  end
+end

data/spec/analysis_specs/wool_class_spec.rb

@@ -0,0 +1,54 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'pp'
+
+describe WoolClass do
+  before do
+    @a = WoolClass.new('A')
+    @b = WoolClass.new('B') do |b|
+      b.add_method(WoolMethod.new('foo') do |method|
+        method.add_signature(@a.protocol, [])
+        method.add_signature(b.protocol, [@a.protocol])
+      end)
+      b.add_method(WoolMethod.new('bar') do |method|
+        method.add_signature(b.protocol, [@a.protocol, b.protocol])
+      end)
+    end
+  end
+  
+  context '#signatures' do
+    it 'returns an empty list when no methods are declared' do
+      @a.signatures.should be_empty
+    end
+    
+    it "flattens all its method's signatures" do
+      @b.signatures.should include(Signature.new('foo', @a.protocol, []))
+      @b.signatures.should include(Signature.new('foo', @b.protocol, [@a.protocol]))
+      @b.signatures.should include(
+          Signature.new('bar', @b.protocol, [@a.protocol, @b.protocol]))
+    end
+  end
+end
+
+describe WoolMethod do
+  before do
+    @a = WoolClass.new('A')
+    @b = WoolClass.new('B')
+    @method = WoolMethod.new('foobar')
+  end
+  
+  context '#add_signature' do
+    it 'creates signature objects and returns them in #signatures' do
+      @method.add_signature(@a.protocol, [])
+      @method.add_signature(@b.protocol, [@a.protocol, @a.protocol])
+      @method.signatures.should include(Signature.new('foobar', @a.protocol, []))
+      @method.signatures.should include(
+          Signature.new('foobar', @b.protocol, [@a.protocol, @a.protocol]))
+    end
+  end
+  
+  context '#name' do
+    it 'returns the name' do
+      @method.name.should == 'foobar'
+    end
+  end
+end

data/spec/rake_specs/spec_helper.rb

@@ -0,0 +1 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')

data/spec/rake_specs/task_spec.rb

@@ -0,0 +1,67 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'rubygems'
+require 'rake'
+require 'tmpdir'
+require 'wool/rake/task'
+
+describe Rake::WoolTask do
+  context '#initialize' do
+    it 'yields to allow setting :libs and :extras' do
+      task_name = "temptask1-#{rand(65329)}".to_sym
+      task = Rake::WoolTask.new(task_name) do |wool|
+        wool.libs = "LOL"
+        wool.extras = "hai"
+      end
+      task.settings.libs.should == "LOL"
+      task.settings.extras.should == "hai"
+    end
+
+    it 'creates a Rake task with the given name that calls #run' do
+      task_name = "temptask2_#{rand(65000)}".to_sym
+      task = Rake::WoolTask.new(task_name)
+      Rake::Task[task_name].should_not be_nil
+      task.should_receive(:run)
+      Rake::Task[task_name].invoke
+    end
+
+    it 'allows you to specify which warnings to use' do
+      task_name = "temptask3_#{rand(65000)}".to_sym
+      task = Rake::WoolTask.new(task_name) do |wool|
+        wool.using << :one << :two
+      end
+      task.settings.using.should == [:one, :two]
+    end
+
+    it 'defaults to using all warnings' do
+      task_name = "temptask4_#{rand(65000)}".to_sym
+      task = Rake::WoolTask.new(task_name) do |wool|
+      end
+      task.settings.using.should == [:all]
+    end
+  end
+
+  context '#run' do
+    it 'searches the listed libraries for files' do
+      Dir.should_receive(:[]).with('lib/**/*.rb').and_return([])
+      Dir.should_receive(:[]).with('spec/**/*.rb').and_return([])
+      task = Rake::WoolTask.new("temptask3-#{rand(65329)}".to_sym) do |wool|
+        wool.libs << 'lib' << 'spec'
+      end
+      swizzling_io { task.run }
+    end
+
+    it 'scans the matching files' do
+      test_file = File.open(File.join(Dir.tmpdir, 'test_input'), 'w') do |fp|
+        fp << 'a + b  '
+      end
+      Dir.should_receive(:[]).with('lib/**/*.rb').and_return([File.join(Dir.tmpdir, 'test_input')])
+      Dir.should_receive(:[]).with('spec/**/*.rb').and_return([])
+      task = Rake::WoolTask.new("temptask4-#{rand(65329)}".to_sym) do |wool|
+        wool.libs << 'lib' << 'spec'
+      end
+      printout = swizzling_io { task.run }
+      printout.should =~ /whitespace/
+      printout.should =~ /1 are fixable/
+    end
+  end
+end