alf-core 0.15.0 → 0.16.0

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

@@ -1,17 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Keys, "all?" do
-
-    subject{ keys.all?{|k| (k & [:name]).empty? } }
-
-    let(:keys) { 
-      Keys[ [:a], [:name], [:last, :name] ]
-    }
-    let(:expected) { 
-      Keys[ [:a] ]
-    }
-
-    it{ should be_false }
-
-  end
-end

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

@@ -1,26 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Keys, "&" do
-
-    subject{ left & right }
-
-    context 'when disjoint' do
-      let(:left) { Keys[ [:a] ] }
-      let(:right){ Keys[ [:b] ] }
-
-      let(:expected){ Keys[ ] }
-
-      it{ should eq(expected) }
-    end
-
-    context 'when not disjoint' do
-      let(:left) { Keys[ [:a, :b], [:c] ] }
-      let(:right){ Keys[ [:d], [:b, :a] ] }
-
-      let(:expected){ Keys[ [:a, :b] ] }
-
-      it{ should eq(expected) }
-    end
-
-  end
-end

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

@@ -1,17 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Keys, "any?" do
-
-    subject{ keys.any?{|k| (k & [:name]).empty? } }
-
-    let(:keys) { 
-      Keys[ [:a], [:name], [:last, :name] ]
-    }
-    let(:expected) { 
-      Keys[ [:a] ]
-    }
-
-    it{ should be_true }
-
-  end
-end

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

@@ -1,64 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Keys, ".coerce" do
-
-    subject{ Keys.coerce(arg) }
-
-    let(:expected){ Keys.new [ AttrList[:id], AttrList[:name] ] }
-
-    context 'on a Keys' do
-      let(:arg){ expected }
-
-      it{ should be(arg) }
-    end
-
-    context 'on an Array of AttrList coercables' do
-      let(:arg){ [ [:id], [:name] ] }
-
-      it{ should eq(expected) }
-    end
-  end
-  describe Keys, "[]" do
-
-    let(:expected){ Keys.new [ AttrList[:id], AttrList[:name] ] }
-
-    context 'on a varargs with arrays of symbols' do
-      subject{ Keys[ [:id], [:name] ] }
-
-      it{ should eq(expected) }
-    end
-
-    context 'on [:a, :b]' do
-      subject{ Keys[ [:a, :b] ] }
-
-      it 'should have correct AttrList lists' do
-        subject.to_a.should eq([ AttrList[:a, :b] ])
-      end
-    end
-
-    context 'on empty' do
-      subject{ Keys[] }
-
-      it 'should have correct AttrList lists' do
-        subject.to_a.should eq([])
-      end
-    end
-
-    context 'on one empty list' do
-      subject{ Keys[ [] ] }
-
-      it 'should have correct AttrList lists' do
-        subject.to_a.should eq([ AttrList[] ])
-      end
-    end
-
-    context 'at least one empty list' do
-      subject{ Keys[ [:a], [] ] }
-
-      it 'should have correct AttrList lists' do
-        subject.to_a.should eq([ AttrList[:a], AttrList[] ])
-      end
-    end
-
-  end
-end

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

@@ -1,20 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Keys, "empty?" do
-
-    subject{ keys.empty? }
-
-    context 'on empty Keys' do
-      let(:keys){ Keys.new [] }
-
-      it{ should be_true }
-    end
-
-    context 'on non empty Keys' do
-      let(:keys){ Keys.new [ AttrList[:a] ] }
-
-      it{ should be_false }
-    end
-
-  end
-end

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

@@ -1,17 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Keys, "first" do
-
-    subject{ keys.first }
-
-    let(:keys) { 
-      Keys[ [:a], [:name], [:last, :name] ]
-    }
-    let(:expected) { 
-      AttrList[:a]
-    }
-
-    it{ should eq(expected) }
-
-  end
-end

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

@@ -1,33 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Keys, "hash and ==" do
-
-    subject{ left == right }
-
-    after do
-      (left.hash == right.hash).should be_true if subject
-    end
-
-    context 'on empty Keys' do
-      let(:left) { Keys.new [] }
-      let(:right){ Keys.new [] }
-
-      it{ should be_true }
-    end
-
-    context 'on non-empty equal Keys' do
-      let(:left) { Keys.new [ AttrList[], AttrList[:b, :a] ] }
-      let(:right){ Keys.new [ AttrList[:a, :b], AttrList[] ] }
-
-      it{ should be_true }
-    end
-
-    context 'on non equal Keys' do
-      let(:left) { Keys.new [ AttrList[:b, :a] ] }
-      let(:right){ Keys.new [ AttrList[:a, :c] ] }
-
-      it{ should be_false }
-    end
-
-  end
-end

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

@@ -1,40 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Keys, "if_empty" do
-
-    context 'with an arg' do
-      subject{ keys.if_empty([ [:foo] ]) }
-
-      context 'when empty' do
-        let(:keys){ Keys[] }
-        let(:expected){ Keys[ [:foo] ] }
-
-        it{ should eq(expected) }
-      end
-
-      context 'when not empty' do
-        let(:keys){ Keys[ [:a] ] }
-
-        it{ should be(keys) }
-      end
-    end
-
-    context 'with a block' do
-      subject{ keys.if_empty{ [ [:foo] ] } }
-
-      context 'when empty' do
-        let(:keys){ Keys[] }
-        let(:expected){ Keys[ [:foo] ] }
-
-        it{ should eq(expected) }
-      end
-
-      context 'when not empty' do
-        let(:keys){ Keys[ [:a] ] }
-
-        it{ should be(keys) }
-      end
-    end
-
-  end
-end

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

@@ -1,17 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Keys, "map" do
-
-    subject{ keys.map{|k| k | [:foo] } }
-
-    let(:keys) { 
-      Keys[ [:a], [:name] ]
-    }
-    let(:expected) { 
-      Keys[ [:a, :foo], [:name, :foo] ]
-    }
-
-    it{ should eq(expected) }
-
-  end
-end

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

@@ -1,26 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Keys, "+" do
-
-    subject{ left + right }
-
-    context 'when disjoint' do
-      let(:left) { Keys[ [:a] ] }
-      let(:right){ Keys[ [:b] ] }
-
-      let(:expected){ Keys[ [:a], [:b] ] }
-
-      it{ should eq(expected) }
-    end
-
-    context 'when not disjoint' do
-      let(:left) { Keys[ [:a], [:b] ] }
-      let(:right){ Keys[ [:c], [:a] ] }
-
-      let(:expected){ Keys[ [:a], [:b], [:c] ] }
-
-      it{ should eq(expected) }
-    end
-
-  end
-end

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

@@ -1,29 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Keys, "project" do
-
-    let(:keys){
-      Keys[ [:id], [:id, :name], [:status] ]
-    }
-    let(:attrs){ 
-      [:id]
-    }
-
-    subject{ keys.project(attrs, allbut) }
-
-    context '--no-allbut' do
-      let(:allbut)  { false }
-      let(:expected){ Keys[ [:id], [] ]  }
-
-      it{ should eq(expected) }
-    end
-
-    context '--allbut' do
-      let(:allbut)  { true }
-      let(:expected){ Keys[ [], [:name], [:status] ] }
-
-      it{ should eq(expected) }
-    end
-
-  end
-end

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

@@ -1,17 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Keys, "reject" do
-
-    subject{ keys.reject{|k| (k & [:name]).empty? } }
-
-    let(:keys) { 
-      Keys[ [:a], [:name], [:last, :name] ]
-    }
-    let(:expected) { 
-      Keys[ [:name], [:last, :name] ]
-    }
-
-    it{ should eq(expected) }
-
-  end
-end

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

@@ -1,21 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Keys, "rename" do
-
-    subject{ keys.rename(:name => :nome) }
-
-    context 'on empty Keys' do
-      let(:keys){ Keys[] }
-
-      it{ should eq(Keys[]) }
-    end
-
-    context 'on non empty Keys' do
-      let(:keys)    { Keys[ [:a], [:name], [:last, :name] ] }
-      let(:expected){ Keys[ [:a], [:nome], [:last, :nome] ] }
-
-      it{ should eq(expected) }
-    end
-
-  end
-end

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

@@ -1,66 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Keys, "select" do
-
-    context 'when checking for intersection' do
-      subject{ keys.select{|k| (k & [:name]).empty? } }
-
-      let(:keys) {
-        Keys[ [:a], [:name], [:last, :name] ]
-      }
-
-      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

@@ -1,77 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Ordering, "coerce" do
-
-    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 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 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 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 (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
-
-    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
-
-    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