alf-core 0.15.0 → 0.16.0

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

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

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

@@ -1,28 +0,0 @@
-require 'spec_helper'
-module Alf
-  class Predicate
-    describe Predicate, "hash and ==" do
-
-      subject{ left == right }
-
-      after do
-        left.hash.should eq(right.hash) if subject
-      end
-
-      describe "on equal predicates" do
-        let(:left) { Predicate.coerce(:x => 2) }
-        let(:right){ Predicate.coerce(:x => 2) }
-
-        it{ should be_true }
-      end
-
-      describe "on non equal predicates" do
-        let(:left) { Predicate.coerce(:x => 2) }
-        let(:right){ Predicate.coerce(:x => 3) }
-
-        it{ should be_false }
-      end
-
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-require 'spec_helper'
-module Alf
-  class Predicate
-    describe Predicate, "qualify" do
-
-      let(:p){ Predicate }
-
-      subject{ predicate.qualify(qualifier) }
-
-      let(:qualifier) { {:x => :t} }
-
-      context 'on a full AST predicate' do
-        let(:predicate){ p.in(:x, [2]) & p.eq(:y, 3) }
-
-        it{ should eq(p.in(Factory.qualified_identifier(:t, :x), [2]) & p.eq(:y, 3)) }
-
-        specify "it should tag expressions correctly" do
-          subject.expr.should be_a(Sexpr)
-          subject.expr.should be_a(Expr)
-          subject.expr.should be_a(And)
-        end
-      end
-
-      context 'on a predicate that contains natives' do
-        let(:predicate){ p.in(:x, [2]) & p.native(lambda{}) }
-
-        it 'raises an error' do
-          lambda{
-            subject
-          }.should raise_error(NotSupportedError)
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,78 +0,0 @@
-require 'spec_helper'
-module Alf
-  class Predicate
-    describe Predicate, "rename" do
-
-      let(:p){ Predicate }
-
-      subject{ predicate.rename(renaming) }
-
-      context 'on a pure Renaming' do
-        let(:renaming) { Renaming[:x => :z] }
-
-        context 'on a full AST predicate' do
-          let(:predicate){ p.in(:x, [2]) & p.eq(:y, 3) }
-
-          it{ should eq(p.in(:z, [2]) & p.eq(:y, 3)) }
-
-          specify "it should tag expressions correctly" do
-            subject.expr.should be_a(Sexpr)
-            subject.expr.should be_a(Expr)
-            subject.expr.should be_a(And)
-          end
-        end
-
-        context 'on a predicate that contains natives' do
-          let(:predicate){ p.in(:x, [2]) & p.native(lambda{}) }
-
-          it 'raises an error' do
-            lambda{
-              subject
-            }.should raise_error(NotSupportedError)
-          end
-        end
-
-        context 'on a predicate that contains qualified identifiers' do
-          let(:predicate){ p.eq(Factory.qualified_identifier(:t, :x), 3) }
-
-          it 'renames correctly' do
-            subject.should eq(p.eq(Factory.qualified_identifier(:t, :z), 3))
-          end
-        end
-      end
-
-      context 'when the renamer is a Proc returning identifiers' do
-        let(:renaming){ ->(a){ Grammar.sexpr([:identifier, :y]) } }
-
-        context "on an identifier" do
-          let(:predicate){ p.eq(:x, 2) }
-
-          it{ should eq(p.eq(:y, 2)) }
-        end
-
-        context "on a qualifier identifier" do
-          let(:predicate){ p.eq(Factory.qualified_identifier(:t, :x), 2) }
-
-          it{ should eq(p.eq(:y, 2)) }
-        end
-      end
-
-      context 'when the renamer is a Proc returning qualified identifiers' do
-        let(:renaming){ ->(a){ Grammar.sexpr([:qualified_identifier, :t, :y]) } }
-
-        context 'on an identifier' do
-          let(:predicate){ p.eq(:x, 2) }
-
-          it{ should eq(p.eq(Factory.qualified_identifier(:t, :y), 2)) }
-        end
-
-        context 'on a qualified' do
-          let(:predicate){ p.eq(Factory.qualified_identifier(:t, :x), 2) }
-
-          it{ should eq(p.eq(Factory.qualified_identifier(:t, :y), 2)) }
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-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 "identifier" do
-        subject{ Predicate.identifier(:x) }
-
-        it{ should be_false }
-      end
-
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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("->(t){ t.x == 2 }") }
-      end
-
-      describe "with qualified identifiers" do
-        let(:p){ Predicate.eq(Factory.qualified_identifier(:t, :y), 2) }
-
-        it{ should eq("->(t){ t.y == 2 }") }
-      end
-
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-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("->(t){ t.x == 2 }") }
-      end
-      
-    end
-  end
-end

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

@@ -1,131 +0,0 @@
-require 'spec_helper'
-
-shared_examples_for "a predicate" do
-
-  let(:x){ 12 }
-  let(:y){ 13 }
-
-  it 'provides a proc for easy evaluation' do
-    got = subject.to_proc.call(Tuple(x: 12, y: 13))
-    [ 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.among" do
-    subject{ Predicate.among(: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

@@ -1,62 +0,0 @@
-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_dum.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Relation, '.dum' do
-
-    let(:type){ Relation[name: String, status: Integer] }
-
-    subject{ type.dum }
-
-    it 'returns a Relation' do
-      subject.should be_a(type)
-      subject.should be_a(Relation)
-    end
-
-    it 'is empty' do
-      subject.should be_empty
-    end
-
-  end
-end