alf-core 0.13.0

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

@@ -0,0 +1,28 @@
+require 'spec_helper'
+module Alf
+  class Predicate
+    describe Predicate, "tautology?" do
+
+      subject{ pred.tautology? }
+
+      context "tautology" do
+        subject{ Predicate.tautology }
+
+        it{ should be_true }
+      end
+
+      context "contradiction" do
+        subject{ Predicate.contradiction }
+
+        it{ should be_false }
+      end
+
+      context "var_ref" do
+        subject{ Predicate.var_ref(:x) }
+
+        it{ should be_false }
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+require 'spec_helper'
+module Alf
+  class Predicate
+    describe Predicate, "to_proc" do
+
+      subject{ p.to_proc }
+
+      describe "on a comp(:eq)" do
+        let(:p){ Predicate.coerce(:x => 2) }
+
+        it{ should be_a(Proc) }
+      end
+      
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+require 'spec_helper'
+module Alf
+  class Predicate
+    describe Predicate, "to_ruby_code" do
+
+      subject{ p.to_ruby_code }
+
+      describe "on a comp(:eq)" do
+        let(:p){ Predicate.coerce(:x => 2) }
+
+        it{ should eq("self.x == 2") }
+      end
+      
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+require 'spec_helper'
+module Alf
+  class Predicate
+    describe Predicate, "to_ruby_literal" do
+
+      subject{ p.to_ruby_literal }
+
+      describe "on a comp(:eq)" do
+        let(:p){ Predicate.coerce(:x => 2) }
+
+        it{ should eq("lambda{ self.x == 2 }") }
+      end
+      
+    end
+  end
+end

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

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+shared_examples_for "a predicate" do
+
+  let(:x){ 12 }
+  let(:y){ 13 }
+
+  it 'can be compiled to valid ruby code' do
+    code = subject.to_ruby_code
+    got  = Kernel::eval code, binding
+    msg  = "Expected `#{code}` to return truth value (#{subject.expr.inspect})"
+    [ TrueClass, FalseClass ].should include(got.class), msg
+  end
+
+  it 'provides a proc for easy evaluation' do
+    got = instance_exec(&subject.to_proc)
+    [ TrueClass, FalseClass ].should include(got.class)
+  end
+
+  it 'can be negated easily' do
+    (!subject).should be_a(Alf::Predicate)
+  end
+
+  it 'detects stupid AND' do
+    (subject & Alf::Predicate.tautology).should be(subject)
+  end
+
+  it 'detects stupid OR' do
+    (subject | Alf::Predicate.contradiction).should be(subject)
+  end
+
+  it 'has free variables' do
+    (fv = subject.free_variables).should be_a(Alf::AttrList)
+    (fv - Alf::AttrList[ :x, :y ]).should be_empty
+  end
+
+  it 'always splits around and trivially when no free variables are touched' do
+    top, down = subject.and_split(Alf::AttrList[:z])
+    top.should be_tautology
+    down.should eq(subject)
+  end
+
+end
+
+module Alf
+
+  describe 'Predicate.tautology' do
+    subject{ Predicate.tautology }
+
+    it_should_behave_like "a predicate"
+  end
+
+  describe 'Predicate.contradiction' do
+    subject{ Predicate.contradiction }
+
+    it_should_behave_like "a predicate"
+  end
+
+  describe "Predicate.comp" do
+    subject{ Predicate.comp(:lt, {:x => 2}) }
+
+    it_should_behave_like "a predicate"
+  end
+
+  describe "Predicate.in" do
+    subject{ Predicate.in(:x, [2, 3]) }
+
+    it_should_behave_like "a predicate"
+  end
+
+  describe "Predicate.eq" do
+    subject{ Predicate.eq(:x, 2) }
+
+    it_should_behave_like "a predicate"
+  end
+
+  describe "Predicate.neq" do
+    subject{ Predicate.neq(:x, 2) }
+
+    it_should_behave_like "a predicate"
+  end
+
+  describe "Predicate.gt" do
+    subject{ Predicate.gt(:x, 2) }
+
+    it_should_behave_like "a predicate"
+  end
+
+  describe "Predicate.gte" do
+    subject{ Predicate.gte(:x, 2) }
+
+    it_should_behave_like "a predicate"
+  end
+
+  describe "Predicate.lt" do
+    subject{ Predicate.lt(:x, 2) }
+
+    it_should_behave_like "a predicate"
+  end
+
+  describe "Predicate.lte" do
+    subject{ Predicate.lte(:x, 2) }
+
+    it_should_behave_like "a predicate"
+  end
+
+  describe "Predicate.between" do
+    subject{ Predicate.between(:x, 2, 3) }
+
+    it_should_behave_like "a predicate"
+  end
+
+  describe "Predicate.and" do
+    subject{ Predicate.and(Predicate.eq(:x, 12), Predicate.eq(:y, 12)) }
+
+    it_should_behave_like "a predicate"
+  end
+
+  describe "Predicate.or" do
+    subject{ Predicate.or(Predicate.eq(:x, 12), Predicate.eq(:y, 12)) }
+
+    it_should_behave_like "a predicate"
+  end
+
+  describe "Predicate.not" do
+    subject{ Predicate.not(Predicate.in(:x, [12])) }
+
+    it_should_behave_like "a predicate"
+  end
+
+end
+  

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

@@ -0,0 +1,62 @@
+require 'spec_helper'
+module Alf
+  describe Relation, '.coerce' do
+
+    let(:heading) { {sid: String}           }
+    let(:type)    { Relation[heading]       }
+    let(:tuple)   { {sid: 'S1'}             }
+    let(:tuples)  { Set.new << Tuple(tuple) }
+    let(:expected){ type.new(tuples)        }
+
+    subject{ Relation.coerce(arg) }
+
+    context 'on a Relation' do
+      let(:arg){ expected }
+
+      it{ should be(expected) }
+    end
+
+    context 'on a to_relation capable' do
+      let(:arg){ Struct.new(:to_relation).new("Hello") }
+
+      it{ should eq("Hello") }
+    end
+
+    context 'on a single Hash' do
+      let(:arg){ tuple }
+
+      it{ should eq(expected) }
+    end
+
+    context 'on a single Tuple' do
+      let(:arg){ Tuple(tuple) }
+
+      it{ should eq(expected) }
+    end
+
+    context 'on an array of Hashes' do
+      let(:arg){ [tuple] }
+
+      it{ should eq(expected) }
+    end
+
+    context "with unrecognized arg" do
+      let(:arg){ nil }
+      specify{ lambda{ subject }.should raise_error(TypeError) }
+    end
+
+    context 'with files and IOs' do
+      let(:path){ Path.dir/'to_relation.rash' }
+
+      before{ path.write("{:sid => 'S1'}") }
+      after { path.unlink rescue nil       }
+
+      context 'on a Path' do
+        let(:arg){ path }
+
+        it{ should eq(expected) }
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'spec_helper'
+module Alf
+  describe Relation, '.type' do
+
+    let(:heading){ {name: String, status: Integer} }
+    subject{ Relation.type(heading) }
+
+    it 'returns a subclass' do
+      subject.should be_a(Class)
+      subject.superclass.should be(Alf::Relation)
+    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 'supports a tuple type' do
+      Relation[Tuple[heading]].should eq(Relation[heading])
+    end
+
+    it 'is aliased as []' do
+      Relation[heading].should be_a(Class)
+      Relation[heading].should eq(subject)
+    end
+
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'spec_helper'
+module Alf
+  describe Relation, '.allbut' do
+
+    let(:type){ Relation[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(Relation[status: Integer])
+      end
+    end
+
+    context 'with a full attribute list' do
+      let(:attr_list){ AttrList.new([:name, :status]) }
+
+      it 'reuses the type of DUM' do
+        subject.should be(Relation::DUM.class)
+      end
+    end
+
+  end
+end

data/spec/unit/alf-relation/relation/factored-types/test_coerce.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+module Alf
+  describe Relation, '.coerce' do
+
+    subject{ type.coerce(tuples) }
+
+    context 'on single attributes' do
+      let(:type)    { Relation[name: String,  status: Fixnum]  }
+      let(:expected){ Relation(name: "Smith", status: 20)      }
+      let(:tuples){
+        [ {'name' => "Smith", 'status' => "20"} ]
+      }
+
+
+      it 'coerces attributes' do
+        subject.should eq(expected)
+      end
+    end
+
+    context 'with a relation-valued attribute' do
+      let(:type)    { Relation[name: String,  prices: Relation[price: Float]]  }
+      let(:expected){ Relation(name: "Smith", prices: Relation(price: [12.0, 14.0])) }
+      let(:tuples){
+        [{'name' => "Smith", 'prices' => [{'price' => "12.0"}, {'price' => "14.0"}]}]
+      }
+
+      it 'coerces the RVA as well' do
+        subject.should eq(expected)
+      end
+    end
+
+    context 'with a subclass of tuple' do
+      let(:tuple_type){ Class.new(Tuple[price: Integer]) }
+      let(:type){ Relation[tuple_type] }
+      let(:tuples){
+        [{'price' => '12'}]
+      }
+
+      it 'coerces the tuples as correct instances' do
+        subject.all?{|t| t.is_a?(tuple_type) }.should be_true
+      end
+    end
+
+  end
+end

data/spec/unit/alf-relation/relation/factored-types/test_comparisons.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+module Alf
+  describe Relation, '<=>' do
+
+    let(:type)     { Relation[name: String, status: Integer] }
+    let(:supertype){ Relation[name: String, status: Numeric] }
+    let(:subtype)  { Relation[name: String, status: Fixnum]  }
+
+    subject{ type <=> other }
+
+    context 'on something else' do
+      let(:other){ Integer }
+
+      it{ should be_nil }
+    end
+
+    context 'on itself' do
+      let(:other){ type }
+
+      it{ should eq(0) }
+    end
+
+    context 'on same type' do
+      let(:other){ Relation[name: String, status: Integer] }
+
+      it{ should eq(0) }
+    end
+
+    context 'on a sub type' do
+      let(:other){ subtype }
+
+      it{ should eq(1) }
+    end
+
+    context 'on a super type' do
+      let(:other){ supertype }
+
+      it{ should eq(-1) }
+    end
+
+    context 'the shortcuts' do
+
+      it 'the > shortcut classifies correctly' do
+        (supertype > supertype).should be_false
+        (supertype > type).should be_true
+        (supertype > subtype).should be_true
+      end
+
+      it 'the >= shortcut classifies correctly' do
+        (supertype >= supertype).should be_true
+        (supertype >= type).should be_true
+        (supertype >= subtype).should be_true
+      end
+
+      it 'the < shortcut classifies correctly' do
+        (supertype < supertype).should be_false
+        (supertype < type).should be_false
+        (supertype < subtype).should be_false
+      end
+
+      it 'the <= shortcut classifies correctly' do
+        (supertype <= supertype).should be_true
+        (supertype <= type).should be_false
+        (supertype <= subtype).should be_false
+      end
+    end
+
+  end
+end