alf-core 0.14.0 → 0.15.0

data/spec/unit/alf-relvar/read_only/test_type.rb

@@ -12,10 +12,6 @@ module Alf
         subject.should eq(Relation[id: Fixnum])
       end
 
-      it 'uses the value class' do
-        subject.should be(value.class)
-      end
-
     end
   end
 end

data/spec/unit/alf-relvar/virtual/test_oo_lang.rb

@@ -25,10 +25,6 @@ module Alf
         subject.expr.operand.should be(base)
       end
 
-      it 'should be kept bound' do
-        subject.should be_bound
-      end
-
     end
   end
 end

data/spec/unit/alf-relvar/virtual/test_to_cog.rb

@@ -6,13 +6,13 @@ module Alf
       let(:expr){ Algebra::Operand::Named.new(:aname, self) }
       let(:rv)  { Virtual.new(expr)                         }
 
-      subject{ rv.to_cog }
+      subject{ rv.to_cog(12) }
 
-      def cog(expr)
-        [:seen, expr]
+      def cog(*args)
+        @seen = args
       end
 
-      it{ should eq([:seen, expr]) }
+      it{ should eq([12, expr]) }
 
     end
   end

data/spec/unit/alf-relvar/virtual/test_to_s.rb

@@ -8,7 +8,7 @@ module Alf
 
       subject{ rv.to_s }
 
-      it{ should eq("Relvar::Virtual(Operand::Named(:aname))") }
+      it{ should eq("Relvar::Virtual(aname)") }
 
     end
   end

data/spec/unit/alf-support/test_to_lispy.rb

@@ -2,20 +2,8 @@ require 'spec_helper'
 module Alf
   describe Support, ".to_lispy" do
 
-    # it "should have a valid example" do
-    #   expr = examples_database.parse{
-    #    (project suppliers, [:name])
-    #   }
-    #   Support.to_lispy(expr).should eq("project(suppliers, [:name])")
-    # end
-
     subject{ Support.to_lispy(value) }
 
-    # describe "on a Relvar" do
-    #   let(:value){ examples_database.relvar(:suppliers) }
-    #   it { should eq("suppliers") }
-    # end
-    #
     describe "on an AttrName" do
       let(:value){ :city }
       it { should eq(":city") }
@@ -42,21 +30,18 @@ module Alf
     end
 
     describe "on an Aggregation" do
-      let(:value){ Aggregator.coerce("sum{ qty*price }") }
-      it { should eq("sum{ qty*price }") }
+      let(:expr){ ->(t){ t.qty*t.price } }
+      let(:value){ Aggregator.coerce(Aggregator.sum(expr)) }
+
+      it { should eq("sum{|t| [code unavailable] }") }
     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 }")}
+        it{ should eq("->(t){ t.status }")}
       end
 
     end # TupleExpression
@@ -66,37 +51,34 @@ module Alf
 
       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 }")}
+        it{ should eq("->(t){ true }")}
       end
 
       describe "When built from a Hash" do
         let(:arg){ {:status => 10} }
-        it{ should eq("->{ self.status == 10 }")}
+        it{ should eq("->(t){ t.status == 10 }")}
       end
 
     end # Predicate
 
     describe "on a TupleComputation" do
       let(:value){ TupleComputation.coerce(arg) }
+      let(:expr){ ->(t){ status.upcase } }
 
       describe "When built from a Hash" do
-        let(:arg){ {"upcased" => "status.upcase"} }
-        it{ should eq("{upcased: ->{ status.upcase }}")}
+        let(:arg){ {"upcased" => expr} }
+        it{ should eq("{upcased: ->(t){ [code unavailable] }}")}
       end
 
     end # TupleComputation
 
     describe "on a Summarization" do
       let(:value){ Summarization.coerce(arg) }
+      let(:expr){ Aggregator.sum{|t| t.qty*t.price } }
 
       describe "When built from an Array" do
-        let(:arg){ {"total" => "sum{ qty*price }"} }
-        it{ should eq("{total: sum{ qty*price }}") }
+        let(:arg){ {"total" => expr} }
+        it{ should eq("{total: sum{|t| [code unavailable] }}") }
       end
 
     end # Summarization

data/spec/unit/alf-support/test_tuple_scope.rb

@@ -30,6 +30,17 @@ module Alf
         scope.evaluate{ path < 1 }.should be_false
       end
 
+      it "should support calling Tuple and Relation" do
+        scope.__set_tuple(:path => 1)
+        scope.evaluate{ Tuple(sid: path) }.should eq(Tuple(sid: 1))
+        scope.evaluate{ Relation(sid: path) }.should eq(Relation(sid: 1))
+      end
+
+      it "should support being converted to Relation" do
+        scope.__set_tuple(:path => 1)
+        Relation(scope).should eq(Relation(path: 1))
+      end
+
     end
   end
 end

data/spec/unit/alf-types/ordering/test_coerce.rb

@@ -60,5 +60,18 @@ module Alf
       end
     end
 
+    context 'coming from ARGV' do
+      let(:argv){
+        ["city", "asc", "status", "desc", "sid", "asc"]
+      }
+      let(:expected){
+        Ordering.new([[:city, :asc], [:status, :desc], [:sid, :asc]])
+      }
+
+      it "should work as expected" do
+        Ordering.coerce(argv).should eq(expected)
+      end
+    end
+
   end # Ordering
 end # Alf

data/spec/unit/alf-types/ordering/test_lte.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+module Alf
+  describe Ordering, "<=" do
+
+    subject{ o1 <= o2 }
+
+    context 'when empty' do
+      let(:o1){ Ordering::EMPTY  }
+      let(:o2){ Ordering.new([]) }
+
+      it{ should be_true }
+    end
+
+    context 'when equal' do
+      let(:o1){ Ordering.new([[:a, :asc], [:b, :desc]]) }
+      let(:o2){ Ordering.new([[:a, :asc], [:b, :desc]]) }
+
+      it{ should be_true }
+    end
+
+    context 'when subsumed' do
+      let(:o1){ Ordering.new([[:a, :asc]]) }
+      let(:o2){ Ordering.new([[:a, :asc], [:b, :desc]]) }
+
+      it{ should be_true }
+    end
+
+    context 'when larger' do
+      let(:o1){ Ordering.new([[:a, :asc], [:b, :desc]]) }
+      let(:o2){ Ordering.new([[:a, :asc]]) }
+
+      it{ should be_false }
+    end
+
+    context 'when different' do
+      let(:o1){ Ordering.new([[:a, :asc]]) }
+      let(:o2){ Ordering.new([[:a, :desc]]) }
+
+      it{ should be_false }
+    end
+
+  end
+end

data/spec/unit/alf-types/summarization/test_coerce.rb

@@ -10,7 +10,7 @@ module Alf
     end
 
     describe "from a Hash" do
-      let(:arg){ { :s => "sum{ qty }", :m => Aggregator.max{ size } } }
+      let(:arg){ { :s => Aggregator.sum{ qty }, :m => Aggregator.max{ size } } }
       it{ should be_a(Summarization) }
       specify{ 
         subject.to_hash.keys.to_set.should eq([:s, :m].to_set)
@@ -19,7 +19,7 @@ module Alf
     end
 
     describe "from an Array" do
-      let(:arg){ ["s", "sum{ qty }", "m", "max{ size }"] }
+      let(:arg){ ["s", Aggregator.sum{ qty }, "m", Aggregator.max{ size }] }
       it{ should be_a(Summarization) }
       specify{ 
         subject.to_hash.keys.to_set.should eq([:s, :m].to_set)

data/spec/unit/alf-types/summarization/test_least.rb

@@ -3,7 +3,7 @@ module Alf
   describe Summarization, "least" do
 
     it 'should invoke least on each aggregator' do
-      sum = Summarization.coerce(["s", "avg{ qty }", "m", "max{ size }"])
+      sum = Summarization.coerce(["s", Aggregator.avg{ qty }, "m", Aggregator.max{ size }])
       sum.least.should eq({:s => [0.0, 0.0], :m => nil})
     end
 

data/spec/unit/alf-types/summarization/test_summarize.rb

@@ -7,7 +7,7 @@ module Alf
         {:qty => 10, :size => 12},
         {:qty => 5,  :size => 5}
       ]
-      sum = Summarization.coerce(["s", "avg{ qty }", "m", "max{ size }"])
+      sum = Summarization.coerce(["s", Aggregator.avg{ qty }, "m", Aggregator.max{ size }])
       sum.summarize(rel).should eq({:s => 7.5, :m => 12})
     end
 

data/spec/unit/alf-types/test_summarization.rb

@@ -6,7 +6,7 @@ module Alf
       let(:type){ Summarization }
       def Summarization.exemplars
         [
-          ["total", "sum{ qty }"]
+          ["total", Aggregator.sum{ qty }]
         ].map{|x| Summarization.coerce(x)}
       end
       it_should_behave_like 'A valid type implementation'
@@ -14,7 +14,7 @@ module Alf
 
     specify "least -> happens -> finalize" do
       scope = Support::TupleScope.new
-      summ = Summarization.coerce(["s", "sum{ qty }", "m", "max{ size }"])
+      summ = Summarization.coerce(["s", Aggregator.sum{ qty }, "m", Aggregator.max{ size }])
       (x = summ.least).should eql(:s => 0, :m => nil)
       (x = summ.happens(x, scope.__set_tuple(:qty => 10, :size => 12))).should eq(:s => 10, :m => 12)
       (x = summ.happens(x, scope.__set_tuple(:qty => 5, :size => 5))).should eq(:s => 15, :m => 12)

data/spec/unit/alf-types/test_tuple_expression.rb

@@ -4,8 +4,8 @@ module Alf
 
     def TupleExpression.exemplars
       [
-        "10",
-        "status > 10",
+        ->{ 10 },
+        ->(t){ t.status > 10 },
       ].map{|x| TupleExpression.coerce(x)}
     end
 

data/spec/unit/alf-types/tuple_computation/test_coerce.rb

@@ -16,21 +16,20 @@ module Alf
     describe "from a Hash without coercion" do
       let(:arg){
         {:hello  => TupleExpression.coerce(:who),
-         :hello2 => 2,
-         :hello3 => lambda{ who } }
+         :hello2 => ->(t){ t.who } }
       }
       let(:expected){
-        {hello: "alf", :hello2 => 2, :hello3 => "alf"}
+        {hello: "alf", :hello2 => "alf"}
       }
       it{ should eql(expected) }
     end
 
     describe "from a Hash with coercion" do
       let(:arg){
-        {"hello" => "who", "hello2" => "2"}
+        {"hello" => :who}
       }
       let(:expected){
-        {hello: "alf", :hello2 => 2}
+        {hello: "alf"}
       }
       it{ should eql(expected) }
     end
@@ -42,13 +41,5 @@ module Alf
       it{ should eql(expected) }
     end
 
-    describe "from an Array with coercions" do
-      let(:arg){ ["hello", "who", "hello2", "2"] }
-      let(:expected){
-        {hello: "alf", hello2: 2}
-      }
-      it{ should eql(expected) }
-    end
-
   end
 end

data/spec/unit/alf-types/tuple_computation/test_empty.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+module Alf
+  describe TupleComputation, "empty?" do
+
+    subject{ comp.empty? }
+
+    context 'when not empty' do
+      let(:comp){
+        TupleComputation[big?: ->{}, who: ->{}]
+      }
+
+      it{ should be_false }
+    end
+
+    context 'when empty' do
+      let(:comp){
+        TupleComputation[{}]
+      }
+
+      it{ should be_true }
+    end
+
+  end
+end

data/spec/unit/alf-types/tuple_computation/test_project.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+module Alf
+  describe TupleComputation, "project" do
+    big = TupleExpression.coerce(->(t){ t.status > 10 })
+    who = TupleExpression.coerce(->(t){ t.name })
+
+    let(:comp){
+      TupleComputation[big?: big, who: who]
+    }
+
+    subject{ comp.project(list, allbut) }
+
+    context 'when not allbut' do
+      let(:allbut){ false }
+
+      [
+        [ [:big?, :who],  TupleComputation[big?: big, who: who] ],
+        [ [:big?],        TupleComputation[big?: big] ],
+        [ [:none],        TupleComputation[{}] ],
+      ].each do |(attrs,expected)|
+        context "on #{attrs}" do
+          let(:list){ attrs }
+
+          it{ should eq(expected) }
+        end
+      end
+    end
+
+    context 'when allbut' do
+      let(:allbut){ true }
+
+      [
+        [ [:big?, :who], TupleComputation[{}] ],
+        [ [:big?],       TupleComputation[who: who] ],
+        [ [:none],       TupleComputation[big?: big, who: who] ],
+      ].each do |(attrs,expected)|
+        context "on #{attrs}" do
+          let(:list){ attrs }
+
+          it{ should eq(expected) }
+        end
+      end
+    end
+
+  end
+end

data/spec/unit/alf-types/tuple_expression/test_coerce.rb

@@ -13,21 +13,12 @@ module Alf
       specify{ lambda{ subject }.should raise_error(ArgumentError) }
     end
 
-    describe "with a String" do
-      let(:arg){ "true" }
-      it { should be_a(TupleExpression) }
-      specify{
-        subject.evaluate(scope).should eql(true)
-        subject.source.should eq("true")
-      }
-    end
-
     describe "with a Symbol" do
       let(:arg){ :status }
       it { should be_a(TupleExpression) }
       specify{
         subject.evaluate(scope).should eql(10)
-        subject.source.should eq(:status)
+        subject.source.should eq("t.status")
       }
     end
 

data/spec/unit/alf-types/tuple_expression/test_evaluate.rb

@@ -26,13 +26,5 @@ module Alf
       it{ should be_a(Relation) }
     end
 
-    context 'when the proc returns a unbound, yet boundable expression' do
-      let(:exp){ TupleExpression[->(t){ Algebra::Operand::Named.new(:suppliers) }] }
-
-      subject{ exp.evaluate(scope, examples_database) }
-
-      it{ should be_a(Relation) }
-    end
-
   end # TupleExpression
 end # Alf