alf-core 0.13.1 → 0.14.0

data/spec/unit/alf-engine/compiler/test_unsupported.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+module Alf
+  module Engine
+    describe Compiler, 'unsupported' do
+
+      def unsupported(*args, &bl)
+        Compiler.new.send(:unsupported, *args, &bl)
+      end
+
+      context 'when nothing raised' do
+
+        subject{
+          unsupported(:fall){ 12 }
+        }
+
+        it 'should return the value if nothing raised' do
+          subject.should eq(12)
+        end
+      end
+
+      context 'when a NotSupportedError is raised' do
+
+        subject{
+          unsupported(:fall){ raise NotSupportedError }
+        }
+
+        it 'should return the fallback value' do
+          subject.should eq(:fall)
+        end
+      end
+
+      context 'when something else is raised' do
+
+        subject{
+          unsupported(:fall){ raise ArgumentError, "here" }
+        }
+
+        it 'should let the error be raised' do
+          lambda{
+            subject
+          }.should raise_error(ArgumentError, "here")
+        end
+      end
+
+
+    end
+  end
+end

data/spec/unit/alf-engine/hierarchize/test_renamer.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+module Alf
+  module Engine
+    describe Hierarchize, "renaming" do
+
+      let(:hierarchize){
+        Hierarchize.new([], AttrList[:id, :subid], AttrList[:parent, :subparent], :children)
+      }
+
+      subject{
+        hierarchize.send(:renamer)
+      }
+
+      it{ should eq(Renaming[parent: :id, subparent: :subid]) }
+
+    end
+  end
+end

data/spec/unit/alf-engine/test_filter.rb

@@ -3,19 +3,51 @@ module Alf
   module Engine
     describe Filter do
 
-      it 'should work on an empty operand' do
-        Filter.new(Leaf.new([]), Predicate.coerce(true)).to_a.should eq([])
+      subject{ Filter.new(operand, predicate).to_a }
+
+      context 'on an empty operand' do
+        let(:operand)  { Leaf.new([])           }
+        let(:predicate){ Predicate.coerce(true) }
+
+        it{ should eq([]) }
+      end
+
+      context 'on a non-empty operand' do
+        let(:operand){
+          Leaf.new [
+            {:name => "Jones"},
+            {:name => "Smith"}
+          ]
+        }
+        let(:predicate){
+          Predicate.parse("name =~ /^J/")
+        }
+        let(:expected){
+          [
+            {:name => "Jones"},
+          ]
+        }
+
+        it{ should eq(expected) }
       end
 
-      it 'should filter according to the predicate' do
-        rel = Leaf.new [
-          {:name => "Jones"},
-          {:name => "Smith"}
-        ]
-        exp = [
-          {:name => "Jones"},
-        ]
-        Filter.new(rel, Predicate.parse("name =~ /^J/")).to_a.should eq(exp)
+      context 'on a predicate of arity 1' do
+        let(:operand){
+          Leaf.new [
+            {:name => "Jones"},
+            {:name => "Smith"}
+          ]
+        }
+        let(:predicate){
+          Predicate.native(->(t){ t[:name] =~ /^J/})
+        }
+        let(:expected){
+          [
+            {:name => "Jones"},
+          ]
+        }
+
+        it{ should eq(expected) }
       end
 
     end

data/spec/unit/alf-engine/test_hierarchize.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+module Alf
+  module Engine
+    describe Hierarchize do
+
+      let(:type){
+        Relation.type(id: Fixnum, parent: Fixnum, name: String){|r| {subs: r} }
+      }
+
+      let(:operand){[
+        {id: 1, parent: 1, name: "USA"},
+        {id: 5, parent: 3, name: "Brussels"},
+        {id: 2, parent: 2, name: "Europe"},
+        {id: 3, parent: 2, name: "Belgium"},
+        {id: 4, parent: 2, name: "France"},
+      ]}
+
+      let(:expected){
+        type.new([
+          { id: 1, parent: 1, name: "USA",    subs: type.empty },
+          { id: 2, parent: 2, name: "Europe", subs: type.new([
+              { id: 3, parent: 2, name: "Belgium", subs: type.new([
+                  {id: 5, parent: 3, name: "Brussels", subs: type.empty } ].to_set) },
+              { id: 4, parent: 2, name: "France", subs: type.empty } ].to_set) }
+        ].to_set)
+      }
+
+      subject{
+        Hierarchize.new(operand, AttrList[:id], AttrList[:parent], :subs)
+      }
+
+      let(:resulting_relation){
+        subject.to_relation
+      }
+
+      def are_equal(x, y)
+        # same class
+        x.class.should eq(y.class)
+
+        # take tuples
+        got = x.to_a.sort{|t,u| t[:id] <=> u[:id] }
+        exp = y.to_a.sort{|t,u| t[:id] <=> u[:id] }
+        
+        # compare attributes
+        got.zip(exp) do |e,f|
+          [:id, :parent, :name].each do |a|
+            e[a].should eq(f[a])
+          end
+          are_equal(e[:subs], f[:subs])
+          e[:subs].to_set.should eq(f[:subs].to_set)
+          e[:subs].should eq(f[:subs])
+        end
+
+        true
+      end
+
+      it 'has expected result type' do
+        resulting_relation.class.should eq(type)
+      end
+
+      it 'has pair-wise equal tuples' do
+        are_equal(resulting_relation, expected).should be_true
+      end
+
+      it 'computes expected relation' do
+        resulting_relation.should eq(expected)
+      end
+
+    end
+  end
+end

data/spec/unit/alf-engine/test_set_attr.rb

@@ -33,6 +33,19 @@ module Alf
         SetAttr.new(rel, comp).to_a.should eq(exp)
       end
 
+      it 'should support lambda of arity 1' do
+        rel = Leaf.new [
+          {:name => "Jones"},
+          {:name => "Smith"}
+        ]
+        exp = [
+          {:name => "Jones", :up => "JONES"},
+          {:name => "Smith", :up => "SMITH"}
+        ]
+        comp = TupleComputation[:up => lambda{|t| t.name.upcase }]
+        SetAttr.new(rel, comp).to_a.should eq(exp)
+      end
+
     end
   end # module Engine
 end # module Alf

data/spec/unit/alf-engine/test_take.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+module Alf
+  module Engine
+    describe Take do
+
+      it 'should work on an empty operand' do
+        Take.new(Leaf.new([]), 1, 1).to_a.should eq([])
+      end
+
+      it 'should filter according to the offset' do
+        rel = Leaf.new [
+          {:name => "Jones"},
+          {:name => "Smith"}
+        ]
+        exp = [
+          {:name => "Smith"}
+        ]
+        Take.new(rel, 1, 10).to_a.should eq(exp)
+      end
+
+      it 'should filter according to the limit (1/2)' do
+        rel = Leaf.new [
+          {:name => "Jones"},
+          {:name => "Smith"}
+        ]
+        exp = [
+          {:name => "Jones"},
+          {:name => "Smith"}
+        ]
+        Take.new(rel, 0, 2).to_a.should eq(exp)
+      end
+
+      it 'should filter according to the limit (2/2)' do
+        rel = Leaf.new [
+          {:name => "Jones"},
+          {:name => "Smith"}
+        ]
+        exp = [
+          {:name => "Jones"},
+        ]
+        Take.new(rel, 0, 1).to_a.should eq(exp)
+      end
+
+    end
+  end # module Engine
+end # module Alf

data/spec/unit/alf-engine/test_to_array.rb

@@ -3,40 +3,57 @@ module Alf
   module Engine
     describe ToArray do
 
-      it 'should work on an empty operand' do
-        ToArray.new([], Ordering[[]]).to_a.should eq([])
+      subject{ ToArray.new(rel, ordering).to_a }
+
+      context 'when both empty' do
+        let(:rel)     { [] }
+        let(:ordering){ Ordering::EMPTY }
+
+        it{ should eq(rel) }
+      end
+
+      context 'when ascending on single attribute' do
+        let(:rel){[
+          {name: "Jones"},
+          {name: "Smith"}
+        ]}
+        let(:ordering){ Ordering.new([[:name, :asc]]) }
+
+        it{ should eq(rel) }
       end
 
-      it 'should work with ascending' do
-        rel = [
-          {:name => "Jones"},
-          {:name => "Smith"}
-        ]
-        ToArray.new(rel, Ordering[[:name, :asc]]).to_a.should eq(rel)
+      context 'when descending on single attribute' do
+        let(:rel){[
+          {name: "Jones"},
+          {name: "Smith"}
+        ]}
+        let(:ordering){ Ordering.new([[:name, :desc]]) }
+
+        it{ should eq(rel.reverse) }
       end
 
-      it 'should work with descending' do
-        rel = [
-          {:name => "Jones"},
-          {:name => "Smith"}
-        ]
-        exp = [
-          {:name => "Smith"},
-          {:name => "Jones"}
-        ]
-        ToArray.new(rel, Ordering[[:name, :desc]]).to_a.should eq(exp)
+      context 'when TVAs are involved' do
+        let(:rel){[
+          {name: "Jones", hobby: { score: 10 }},
+          {name: "Jones", hobby: { score: 12 }}
+        ]}
+        let(:ordering){ Ordering.new([[:name, :asc], [[:hobby, :score], :desc]]) }
+
+        it{ should eq(rel.reverse) }
       end
 
-      it 'should work with RVAs' do
-        rel = [
-          {:name => "Smith", :rva => Relation(:id => [8, 7]) },
-          {:name => "Jones", :rva => Relation(:id => [1, 3]) }
-        ]
-        exp = [
-          {:name => "Jones", :rva => [Tuple(:id => 1), Tuple(:id => 3)] },
-          {:name => "Smith", :rva => [Tuple(:id => 7), Tuple(:id => 8)] }
-        ]
-        ToArray.new(rel, Ordering[[:name, :id]]).to_a.should eq(exp)
+      context 'when RVAs are involved' do
+        let(:rel){[
+          {name: "Smith", rva: Relation(id: [8, 7]) },
+          {name: "Jones", rva: Relation(id: [1, 3]) }
+        ]}
+        let(:expected){[
+          {name: "Jones", rva: [Tuple(id: 1), Tuple(id: 3)] },
+          {name: "Smith", rva: [Tuple(id: 7), Tuple(id: 8)] }
+        ]}
+        let(:ordering){ Ordering.new([[:name, :asc], [[:rva, :id], :asc]]) }
+
+        it{ should eq(expected) }
       end
 
     end # describe ToArray

data/spec/unit/alf-io/reader/input.ruby

@@ -0,0 +1,4 @@
+[
+  {:id => 1},
+  {:id => 2}
+]

data/spec/unit/alf-io/reader/test_rash.rb

@@ -19,7 +19,7 @@ module Alf
     
     describe "when called on a String" do
       
-      let(:file){ File.expand_path('../input.rb', __FILE__) }
+      let(:file){ File.expand_path('../input.rash', __FILE__) }
       let(:reader){ Reader::Rash.new(file) }
   
       it "should be enumerable" do

data/spec/unit/alf-io/reader/test_ruby.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+module Alf
+  describe Reader::Ruby do
+    it_should_behave_like "a Reader class"
+
+    let(:file){
+      File.expand_path('../input.ruby', __FILE__)
+    }
+    let(:reader){
+      Reader::Ruby.new(file)
+    }
+
+    let(:expected){
+      [
+        {:id => 1},
+        {:id => 2}
+      ]
+    }
+
+    it "should be enumerable" do
+      reader.to_a.should eq(expected)
+    end
+    
+  end
+end

data/spec/unit/alf-predicate/predicate/test_evaluate.rb

@@ -3,28 +3,66 @@ module Alf
   class Predicate
     describe Predicate, "evaluate" do
 
-      let(:predicate){ 
-        Predicate.new(Factory.lte(:x => 2))
-      }
-
       subject{ predicate.evaluate(scope) }
 
-      describe "on x == 2" do
-        let(:scope){ Support::TupleScope.new(:x => 2) }
+      context 'on a native predicate of arity 1, used through tuple#[]' do
+        let(:predicate){
+          Predicate.native(->(t){ t[:name] =~ /foo/ })
+        }
+
+        context 'on a matching tuple' do
+          let(:scope){ Support::TupleScope.new(:name => "foo") }
+
+          it{ should be_true }
+        end
 
-        it{ should be_true }
+        context 'on a non-matching tuple' do
+          let(:scope){ Support::TupleScope.new(:name => "bar") }
+
+          it{ should be_false }
+        end
       end
 
-      describe "on x == 1" do
-        let(:scope){ Support::TupleScope.new(:x => 1) }
+      context 'on a native predicate of arity 1, used through tuple.xxx' do
+        let(:predicate){
+          Predicate.native(->(t){ t.name =~ /foo/ })
+        }
+
+        context 'on a matching tuple' do
+          let(:scope){ Support::TupleScope.new(:name => "foo") }
+
+          it{ should be_true }
+        end
 
-        it{ should be_true }
+        context 'on a non-matching tuple' do
+          let(:scope){ Support::TupleScope.new(:name => "bar") }
+
+          it{ should be_false }
+        end
       end
 
-      describe "on x == 3" do
-        let(:scope){ Support::TupleScope.new(:x => 3) }
+      context 'on a factored predicate' do
+        let(:predicate){
+          Predicate.new(Factory.lte(:x => 2))
+        }
+
+        describe "on x == 2" do
+          let(:scope){ Support::TupleScope.new(:x => 2) }
+
+          it{ should be_true }
+        end
+
+        describe "on x == 1" do
+          let(:scope){ Support::TupleScope.new(:x => 1) }
+
+          it{ should be_true }
+        end
+
+        describe "on x == 3" do
+          let(:scope){ Support::TupleScope.new(:x => 3) }
 
-        it{ should be_false }
+          it{ should be_false }
+        end
       end
 
     end