alf 0.10.1 → 0.11.0

data/spec/unit/alf-core/operator/signature/test_collect_on.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+module Alf
+  module Operator
+    describe Signature, "#collect_on" do
+
+      subject{ op.class.signature.collect_on(op) }
+
+      let(:operands)  { subject[0] }
+      let(:arguments) { subject[1] }
+      let(:options)   { subject[2] }
+
+      describe "on a nullary op" do
+        let(:op){ NonRelational::Generator.new([], 10, :id) } 
+        specify { 
+          subject.should eq([[], [10, :id], {}]) 
+        }
+      end
+
+      describe "on a monadic op, with one arg" do
+        let(:op){ NonRelational::Autonum.new([:suppliers], :id) } 
+        it{ should eq([ [:suppliers], [:id], {} ]) }
+      end
+
+      describe "on a monadic op, with one arg and an option" do
+        let(:op){ 
+          Relational::Project.new([:suppliers], [:name, :city], :allbut => true) 
+        }
+        it{ should eq([[:suppliers], [AttrList[:name, :city]], {:allbut => true}]) }
+      end
+
+      describe "on a dyadic op" do
+        let(:op){ Relational::Join.new([:suppliers, :cities]) }
+        it{ should eq([[:suppliers, :cities], [], {}]) }
+      end
+
+    end
+  end # module Operator
+end # module Alf

data/spec/unit/alf-core/operator/signature/test_parse_args.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+module Alf
+  module Operator
+    describe Signature, "#parse_args" do
+
+      class FakeOp
+        attr_accessor :operands
+      end
+      let(:receiver){ FakeOp.new }
+
+      before{ 
+        signature.install
+      }
+      subject{
+        signature.parse_args(args, receiver)
+      }
+
+      context "on a signature with arguments only" do
+        let(:signature){ 
+          Signature.new(FakeOp) do |s|
+            s.argument :proj, AttrList
+          end
+        }
+        let(:args){ [ [:operand], ["hello", "world"] ] }
+
+        it 'should return the receiver' do
+          subject.should eq(receiver)
+        end
+
+        it "should set the operands" do
+          subject.operands.should eq([:operand])
+        end
+
+        it 'should set the arguments' do
+          subject.proj.should eq(AttrList[:hello, :world]) 
+        end
+      end # arguments only
+
+      context "with default values for arguments" do
+        let(:signature){ 
+          Signature.new(FakeOp) do |s|
+            s.argument :attrname, AttrName, :autonum
+          end
+        }
+
+        context 'and passed' do
+          let(:args){ [[:operand], "hello"] }
+
+          it 'should not use the default value' do
+            subject.attrname.should eq(:hello) 
+          end
+        end
+
+        context 'and not passed' do
+          let(:args){ [[:operand]] }
+
+          it 'should use the default value' do
+            subject.attrname.should eq(:autonum) 
+          end
+        end
+      end # default values for arguments
+
+      context "on a signature with options" do
+        let(:signature){
+          Signature.new(FakeOp) do |s|
+            s.argument :key, AttrList, []
+            s.option   :allbut, Boolean, false
+          end
+        }
+
+        context "when no option is provided" do
+          let(:args){ [[:operand], [:hello, :world]] }
+
+          it 'should use the default values for options' do
+            subject.allbut.should eql(false)
+          end
+        end
+
+        context "when option is provided" do
+          let(:args){ [[:operand], [:hello, :world], {:allbut => true}] }
+
+          it 'should not use the default values for options' do
+            subject.allbut.should eql(true)
+          end
+        end
+      end # signature with options
+
+    end
+  end
+end

data/spec/unit/alf-core/reader/test_looks_a_path.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Alf
+  describe Reader, "looks_a_path?" do
+
+    it 'should recognize strings' do
+      Reader.send(:looks_a_path?, "path/to/a/file.rash").should be_true
+    end
+
+    it 'should recognize XXX#path' do
+      obj = Object.new
+      def obj.to_path; end
+      Reader.send(:looks_a_path?, obj).should be_true
+    end
+
+    it 'should not recognize StringIO' do
+      Reader.send(:looks_a_path?, StringIO.new("")).should be_false
+    end
+
+  end
+end

data/spec/unit/alf-core/test_aggregator.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+module Alf
+  describe Aggregator do
+
+    let(:input){[
+      {:a => 1, :sign => -1},
+      {:a => 2, :sign => 1 },
+      {:a => 3, :sign => -1},
+      {:a => 1, :sign => -1},
+    ]}
+
+    it "should keep track of registered aggregators" do
+      Aggregator.aggregators.should_not be_empty
+      Aggregator.each do |agg|
+        agg.should be_a(Class)
+      end
+    end
+
+    it "should allow specific tuple computations" do
+      Aggregator.sum{ 1.0 * a * sign }.aggregate(input).should == -3.0
+    end
+
+    describe "coerce" do
+     
+      subject{ Aggregator.coerce(arg) }
+      
+      describe "from an Aggregator" do
+        let(:arg){ Aggregator.sum{a} }
+        it{ should eq(arg) }
+      end
+      
+      describe "from a String" do
+        let(:arg){ "sum{a}" }
+
+        it { 
+          should be_a(Aggregator::Sum) 
+        }
+
+        it 'should have source code' do
+          subject.has_source_code!.should eq("sum{a}")
+        end
+
+        specify{ 
+          subject.aggregate(input).should eql(7) 
+        }
+
+      end
+      
+    end
+
+    it 'should implement optimistic equality based on source code' do
+      ag1 = Aggregator.coerce("sum{ qty }")
+      ag2 = Aggregator.coerce("sum{ qty }")
+      ag1.should eq(ag2)
+    end
+
+  end
+end

data/spec/unit/{test_environment.rb → alf-core/test_environment.rb}

@@ -1,43 +1,30 @@
 require 'spec_helper'
 module Alf
   describe Environment do
-    
-    subject{ Environment }
-    it { should respond_to(:folder) }
-      
-    describe "folder" do
-      subject{ Environment.folder(File.dirname(__FILE__)) }
-      it{ should be_a(Environment::Folder) }
-    end
-    
+
     describe "autodetect" do
-      
+
       it "should support an Environment instance" do
         env = Environment.examples
         Environment.autodetect(env).should eq(env)
       end
-      
+
       it "should recognize an existing folder" do
         env = Environment.autodetect(File.dirname(__FILE__))
         env.should be_a(Environment::Folder)
       end
-      
-      it "should recognize a sqlite file" do
-        env = Environment.autodetect(_("sequel/alf.db", __FILE__))
-        env.should be_a(Sequel::Environment)
-      end
-      
+
       it "should raise an Argument when no match" do
         lambda{ Environment.autodetect(12) }.should raise_error(ArgumentError)
       end
-      
+
       it "should be aliased as coerce" do
         env = Environment.examples
         Environment.coerce(env).should eq(env)
         Environment.coerce(File.dirname(__FILE__)).should be_a(Environment::Folder)
       end
-      
-    end
+
+    end # autodetect
 
   end
-end
+end

data/spec/unit/alf-core/tools/test_class_name.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+module Alf
+  describe Tools, "class_name" do
+
+    let(:tools){ Object.new.extend(Tools) }
+
+    it "should work on top-level namespaces" do
+      tools.class_name(Alf).should eq(:Alf)
+    end
+
+    it "should work on non top-level namespaces" do
+      tools.class_name(Alf::Tools).should eq(:Tools)
+    end
+
+  end
+end

data/spec/unit/{tools → alf-core/tools}/test_coalesce.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 module Alf
-  describe "Tools#coalesce" do
+  describe Tools, "coalesce" do
     
     it "should support a varargs variant" do
       Tools.coalesce(:a, nil, :b, :c).should eql(:a)
@@ -11,5 +11,9 @@ module Alf
       Tools.coalesce(nil){ :hello }.should eql(:hello)
     end
     
+    it "should return nil otherwise" do
+      Tools.coalesce(nil).should be_nil
+    end
+
   end
-end
+end

data/spec/unit/alf-core/tools/test_coerce.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+module Alf
+  describe "Tools#coerce" do
+
+    it 'should coerce integers without trouble' do
+      Tools.coerce("12", Integer).should eql(12)
+    end
+
+    it 'should raise a Alf::CoercionError in case of error' do
+      lambda{ 
+        Tools.coerce("abc", Integer)
+      }.should raise_error(Alf::CoercionError)
+    end
+
+  end
+end

data/spec/unit/alf-core/tools/test_ruby_case.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+module Alf
+  describe Tools, "ruby_case" do
+
+    let(:tools){ Object.new.extend(Tools) }
+
+    it "should work on one word" do
+      tools.ruby_case(:Alf).should == "alf"
+    end
+
+    it "should work on multiple words" do
+      tools.ruby_case(:HelloWorld).should == "hello_world"
+    end
+
+  end
+end

data/spec/unit/{tools → alf-core/tools}/test_to_lispy.rb

@@ -1,11 +1,18 @@
 require 'spec_helper'
 module Alf
   describe Tools, ".to_lispy" do
-    
+
+    it "should have a valid example" do
+      expr = Alf.lispy.compile{ 
+       (project :suppliers, [:name])
+      }
+      Tools.to_lispy(expr).should eq("(project :suppliers, [:name])")
+    end
+
     subject{ Tools.to_lispy(value) } 
-    
+
     describe "on a Proxy" do
-      let(:value){ Iterator::Proxy.new(nil, :suppliers) }
+      let(:value){ Iterator::Proxy.new(Environment.examples, :suppliers) }
       it { should eq(":suppliers") }
     end
 
@@ -115,22 +122,22 @@ module Alf
     end # Summarization
 
     describe "on an nullary operator" do
-      let(:value){ Alf.lispy.run(%w{generator -- 10 -- id}) } 
+      let(:value){ Alf::Operator::NonRelational::Generator.new([], 10, :id) } 
       it { should eq("(generator 10, :id)") }
     end
 
     describe "on an monadic operator with an option" do
-      let(:value){ Alf.lispy.run(%w{project --allbut suppliers -- city}) } 
+      let(:value){ Alf::Operator::Relational::Project.new([:suppliers], [:city], :allbut => true) } 
       it { should eq("(project :suppliers, [:city], {:allbut => true})") }
     end
 
     describe "on an monadic operator with default values for options" do
-      let(:value){ Alf.lispy.run(%w{project suppliers -- city}) } 
+      let(:value){ Alf::Operator::Relational::Project.new([:suppliers], [:city]) } 
       it { should eq("(project :suppliers, [:city])") }
     end
 
     describe "on an dyadic operator without no args nor any option" do
-      let(:value){ Alf.lispy.run(%w{join suppliers cities}) } 
+      let(:value){ Alf::Operator::Relational::Join.new([:suppliers, :cities]) } 
       it { should eq("(join :suppliers, :cities)") }
     end
 

data/spec/unit/{tools → alf-core/tools}/test_to_ruby_literal.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 module Alf
   describe "Tools#to_ruby_literal" do
-    
-    specify {
+
+    it 'should work on Integers' do
       Tools.to_ruby_literal(12).should eql("12")
-    }
-    
+    end
+
   end
-end
+end

data/spec/unit/{tools → alf-core/tools}/test_tuple_handle.rb

@@ -2,15 +2,15 @@ require 'spec_helper'
 module Alf
   module Tools
     describe TupleHandle do
-  
+
       let(:handle){ TupleHandle.new }
-  
+
       it "should install methods properly" do
         handle.set(:hello => "a", :world => "b")
         handle.should respond_to(:hello)
         handle.should respond_to(:world)
       end
-  
+
       it "should behave correctly" do
         handle.set(:hello => "a", :world => "b")
         handle.hello.should == "a"
@@ -19,34 +19,34 @@ module Alf
         handle.hello.should == "c"
         handle.world.should == "d"
       end
-  
+
       it "should allow instance evaluating on exprs" do
         handle.set(:tested => 1)
         handle.instance_eval{ tested < 1 }.should be_false
       end
-  
+
       it "should support an attribute called :path" do
         handle.set(:path => 1)
         handle.instance_eval{ path < 1 }.should be_false
       end
-    
+
       describe "evaluate" do
         before{ handle.set(:a => 1, :b => 2) }
-        
+
         it "should allow a String" do
           handle.evaluate("a").should == 1
         end
-        
+
         it "should allow a Symbol" do
           handle.evaluate(:a).should == 1
         end
-        
+
         it "should allow a Proc" do
           handle.evaluate(lambda{ a }).should == 1
         end
-        
-      end
-  
-    end   
+
+      end # evaluate
+
+    end
   end
-end
+end

data/spec/unit/alf-core/tools/test_tuple_heading.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+module Alf
+  describe Tools, "tuple_heading" do
+
+    it 'should work on the empty tuple' do
+      Tools.tuple_heading({}).should eq(Heading::EMPTY)
+    end
+
+    it 'should work on a supplier-like tuple' do
+      expected = Heading[:name => String, :old => FalseClass]
+      Tools.tuple_heading(:name => "Jones", :old => false).should eq(expected)
+    end
+
+  end
+end

data/spec/unit/{tools → alf-core/tools}/test_varargs.rb

@@ -1,16 +1,19 @@
 require 'spec_helper'
 module Alf
   describe "Tools#varargs" do
-    
-    specify "with exact args" do
+
+    it "should work with exact arguments" do
       Tools.varargs([1, "hello"], [Integer, String]).should eq([1, "hello"])
     end
-    
-    specify "with missing args" do
+
+    it "should work when some args are missing" do
       Tools.varargs(["hello"], [Integer, String]).should eq([nil, "hello"])
-      Tools.varargs([], [Integer, String]).should eq([nil, nil])
       Tools.varargs([1, 2], [Integer, String, Integer]).should eq([1, nil, 2])
     end
 
+    it 'should work when no arguments are passed at all' do
+      Tools.varargs([], [Integer, String]).should eq([nil, nil])
+    end
+
   end
-end
+end