alf-core 0.15.0 → 0.16.0

data/spec/unit/alf-relation/relation/test_hash.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Relation, 'hash' do
-
-    let(:tuple){ Relation[id: Integer].coerce(id: 12) }
-
-    subject{ tuple.hash == other.hash }
-
-    context 'on purely equal relation' do
-      let(:other){ Relation[id: Integer].coerce(id: 12) }
-
-      it{ should be_true }
-    end
-
-    context 'on equal relation but a subtype' do
-      let(:other){ Relation[id: Fixnum].coerce(id: 12) }
-
-      it{ should be_true }
-    end
-
-    context 'on equal relation but a supertype' do
-      let(:other){ Relation[id: Numeric].coerce(id: 12) }
-
-      it{ should be_true }
-    end
-
-  end
-end

data/spec/unit/alf-relation/relation/test_heading.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe "Relation#heading" do
-
-    let(:rel){
-      Relation([
-        {:max => 2,   :name => "Jones"},
-        {:max => 7.3, :name => "Jones"},
-      ])
-    }
-
-    subject{ rel.heading }
-
-    it{ should eq(Heading(:max => Numeric, :name => String)) }
-
-  end
-end

data/spec/unit/alf-relation/relation/test_inspect.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Relation do
-    
-    let(:rel){Relation.coerce([
-      {:sid => 'S1'},
-      {:sid => 'S2'},
-      {:sid => 'S3'}
-    ])}
-    
-    describe "inspect" do
-      
-      it "should allows the litteral round-trip" do
-        Kernel.eval(rel.inspect).should == rel
-      end
-
-    end # coerce
-      
-  end
-end

data/spec/unit/alf-relation/relation/test_keys.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe "Relation#keys" do
-
-    let(:rel){
-      Relation([
-        {:max => 2,   :name => "Jones"},
-        {:max => 7.3, :name => "Jones"},
-      ])
-    }
-
-    subject{ rel.keys }
-
-    it{ should eq(Keys[[:max, :name]]) }
-
-  end
-end

data/spec/unit/alf-relation/relation/test_relation.rb

@@ -1,77 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Relation do
-
-    let(:tuples){[
-      {:sid => 'S1', :name => 'Smith', :status => 20, :city => 'London'},
-      {:sid => 'S2', :name => 'Jones', :status => 10, :city => 'Paris'},
-      {:sid => 'S3', :name => 'Blake', :status => 30, :city => 'Paris'}
-    ]}
-    let(:tuples2){ tuples.sort{|t1,t2| t1[:name] <=> t2[:name]} }
-
-    let(:rel1){ Relation.coerce(tuples) }
-    let(:rel2){ Relation.coerce(tuples2) }
-    let(:rel3){ Relation.coerce(tuples[0..1]) }
-
-    it "should have a cardinality method" do
-      rel1.cardinality.should == 3
-    end
-
-    it "should have an empty? method" do
-      Alf::Relation::DUM.should be_empty
-      Alf::Relation::DEE.should_not be_empty
-      rel1.should_not be_empty
-    end
-
-    it "should define == correctly" do
-      rel1.should eq(rel2)
-      rel2.should eq(rel1)
-      rel3.should_not eq(rel1)
-    end
-
-    it "should define eql? correctly" do
-      rel1.should eql(rel2)
-      rel2.should eql(rel1)
-      rel3.should_not eql(rel1)
-    end
-
-    it "should define hash correctly" do
-      rel1.hash.should eq(rel2.hash)
-    end
-
-    it "should allow putting them in hashes" do
-      h = {}
-      h[rel1] = 1
-      h[rel2] = 2
-      h[rel3] = 3
-      h.size.should == 2
-      h[rel1].should == 2
-    end
-
-    describe "rel1" do
-      subject{ rel1 }
-      it_should_behave_like "A value"
-    end
-
-    describe "DUM" do
-      subject{ Relation::DUM }
-      it_should_behave_like "A value"
-      specify{
-        subject.cardinality.should == 0
-        subject.to_a.should == []
-        subject.should be_empty
-      }
-    end
-
-    describe "DEE" do
-      subject{ Relation::DEE }
-      it_should_behave_like "A value"
-      specify{
-        subject.cardinality.should == 1
-        subject.to_a.should == [{}]
-        subject.should_not be_empty
-      }
-    end
-
-  end
-end

data/spec/unit/alf-relation/relation/test_relops.rb

@@ -1,74 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Relation do
-
-    let(:rel1){ Alf::Relation(sid: ['S1', 'S2', 'S3']) }
-    let(:rel2){ Alf::Relation(sid: ['S5', 'S2'])       }
-
-    it 'should have all relational operators installed' do
-      Algebra::Operator.each do |op|
-        rel1.should respond_to(op.rubycase_name)
-      end
-    end
-
-    specify "project" do
-      rel1.project([]).should eq(Alf::Relation::DEE)
-      rel1.project([:sid], allbut: true).should eq(Alf::Relation::DEE)
-    end
-
-    specify "allbut" do
-      rel1.allbut([:sid]).should eq(Alf::Relation::DEE)
-    end
-
-    specify "extend" do
-      rel1.extend(x: lambda{ sid.downcase }).should == Alf::Relation([
-        {sid: 'S1', x: 's1'},
-        {sid: 'S2', x: 's2'},
-        {sid: 'S3', x: 's3'}
-      ])
-    end
-
-    specify "union" do
-      (rel1 + rel1).should == rel1
-      (rel1 | rel1).should == rel1
-      (rel1 + rel2).should == Alf::Relation(sid: ['S1','S3','S2','S5'])
-    end # union
-
-    specify "difference" do
-      (rel1 - rel1).should == Alf::Relation::DUM
-      (rel1 - rel2).should == Alf::Relation(sid: ['S1', 'S3'])
-      (rel2 - rel1).should == Alf::Relation(sid: 'S5')
-    end # difference
-
-    specify "join" do
-      (rel1 * rel2).should == Alf::Relation(sid: 'S2')
-      (rel2 * rel1).should == Alf::Relation(sid: 'S2')
-    end # join
-
-    specify "intersect" do
-      (rel1 & rel2).should == Alf::Relation(sid: 'S2')
-      (rel2 & rel1).should == Alf::Relation(sid: 'S2')
-    end # intersect
-
-    specify "matching" do
-      (rel1 =~ rel2).should == Alf::Relation(sid: 'S2')
-    end # intersect
-
-    specify "not matching" do
-      (rel1 !~ rel2).should == Alf::Relation(sid: ['S1', 'S3'])
-    end # intersect
-
-    specify "page" do
-      rel1.page([[:sid, :asc]], 1, page_size: 2).should == Alf::Relation(sid: ['S1', 'S2'])
-      rel1.page([[:sid, :asc]], -1, page_size: 2).should == Alf::Relation(sid: ['S2', 'S3'])
-      rel1.page([[:sid, :asc]], 2, page_size: 2).should == Alf::Relation(sid: ['S3'])
-      rel1.page([[:sid, :asc]], -2, page_size: 2).should == Alf::Relation(sid: ['S1'])
-    end
-
-    specify "frame" do
-      rel1.frame([[:sid, :asc]], 1, 2).should == Alf::Relation(sid: ['S2', 'S3'])
-      rel1.frame([[:sid, :asc]], 2, 12).should == Alf::Relation(sid: ['S3'])
-    end
-
-  end
-end

data/spec/unit/alf-relation/relation/test_sugar.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Relation, '[]' do
-
-    let(:rel){ Alf::Relation(sid: 'S1', sname: "Jones", city: "London") }
-
-    context 'as a selection' do
-      subject{ rel[:pid => :sid] }
-
-      let(:expected){ Alf::Relation(pid: 'S1') }
-
-      it{ should eq(expected) }
-    end
-
-    context 'as a selection mixing symbols and values' do
-      subject{ rel[pid: :sid, test: ""] }
-
-      let(:expected){ Alf::Relation(pid: 'S1', test: "") }
-
-      it{ should eq(expected) }
-    end
-
-    context 'as a selection mixing list, then selection' do
-      subject{ rel[:sid, pid: :sid, test: ""] }
-
-      let(:expected){ Alf::Relation(sid: 'S1', pid: 'S1', test: "") }
-
-      it{ should eq(expected) }
-    end
-
-    context 'as a projection' do
-      subject{ rel[:sid, :city] }
-
-      let(:expected){ Alf::Relation(sid: 'S1', city: "London") }
-
-      it{ should eq(expected) }
-    end
-
-  end
-end

data/spec/unit/alf-relation/relation/test_to_a.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe "Relation#to_a" do
-
-    let(:rel){Alf::Relation(sid: ['S2', 'S1', 'S3']) }
-
-    specify "without an ordering key" do
-      rel.to_a.sort{|k1,k2| k1[:sid] <=> k2[:sid]}.should eq([
-        {:sid => 'S1'},
-        {:sid => 'S2'},
-        {:sid => 'S3'}
-      ])
-    end
-
-    specify "with an ordering key" do
-      rel.to_a([:sid]).should eq([
-        {:sid => 'S1'},
-        {:sid => 'S2'},
-        {:sid => 'S3'}
-      ])
-      rel.to_a([[:sid, :desc]]).should eq([
-        {:sid => 'S3'},
-        {:sid => 'S2'},
-        {:sid => 'S1'}
-      ])
-    end
-
-    specify "ON DUM" do
-      Relation::DUM.to_a.should eq([])
-    end
-
-    specify "ON DEE" do
-      Relation::DEE.to_a.should eq([{}])
-    end
-
-  end
-end

data/spec/unit/alf-relation/relation/test_to_hash.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe "Relation#to_hash" do
-
-    let(:rel){
-      Alf::Relation([
-        {sid: 'S1', name: 'Jones', city: 'London', status: 20},
-        {sid: 'S2', name: 'Blake', city: 'London', status: 20},
-      ])
-    }
-
-    specify "with :sid => :name" do
-      rel.to_hash(:sid => :name).should eq('S1' => 'Jones', 'S2' => 'Blake')
-    end
-
-    specify "with :sid => :city" do
-      rel.to_hash(:sid => :city).should eq('S1' => 'London', 'S2' => 'London')
-    end
-
-    specify "with :city => :sid" do
-      lambda{
-        rel.to_hash(:city => :sid)
-      }.should raise_error(/Key expected for `city`, divergence found on `London`/)
-    end
-
-    specify "with :city => :status" do
-      rel.to_hash(:city => :status).should eq('London' => 20)
-    end
-
-  end
-end

data/spec/unit/alf-relation/relation/test_to_relation.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe "Relation#to_relation" do
-
-    let(:rel){ Relation(:sid => ['S1', 'S2', 'S3']) }
-
-    subject{ rel.to_relation }
-
-    it 'should return self' do
-      subject.object_id.should eq(rel.object_id)
-    end
-
-  end
-end

data/spec/unit/alf-relation/tuple/class/test_coerce.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Types
-    describe Tuple, '.coerce' do
-
-      subject{ Tuple.coerce(arg) }
-
-      let(:expected){ Tuple[name: String].new(:name => "bla") }
-
-      context 'on self' do
-        let(:arg){ expected }
-
-        it { should be(expected) }
-      end
-
-      context 'on a Tuple' do
-        let(:arg){ Tuple[name: String].new(:name => "bla") }
-
-        it{ should eq(expected) }
-      end
-
-      context 'on an unsymbolized Hash' do
-        let(:arg){ {'name' => "bla"} }
-
-        it{ should eq(expected) }
-      end
-    end
-  end
-end

data/spec/unit/alf-relation/tuple/class/test_type.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Tuple, '.type' do
-
-    let(:heading){ {name: String, status: Integer} }
-    subject{ Tuple.type(heading) }
-
-    it 'returns a subclass' do
-      subject.should be_a(Class)
-      subject.superclass.should be(Alf::Tuple)
-    end
-
-    it 'coerces the heading' do
-      subject.heading.should be_a(Heading)
-    end
-
-    it 'sets the heading correctly' do
-      subject.heading.to_hash.should eq(heading)
-    end
-
-    it 'is aliased as []' do
-      Tuple[heading].should be_a(Class)
-      Tuple[heading].should eq(subject)
-    end
-
-  end
-end

data/spec/unit/alf-relation/tuple/factored-types/test_allbut.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Tuple, '.allbut' do
-
-    let(:type){ Tuple[name: String, status: Integer] }
-
-    subject{ type.allbut(attr_list) }
-
-    context 'with an empty attribute list' do
-      let(:attr_list){ AttrList.new([]) }
-
-      it 'allbuts as expected' do
-        subject.should be(type)
-      end
-    end
-
-    context 'with an non empty attribute list' do
-      let(:attr_list){ AttrList.new([:name]) }
-
-      it 'allbuts as expected' do
-        subject.should eq(Tuple[status: Integer])
-      end
-    end
-
-    context 'with a full attribute list' do
-      let(:attr_list){ AttrList.new([:name, :status]) }
-
-      it 'reuses the DUM class' do
-        subject.should be(Tuple::DUM.class)
-      end
-    end
-
-  end
-end