alf 0.9.3 → 0.10.0

data/spec/unit/tools/test_to_lispy.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+module Alf
+  describe Tools, ".to_lispy" do
+    
+    subject{ Tools.to_lispy(value) } 
+    
+    describe "on a Proxy" do
+      let(:value){ Iterator::Proxy.new(nil, :suppliers) }
+      it { should eq(":suppliers") }
+    end
+
+    describe "on an AttrName" do
+      let(:value){ :city }
+      it { should eq(":city") }
+    end
+
+    describe "on an AttrList" do
+      let(:value){ AttrList.new([:name, :city]) }
+      it { should eq("[:name, :city]") }
+    end
+
+    describe "on a Heading" do
+      let(:value){ Heading.new(:name => String) }
+      it { should eq("{:name => String}") }
+    end
+
+    describe "on an Ordering" do
+      let(:value){ Ordering.new([[:name, :asc], [:city, :desc]]) }
+      it { should eq("[[:name, :asc], [:city, :desc]]") }
+    end
+
+    describe "on a Renaming" do
+      let(:value){ Renaming.new(:old => :new) }
+      it { should eq("{:old => :new}") }
+    end
+
+    describe "on an Aggregation" do
+      let(:value){ Aggregator.coerce("sum{ qty*price }") }
+      it { should eq("sum{ qty*price }") }
+    end
+
+    describe "on a TupleExpression" do
+      let(:value){ TupleExpression.coerce(arg) }
+
+      describe "When built from a string" do
+        let(:arg){ "status.upcase" }
+        it{ should eq("->(){ status.upcase }")}
+      end
+
+      describe "When built from a symbol" do
+        let(:arg){ :status }
+        it{ should eq("->(){ status }")}
+      end
+
+    end # TupleExpression
+
+    describe "on a TuplePredicate" do
+      let(:value){ TuplePredicate.coerce(arg) }
+
+      describe "When built from a TupleExpression" do
+        let(:arg){ TupleExpression.coerce("status > 10") }
+        it{ should eq("->(){ status > 10 }")}
+      end
+
+      describe "When built from a boolean" do
+        let(:arg){ true }
+        it{ should eq("->(){ true }")}
+      end
+
+      describe "When built from a String" do
+        let(:arg){ "status > 10" }
+        it{ should eq("->(){ status > 10 }")}
+      end
+
+      describe "When built from a Hash" do
+        let(:arg){ {:status => 10} }
+        it{ should eq("->(){ (self.status == 10) }")}
+      end
+
+      describe "When built with a singleton Array" do
+        let(:arg){ ["status > 10"] }
+        it{ should eq("->(){ status > 10 }")}
+      end
+
+      describe "When built with a Hash-Array" do
+        let(:arg){ ["status", "10"] }
+        it{ should eq("->(){ (self.status == 10) }")}
+      end
+
+      describe "When built with a Hash-Array without coercion" do
+        let(:arg){ [:status, "10"] }
+        it{ should eq("->(){ (self.status == \"10\") }")}
+      end
+
+    end # TuplePredicate
+
+    describe "on a TupleComputation" do
+      let(:value){ TupleComputation.coerce(arg) }
+
+      describe "When built from a Hash" do
+        let(:arg){ {"upcased" => "status.upcase"} }
+        it{ should eq("{:upcased => ->(){ status.upcase }}")}
+      end
+
+    end # TupleComputation
+
+    describe "on a Summarization" do
+      let(:value){ Summarization.coerce(arg) }
+
+      describe "When built from an Array" do
+        let(:arg){ {"total" => "sum{ qty*price }"} }
+        it{ should eq("{:total => sum{ qty*price }}") }
+      end
+
+    end # Summarization
+
+    describe "on an nullary operator" do
+      let(:value){ Alf.lispy.run(%w{generator -- 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}) } 
+      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}) } 
+      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}) } 
+      it { should eq("(join :suppliers, :cities)") }
+    end
+
+  end
+end

data/spec/unit/tools/test_to_ruby_literal.rb

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

data/spec/unit/tools/test_tuple_handle.rb

@@ -29,47 +29,7 @@ module Alf
         handle.set(:path => 1)
         handle.instance_eval{ path < 1 }.should be_false
       end
-  
-      describe "compile" do
-        
-        it "should return a Proc when passed a string" do
-          TupleHandle.compile("true").should be_a(Proc)
-        end
-        
-        it "should return the Proc when directly passed" do
-          x = lambda{ true }
-          TupleHandle.compile(x).should == x
-        end
-        
-        it "should support an empty Hash" do
-          pred = TupleHandle.compile({})
-          pred.call.should be_true
-        end
-        
-        it "should support a Hash" do
-          pred = TupleHandle.compile({:status => 10})
-          handle = TupleHandle.new
-          handle.set({:status => 20}).evaluate(pred).should be_false
-          handle.set({:status => 10}).evaluate(pred).should be_true
-        end
-        
-        it "should support a Hash using keywords as attribute names" do
-          pred = TupleHandle.compile({:when => 10})
-          handle = TupleHandle.new
-          handle.set({:when => 20}).evaluate(pred).should be_false
-          handle.set({:when => 10}).evaluate(pred).should be_true
-        end
-  
-        it "should support a Hash containing a Date" do
-          today = Date.today
-          pred = TupleHandle.compile({:at => today})
-          handle = TupleHandle.new
-          handle.set({:at => today}).evaluate(pred).should be_true
-          handle.set({:at => today+1}).evaluate(pred).should be_false
-        end
-  
-      end
-  
+    
       describe "evaluate" do
         before{ handle.set(:a => 1, :b => 2) }
         
@@ -85,24 +45,6 @@ module Alf
           handle.evaluate(lambda{ a }).should == 1
         end
         
-        it "should allow a Hash" do
-          handle.evaluate(:a => 1).should == true
-          handle.evaluate(:a => 2).should == false
-          handle.evaluate(:a => 1, :b => 1).should == false
-          handle.evaluate(:a => 1, :b => 2).should == true
-        end
-        
-        it "should allow an Array" do
-          handle.evaluate([:a, 1]).should == true
-          handle.evaluate([:a, 2]).should == false
-          handle.evaluate([:a, 1, :b, 1]).should == false
-          handle.evaluate([:a, 1, :b, 2]).should == true
-        end
-        
-        it "should allow the result of compile" do
-          handle.evaluate(TupleHandle.compile('a')).should == 1
-        end
-  
       end
   
     end   

data/spec/unit/types/test_attr_list.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+module Alf
+  describe AttrList do
+
+    describe "coerce" do
+      
+      subject{ AttrList.coerce(arg) }
+      
+      describe "when passed a AttrList" do
+        let(:arg){ [:a, :b] } 
+        it{ should eq(AttrList.new(arg)) }
+      end
+      
+      describe "when passed an array" do
+        let(:arg){ [:a, :b] }
+        specify{
+          subject.attributes.should eq([:a, :b])
+        }
+      end
+
+      describe "when passed an Ordering" do
+        let(:arg){ Ordering.new [[:a, :asc], [:b, :asc]] }
+        it{ should eq(AttrList.new([:a, :b])) }
+      end
+
+    end
+    
+    describe "from_argv" do
+      
+      subject{ AttrList.from_argv(argv) }
+      
+      describe "on an empty array" do
+        let(:argv){ [] }
+        it{ should eq(AttrList.new([])) }
+      end
+      
+      describe "on a singleton" do
+        let(:argv){ ["hello"] }
+        it{ should eq(AttrList.new([:hello])) }
+      end
+      
+      describe "on multiple strings" do
+        let(:argv){ ["hello", "world"] }
+        it{ should eq(AttrList.new([:hello, :world])) }
+      end
+        
+    end
+
+    describe "to_ordering" do
+
+      specify "when passed an array" do
+        key = AttrList.coerce [:a, :b]
+        okey = key.to_ordering
+        okey.attributes.should == [:a, :b]
+        okey.order_of(:a).should == :asc
+        okey.order_of(:b).should == :asc
+      end
+
+    end
+
+    describe "split" do 
+
+      subject{ key.split(tuple, allbut) }
+
+      describe "when used without allbut" do
+        let(:key){ AttrList.new [:a, :b] }
+        let(:allbut){ false }
+        let(:tuple){ {:a => 1, :b => 2, :c => 3} }
+        let(:expected){ [{:a => 1, :b => 2}, {:c => 3}] }
+        it{ should == expected }
+      end   
+
+      describe "when used with allbut" do
+        let(:key){ AttrList.new [:a, :b] }
+        let(:allbut){ true }
+        let(:tuple){ {:a => 1, :b => 2, :c => 3} }
+        let(:expected){ [{:c => 3}, {:a => 1, :b => 2}] }
+        it{ should == expected }
+      end   
+
+    end
+
+    describe "project" do 
+
+      subject{ key.project(tuple, allbut) }
+
+      describe "when used without allbut" do
+        let(:key){ AttrList.new [:a, :b] }
+        let(:allbut){ false }
+        let(:tuple){ {:a => 1, :b => 2, :c => 3} }
+        let(:expected){ {:a => 1, :b => 2} }
+        it{ should == expected }
+      end   
+
+      describe "when used with allbut" do
+        let(:key){ AttrList.new [:a, :b] }
+        let(:allbut){ true }
+        let(:tuple){ {:a => 1, :b => 2, :c => 3} }
+        let(:expected){ {:c => 3} }
+        it{ should == expected }
+      end   
+
+    end
+
+  end
+end

data/spec/unit/types/test_attr_name.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+module Alf
+  describe AttrName do
+    
+    it "should allow normal names" do
+      (AttrName === :city).should be_true
+    end
+    
+    it "should allow underscores" do
+      (AttrName === :my_city).should be_true
+    end
+    
+    it "should allow numbers" do
+      (AttrName === :city2).should be_true
+    end
+    
+    it "should not allow strange attribute names" do
+      (AttrName === "$$$".to_sym).should be_false
+    end
+    
+    describe "from_argv" do
+      
+      subject{ AttrName.from_argv(argv, opts) }
+      
+      describe "with a String" do
+        let(:argv){ %w{hello} }
+        let(:opts) {{}}
+        it{ should eq(:hello) }
+      end
+
+      describe "with nothing but a default" do
+        let(:argv){ %w{} }
+        let(:opts){ {:default => :hello} }
+        it{ should eq(:hello) }
+      end
+
+      describe "with nothing and no default" do
+        let(:argv){ %w{} }
+        let(:opts){ {} }
+        specify{ lambda{subject}.should raise_error(ArgumentError) }
+      end
+
+      describe "with more than one string" do
+        let(:argv){ %w{hello world} }
+        let(:opts){ {} }
+        specify{ lambda{subject}.should raise_error(ArgumentError) }
+      end
+      
+    end
+    
+  end
+end

data/spec/unit/{test_heading.rb → types/test_heading.rb}

@@ -6,6 +6,16 @@ module Alf
     let(:h1){ Heading.new(:name => String) }
     let(:h2){ Heading.new(:name => String, :price => Float) }
     
+    specify "coerce" do
+      Heading.coerce(:name => String).should eq(h1)
+      Heading.coerce([]).should eq(h0)
+      Heading.coerce(["name", "String"]).should eq(h1)
+    end
+    
+    specify "from_argv" do
+      Heading.from_argv(["name", "String"]).should eq(h1)
+    end
+     
     specify "cardinality" do
       h0.cardinality.should eq(0)
       h1.cardinality.should eq(1)

data/spec/unit/types/test_ordering.rb

@@ -0,0 +1,127 @@
+require 'spec_helper'
+module Alf
+  describe Ordering do
+
+    describe "coerce" do
+
+      specify "when passed an doubly array" do
+        key = Ordering.coerce [[:a, :asc], [:b, :desc]]
+        key.attributes.should == [:a, :b]
+        key.order_of(:a).should == :asc
+        key.order_of(:b).should == :desc
+      end
+
+      specify "when passed a single array" do
+        key = Ordering.coerce [:a, :b]
+        key.attributes.should == [:a, :b]
+        key.order_of(:a).should == :asc
+        key.order_of(:b).should == :asc
+      end
+
+      specify "when passed a single array of strings" do
+        key = Ordering.coerce ["a", "b"]
+        key.attributes.should == [:a, :b]
+        key.order_of(:a).should == :asc
+        key.order_of(:b).should == :asc
+      end
+
+      specify "when passed a single array with asc and desc (1)" do
+        key = Ordering.coerce [:a, :asc]
+        key.attributes.should == [:a]
+        key.order_of(:a).should == :asc
+      end
+
+      specify "when passed a single array with asc and desc (1)" do
+        key = Ordering.coerce [:a, :asc, :b, :desc]
+        key.attributes.should == [:a, :b]
+        key.order_of(:a).should == :asc
+        key.order_of(:b).should == :desc
+      end
+
+      specify "when passed a string array with asc and desc" do
+        key = Ordering.coerce ["a", "asc", "b", "desc"]
+        key.attributes.should == [:a, :b]
+        key.order_of(:a).should == :asc
+        key.order_of(:b).should == :desc
+      end
+
+      specify "when passed an ordering key" do
+        key  = Ordering.coerce [:a, :b]
+        key2 = Ordering.coerce key
+        key.should == key2
+      end
+
+      specify "when passed a projection key" do
+        pkey = AttrList.new [:a, :b]
+        key = Ordering.coerce pkey
+        key.attributes.should == [:a, :b]
+        key.order_of(:a).should == :asc
+        key.order_of(:b).should == :asc
+      end
+
+    end # coerce
+    
+    describe "from_argv" do
+      
+      subject{ Ordering.from_argv(argv) }
+      
+      describe "on an empty array" do
+        let(:argv){ [] }
+        it{ should eq(Ordering.new([])) }
+      end
+      
+      describe "on a singleton" do
+        let(:argv){ ["hello"] }
+        it{ should eq(Ordering.new([[:hello, :asc]])) }
+      end
+      
+      describe "on multiple strings" do
+        let(:argv){ ["hello", "asc", "world", "desc"] }
+        it{ should eq(Ordering.new([[:hello, :asc], [:world, :desc]])) }
+      end
+        
+    end
+
+    describe "compare" do
+      
+      specify "when passed a single key" do
+        key = Ordering.coerce [:a]
+        key.compare({:a => 1}, {:a => 2}).should == -1
+        key.compare({:a => 1}, {:a => 1}).should == 0
+        key.compare({:a => 2}, {:a => 1}).should == 1
+      end 
+      
+      specify "when passed a single key with desc order" do
+        key = Ordering.coerce [[:a, :desc]]
+        key.compare({:a => 1}, {:a => 2}).should == 1
+        key.compare({:a => 1}, {:a => 1}).should == 0
+        key.compare({:a => 2}, {:a => 1}).should == -1
+      end 
+
+      specify "when passed a double key" do
+        key = Ordering.coerce [[:a, :asc], [:b, :desc]]
+        key.compare({:a => 1, :b => 1}, {:a => 0, :b => 1}).should == 1
+        key.compare({:a => 1, :b => 1}, {:a => 1, :b => 2}).should == 1
+        key.compare({:a => 1, :b => 1}, {:a => 1, :b => 1}).should == 0
+      end 
+
+    end
+
+    describe "+" do
+
+      specify "when passed another key" do
+        key = Ordering.coerce [:a]
+        key2 = key + Ordering.coerce([[:b, :desc]])
+        key2.ordering.should == [[:a, :asc], [:b, :desc]]
+      end
+
+      specify "when passed another array" do
+        key = Ordering.coerce [:a]
+        key2 = key + [[:b, :desc]]
+        key2.ordering.should == [[:a, :asc], [:b, :desc]]
+      end
+
+    end
+
+  end
+end

data/spec/unit/types/test_renaming.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+module Alf
+  describe Renaming do
+    
+    describe "coerce" do
+      
+      subject{ Renaming.coerce(arg) }
+      
+      describe "from a Renaming" do
+        let(:arg){ Renaming.new(:old => :new) }
+        it{ should eq(arg) }
+      end
+      
+      describe "from a Hash" do
+        let(:arg){ {"old" => "new"} }
+        it{ should eq(Renaming.new(:old => :new)) }
+      end
+      
+      describe "from an Array" do
+        let(:arg){ ["old", "new"] }
+        it{ should eq(Renaming.new(:old => :new)) }
+      end
+        
+    end
+    
+    describe "from_argv" do
+      
+      subject{ Renaming.from_argv(argv) }
+      
+      describe "from an empty Array" do
+        let(:argv){ [] }
+        it{ should eq(Renaming.new({})) }
+      end
+        
+      describe "from an Array of two elements" do
+        let(:argv){ ["old", "new"] }
+        it{ should eq(Renaming.new(:old => :new)) }
+      end
+        
+      describe "from an Array of four elements" do
+        let(:argv){ ["old", "new", "hello", "world"] }
+        it{ should eq(Renaming.new(:old => :new, :hello => :world)) }
+      end
+        
+    end
+    
+    describe "apply" do
+      let(:r){ Renaming.coerce(["old", "new"])} 
+      specify{
+        r.apply(:old => :a, :other => :b).should eql(:new => :a, :other => :b)
+      }
+    end
+    
+  end 
+end

data/spec/unit/types/test_summarization.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+module Alf
+  describe Summarization do
+    
+    describe "coerce" do
+    
+      subject{ Summarization.coerce(arg) }
+      
+      describe "from a Summarization" do
+        let(:arg){ Summarization.new(:s => Aggregator.sum{ qty }) }
+        it{ should eq(arg) }
+      end
+      
+      describe "from a Hash" do
+        let(:arg){ { :s => "sum{ qty }", :m => Aggregator.max{ size } } }
+        it{ should be_a(Summarization) }
+        specify{ 
+          subject.aggregations.values.all?{|v|
+            v.is_a?(Aggregator)
+          }.should be_true
+        }
+      end
+      
+      describe "from an Array" do
+        let(:arg){ ["s", "sum{ qty }", "m", "max{ size }"] }
+        it{ should be_a(Summarization) }
+        specify{ 
+          ([:s, :m] & subject.aggregations.keys).should eq([:s, :m]) 
+          subject.aggregations.values.all?{|v|
+            v.is_a?(Aggregator)
+          }.should be_true
+        }
+      end
+        
+    end
+    
+    describe "from_argv" do
+    
+      subject{ Summarization.from_argv(argv) }
+      
+      describe "from an Array" do
+        let(:argv){ ["s", "sum{ qty }", "m", "max{ size }"] }
+        it{ should be_a(Summarization) }
+        specify{ 
+          ([:s, :m] & subject.aggregations.keys).should eq([:s, :m]) 
+          subject.aggregations.values.all?{|v|
+            v.is_a?(Aggregator)
+          }.should be_true
+        }
+      end
+        
+    end
+    
+    specify "least -> happens -> finalize" do
+      summ = Summarization.coerce(["s", "sum{ qty }", "m", "max{ size }"])
+      (x = summ.least).should eql(:s => 0, :m => nil)
+      (x = summ.happens(x, :qty => 10, :size => 12)).should eq(:s => 10, :m => 12)
+      (x = summ.happens(x, :qty => 5, :size => 5)).should eq(:s => 15, :m => 12)
+      summ.finalize(x).should eq(:s => 15, :m => 12)
+    end
+    
+  end
+end