alf-core 0.13.1 → 0.14.0

data/spec/unit/alf-support/tuple_scope/test_respond_to.rb

@@ -7,6 +7,12 @@ module Alf
         let(:scope){ TupleScope.new }
 
         it_behaves_like "A scope"
+
+        it 'responds to [], to_s and inspect' do
+          scope.respond_to?(:[]).should be_true
+          scope.respond_to?(:to_s).should be_true
+          scope.respond_to?(:inspect).should be_true
+        end
       end
 
       context 'on a TupleScope that decorates a tuple' do

data/spec/unit/alf-support/tuple_scope/test_to_s.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+module Alf
+  module Support
+    describe TupleScope, "to_s and inspect" do
+
+      let(:tuple){ {:a => 1, :b => 2} }
+
+      context 'with a simple TupleScope' do
+        let(:scope){ TupleScope.new(tuple) }
+
+        it "delegates to_s to the tuple" do
+          scope.to_s.should eq(tuple.to_s)
+        end
+
+        it "delegates to the tuple" do
+          scope.inspect.should eq(tuple.inspect)
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/alf-types/keys/test_select.rb

@@ -2,16 +2,65 @@ require 'spec_helper'
 module Alf
   describe Keys, "select" do
 
-    subject{ keys.select{|k| (k & [:name]).empty? } }
+    context 'when checking for intersection' do
+      subject{ keys.select{|k| (k & [:name]).empty? } }
 
-    let(:keys) { 
-      Keys[ [:a], [:name], [:last, :name] ]
-    }
-    let(:expected) { 
-      Keys[ [:a] ]
-    }
+      let(:keys) {
+        Keys[ [:a], [:name], [:last, :name] ]
+      }
 
-    it{ should eq(expected) }
+      let(:expected) {
+        Keys[ [:a] ]
+      }
+
+      it{ should eq(expected) }
+    end
+
+    context 'when taking only empty keys' do
+      subject{ keys.select{|k| k.empty?} }
+
+      let(:keys) {
+        Keys[ [:a], [], [], [:a, :b] ]
+      }
+
+      let(:expected) {
+        Keys[ [] ]
+      }
+
+      it{ should eq(expected) }
+    end
+
+    context 'when checking projections' do
+      subject{
+        keys.select{|k|
+          k.project([:a], false) == k
+        }
+      }
+
+      context 'when keys are not empty' do
+        let(:keys){
+          Keys[ [:a], [:a, :name], [] ]
+        }
+
+        let(:expected){
+          Keys[ [:a], [] ]
+        }
+
+        it{ should eq(expected) }
+      end
+
+      context 'when keys contains only the empty key' do
+        let(:keys){
+          Keys[ [] ]
+        }
+
+        let(:expected){
+          Keys[ [] ]
+        }
+
+        it{ should eq(expected) }
+      end
+    end
 
   end
 end

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

@@ -2,51 +2,62 @@ require 'spec_helper'
 module Alf
   describe Ordering, "coerce" do
 
-    let(:expected){ Ordering.new([[:a, :asc], [:b, :asc]]) }
+    context 'with single attribute names' do
+      let(:expected){ Ordering.new([[:a, :asc], [:b, :asc]]) }
 
-    it "should work with an Ordering" do
-      key  = Ordering.coerce [:a, :b]
-      key.should eq(expected)
-    end
+      it "should work with an Ordering" do
+        key  = Ordering.coerce [:a, :b]
+        key.should eq(expected)
+      end
 
-    it "should work with an empty array" do
-      key  = Ordering.coerce []
-      key.should eq(Ordering.new([]))
-    end
+      it "should work with an empty array" do
+        key  = Ordering.coerce []
+        key.should eq(Ordering.new([]))
+      end
 
-    it "should work with a normalized array" do
-      key = Ordering.coerce [[:a, :asc], [:b, :asc]]
-      key.should eq(expected)
-    end
+      it "should work with a normalized array" do
+        key = Ordering.coerce [[:a, :asc], [:b, :asc]]
+        key.should eq(expected)
+      end
 
-    it "should work with an array of AttrName" do
-      key = Ordering.coerce [:a, :b]
-      key.should eq(expected)
-    end
+      it "should work with an array of AttrName" do
+        key = Ordering.coerce [:a, :b]
+        key.should eq(expected)
+      end
 
-    it "should work with an array of Strings" do
-      key = Ordering.coerce ["a", "b"]
-      key.should eq(expected)
-    end
+      it "should work with an array of Strings" do
+        key = Ordering.coerce ["a", "b"]
+        key.should eq(expected)
+      end
 
-    it "should work with a single array with explicit asc/desc (1)" do
-      key = Ordering.coerce [:a, :asc]
-      key.should eq(Ordering.new([[:a, :asc]]))
-    end
+      it "should work with a single array with explicit asc/desc (1)" do
+        key = Ordering.coerce [:a, :asc]
+        key.should eq(Ordering.new([[:a, :asc]]))
+      end
 
-    it "should work with a single array with explicit asc/desc (2)" do
-      key = Ordering.coerce [:a, :asc, :b, :desc]
-      key.should eq(Ordering.new([[:a, :asc], [:b, :desc]]))
-    end
+      it "should work with a single array with explicit asc/desc (2)" do
+        key = Ordering.coerce [:a, :asc, :b, :desc]
+        key.should eq(Ordering.new([[:a, :asc], [:b, :desc]]))
+      end
 
-    it "should work with a single array with explicit asc/desc (3)" do
-      key = Ordering.coerce ["a", "asc", "b", "desc"]
-      key.should eq(Ordering.new([[:a, :asc], [:b, :desc]]))
+      it "should work with a single array with explicit asc/desc (3)" do
+        key = Ordering.coerce ["a", "asc", "b", "desc"]
+        key.should eq(Ordering.new([[:a, :asc], [:b, :desc]]))
+      end
+
+      it "should work with an AttrList" do
+        key = Ordering.coerce(AttrList.new([:a, :b]))
+        key.should eq(expected)
+      end
     end
 
-    it "should work with an AttrList" do
-      key = Ordering.coerce(AttrList.new([:a, :b]))
-      key.should eq(expected)
+    context 'with complex attribute names' do
+      let(:expected){ Ordering.new([[:a, :asc], [[:b, :name], :asc]]) }
+
+      it "should work with an array of Strings" do
+        key = Ordering.coerce ["a", "b.name"]
+        key.should eq(expected)
+      end
     end
 
   end # Ordering

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

@@ -0,0 +1,41 @@
+require 'spec_helper'
+module Alf
+  describe Ordering, 'dive' do
+
+    subject{ ordering.dive(:b) }
+
+    context 'when the ordering has :b' do
+      let(:ordering){
+        Ordering.new([[:a, :asc], [[:b, :x], :asc], [[:b, :y], :asc]])
+      }
+      let(:expected){
+        Ordering.new([[:x, :asc], [:y, :asc]])
+      }
+
+      it{ should eq(expected) }
+    end
+
+    context 'when the ordering has no :b' do
+      let(:ordering){
+        Ordering.new([[:a, :asc]])
+      }
+      let(:expected){
+        Ordering::EMPTY
+      }
+
+      it{ should eq(expected) }
+    end
+
+    context 'when the ordering has a single :b' do
+      let(:ordering){
+        Ordering.new([[:b, :asc]])
+      }
+      let(:expected){
+        Ordering::EMPTY
+      }
+
+      it{ should eq(expected) }
+    end
+
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Alf
+  describe Ordering, "[]" do
+
+    let(:ordering){ Ordering.new([[:a, :asc], [:b, :desc], [[:c, :d], :asc]]) }
+
+    it 'return the direction when an attribute' do
+      ordering[:a].should eq(:asc)
+      ordering[:b].should eq(:desc)
+      ordering[Selector[:a]].should eq(:asc)
+      ordering[Selector[:b]].should eq(:desc)
+      ordering[Selector[[:c, :d]]].should eq(:asc)
+    end
+
+    it 'return nil when not an attribute' do
+      ordering[:c].should be_nil
+    end
+
+  end # Ordering
+end # Alf

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

@@ -0,0 +1,61 @@
+require 'spec_helper'
+module Alf
+  describe Ordering, "merge" do
+
+    subject{ Ordering.coerce(left) + right }
+
+    let(:expected){ Ordering.new([[:a, :asc], [:b, :desc]]) }
+
+    describe "with another Ordering" do
+      let(:left){ [:a] }
+      let(:right){ Ordering.new([[:b, :desc]]) }
+
+      it{ should eq(expected) }
+    end
+
+    describe "with  another array" do
+      let(:left){ [:a] }
+      let(:right){ [[:b, :desc]] }
+
+      it{ should eq(expected) }
+    end
+
+    describe "with  another array (2)" do
+      let(:left){ [:a] }
+      let(:right){ [:b, :desc] }
+
+      it{ should eq(expected) }
+    end
+
+    describe "with redundancy" do
+      let(:left) { [[:a, :asc], [:b, :desc]] }
+      let(:right){ [[:a, :asc], [:c, :desc]] }
+
+      it{ should eq(Ordering.new([[:a, :asc], [:b, :desc], [:c, :desc]])) }
+    end
+
+    describe "with conflict and no block" do
+      let(:left) { [[:a, :asc], [:b, :desc]] }
+      let(:right){ [[:a, :desc], [:c, :desc]] }
+
+      it{ should eq(Ordering.new([[:a, :desc], [:b, :desc], [:c, :desc]])) }
+    end
+
+    describe "with conflict and a block" do
+      let(:left) { [[:a, :asc], [:b, :desc]] }
+      let(:right){ [[:a, :desc], [:c, :desc]] }
+
+      subject{
+        Ordering.coerce(left).merge(right){|attr,d1,d2|
+          attr.should eq(Selector[:a])
+          d1.should eq(:asc)
+          d2.should eq(:desc)
+          d1
+        }
+      }
+
+      it{ should eq(Ordering.new([[:a, :asc], [:b, :desc], [:c, :desc]])) }
+    end
+
+  end # Ordering
+end # Alf

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

@@ -0,0 +1,40 @@
+require 'spec_helper'
+module Alf
+  describe Ordering, "reverse" do
+
+    subject{
+      ordering.reverse
+    }
+
+    context 'on an empty ordering' do
+      let(:ordering){ Ordering.new([]) }
+      
+      it{ should eq(ordering) }
+    end
+
+    context 'on a singleton asc ordering' do
+      let(:ordering){ Ordering.new([[:name, :asc]]) }
+
+      it{ should eq(Ordering.new([[:name, :desc]])) }
+    end
+
+    context 'on a singleton desc ordering' do
+      let(:ordering){ Ordering.new([[:name, :desc]]) }
+
+      it{ should eq(Ordering.new([[:name, :asc]])) }
+    end
+
+    #
+    # name, id   => name, id
+    #    b, 12         a, 13
+    #    a, 10         a, 10
+    #    a, 13         b, 12
+    #
+    context 'on a mixed ordering' do
+      let(:ordering){ Ordering.new([[:name, :desc], [:id, :asc]]) }
+
+      it{ should eq(Ordering.new([[:name, :asc], [:id, :desc]])) }
+    end
+
+  end # Ordering
+end # Alf

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

@@ -0,0 +1,24 @@
+require 'spec_helper'
+module Alf
+  describe Ordering, "selectors" do
+
+    subject{ ordering.selectors }
+
+    context 'with single attribute names' do
+      let(:ordering){ Ordering.new([[:a, :asc], [:b, :asc]]) }
+
+      it "works as expected" do
+        subject.should eq([Alf::Selector[:a], Alf::Selector[:b]])
+      end
+    end
+
+    context 'with complex attribute names' do
+      let(:ordering){ Ordering.new([[:a, :asc], [[:b, :name], :asc]]) }
+      
+      it "works as expected" do
+        subject.should eq([Alf::Selector[:a], Alf::Selector[[:b, :name]]])
+      end
+    end
+
+  end # Ordering
+end # Alf

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

@@ -2,14 +2,68 @@ require 'spec_helper'
 module Alf
   describe Ordering, "sorter" do
 
-    let(:sorter){ Ordering.coerce([[:a, :desc]]).sorter }
-
-    it 'should sort correctly' do
-      [{:a => 2}, 
-       {:a => 7}, 
-       {:a => 1}].sort(&sorter).should eq([
-         {:a => 7}, {:a => 2}, {:a => 1}
-      ])
+    subject{ ordering.sorter }
+
+    context 'on an ordering with single names' do
+      let(:ordering){ Ordering.coerce([[:a, :desc]]) }
+
+      let(:tuples){
+        [{a: 2},
+         {a: 7},
+         {a: 1}]
+      }
+
+      let(:expected){
+        [{a: 7},
+         {a: 2},
+         {a: 1}]
+      }
+
+      it 'should sort correctly' do
+        tuples.sort(&subject).should eq(expected)
+      end
+    end
+
+    context 'on an ordering with hierarchical names' do
+      let(:ordering){ Ordering.coerce([[:a, :asc], [[:b, :x], :desc]]) }
+
+      let(:tuples){
+        [{a: 2, b: {x: 1}},
+         {a: 7, b: {x: 1}},
+         {a: 2, b: {x: 2}}]
+      }
+
+      let(:expected){
+        [{a: 2, b: {x: 2}},
+         {a: 2, b: {x: 1}},
+         {a: 7, b: {x: 1}}]
+      }
+
+      it 'should sort correctly' do
+        tuples.sort(&subject).should eq(expected)
+      end
+    end
+
+    context 'when RVA attributes are involved' do
+      let(:ordering){ Ordering.coerce([[:a, :asc], [[:b, :x], :desc]]) }
+
+      let(:tuples){
+        [{a: 2, b: [{x: 1}]},
+         {a: 7, b: [{x: 1}]},
+         {a: 2, b: [{x: 2}]}]
+      }
+
+      let(:expected){
+        [{a: 2, b: [{x: 1}]},
+         {a: 2, b: [{x: 2}]},
+         {a: 7, b: [{x: 1}]}]
+      }
+
+      it 'should sort correctly' do
+        pending{
+          tuples.sort(&subject).should eq(expected)
+        }
+      end
     end
 
   end # Ordering