alf-core 0.15.0 → 0.16.0

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

@@ -1,70 +0,0 @@
-require 'spec_helper'
-module Alf
-  class Predicate
-    describe Predicate, "!" do
-
-      subject{ !pred }
-
-      context "on tautology" do
-        let(:pred){ Predicate.tautology }
-
-        it{ should eq(Predicate.contradiction) }
-      end
-
-      context "on contradiction" do
-        let(:pred){ Predicate.contradiction }
-
-        it{ should eq(Predicate.tautology) }
-      end
-
-      context "on not" do
-        let(:pred){ Predicate.not(:x) }
-
-        it{ should eq(Predicate.identifier(:x)) }
-      end
-
-      context "on comp" do
-        let(:pred){ Predicate.comp(:eq, :x => 2) }
-
-        it{ should eq(Predicate.comp(:neq, :x => 2)) }
-      end
-
-      context "on eq" do
-        let(:pred){ Predicate.eq(:x => 2) }
-
-        it{ should eq(Predicate.neq(:x => 2)) }
-      end
-
-      context "on neq" do
-        let(:pred){ Predicate.neq(:x => 2) }
-
-        it{ should eq(Predicate.eq(:x => 2)) }
-      end
-
-      context "on lt" do
-        let(:pred){ Predicate.lt(:x => 2) }
-
-        it{ should eq(Predicate.gte(:x => 2)) }
-      end
-
-      context "on lte" do
-        let(:pred){ Predicate.lte(:x => 2) }
-
-        it{ should eq(Predicate.gt(:x => 2)) }
-      end
-
-      context "on gt" do
-        let(:pred){ Predicate.gt(:x => 2) }
-
-        it{ should eq(Predicate.lte(:x => 2)) }
-      end
-
-      context "on gte" do
-        let(:pred){ Predicate.gte(:x => 2) }
-
-        it{ should eq(Predicate.lt(:x => 2)) }
-      end
-
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-require 'spec_helper'
-module Alf
-  class Predicate
-    describe Predicate, "|" do
-
-      let(:left) { Predicate.coerce(x: 2) }
-
-      subject{ left | right }
-
-      before do
-        subject.should be_a(Predicate)
-      end
-
-      context 'with itself' do
-        let(:right){ left }
-
-        it{ should be(left) }
-      end
-
-      context 'with the same expression' do
-        let(:right){ Predicate.coerce(x: 2) }
-
-        it{ should be(left) }
-      end
-
-      context 'with another predicate' do
-        let(:right){ Predicate.coerce(y: 3) }
-
-        it 'should be a expected' do
-          subject.to_ruby_code.should eq("->(t){ (t.x == 2) || (t.y == 3) }")
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,132 +0,0 @@
-require 'spec_helper'
-module Alf
-  class Predicate
-    describe Predicate, ".coerce" do
-
-      subject{ Predicate.coerce(arg) }
-
-      describe "from Predicate" do
-        let(:arg){ Predicate.new(Factory.tautology) }
-
-        it{ should be(arg) }
-      end
-
-      describe "from true" do
-        let(:arg){ true }
-
-        specify{
-          subject.expr.should be_a(Tautology)
-        }
-      end
-
-      describe "from false" do
-        let(:arg){ false }
-
-        specify{
-          subject.expr.should be_a(Contradiction)
-        }
-      end
-
-      describe "from Symbol" do
-        let(:arg){ :status }
-
-        specify{
-          subject.expr.should be_a(Identifier)
-          subject.expr.name.should eq(arg)
-        }
-      end
-
-      describe "from Proc" do
-        let(:arg){ lambda{ status == 10 } }
-
-        specify{
-          subject.expr.should be_a(Native)
-          subject.to_proc.should be(arg)
-        }
-      end
-
-      describe "from String" do
-        let(:arg){ "status == 10" }
-
-        it 'raises an error' do
-          lambda{
-            subject
-          }.should raise_error(ArgumentError)
-        end
-      end
-
-      describe "from Hash (single)" do
-        let(:arg){ {status: 10} }
-
-        specify{
-          subject.expr.should be_a(Eq)
-          subject.expr.should eq([:eq, [:identifier, :status], [:literal, 10]])
-        }
-      end
-
-      describe "from Tuple (single)" do
-        let(:arg){ Tuple(status: 10) }
-
-        specify{
-          subject.expr.should be_a(Eq)
-          subject.expr.should eq([:eq, [:identifier, :status], [:literal, 10]])
-        }
-      end
-
-      describe "from Hash (multiple)" do
-        let(:arg){ {status: 10, name: "Jones"} }
-
-        specify{
-          subject.should eq(Predicate.eq(status: 10) & Predicate.eq(name: "Jones"))
-        }
-      end
-
-      describe "from Tuple (multiple)" do
-        let(:arg){ Tuple(status: 10, name: "Jones") }
-
-        specify{
-          subject.should eq(Predicate.eq(status: 10) & Predicate.eq(name: "Jones"))
-        }
-      end
-
-      describe "from Relation::DUM" do
-        let(:arg){ Relation::DUM }
-
-        specify{
-          subject.should eq(Predicate.contradiction)
-        }
-      end
-
-      describe "from Relation::DEE" do
-        let(:arg){ Relation::DEE }
-
-        specify{
-          subject.should eq(Predicate.tautology)
-        }
-      end
-
-      describe "from Relation (arity=1)" do
-        let(:arg){ Relation(status: [10, 20]) }
-
-        specify{
-          subject.should eq(Predicate.in(:status, [10, 20]))
-        }
-      end
-
-      describe "from Relation (arity>1)" do
-        let(:arg){ Relation([
-          {status: 1, city: "London"},
-          {status: 2, city: "Paris"}
-        ]) }
-        let(:expected){
-          Predicate.eq({status: 1, city: "London"}) | Predicate.eq({status: 2, city: "Paris"})
-        }
-
-        specify{
-          subject.should eq(expected)
-        }
-      end
-
-    end
-  end
-end

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

@@ -1,54 +0,0 @@
-require 'spec_helper'
-module Alf
-  class Predicate
-    describe Predicate, "constant_variables" do
-
-      subject{ p.constant_variables }
-
-      describe "on a comp(:eq)" do
-        let(:p){ Predicate.coerce(x: 2, y: 3) }
-
-        it{ should eq(AttrList[:x, :y]) }
-      end
-
-      describe "on a in with one value" do
-        let(:p){ Predicate.in(:x, [2]) }
-
-        it{ should eq(AttrList[:x]) }
-      end
-
-      describe "on a in with mutiple values" do
-        let(:p){ Predicate.in(:x, [2, 3]) }
-
-        it{ should eq(AttrList::EMPTY) }
-      end
-
-      describe "on a NOT" do
-        let(:p){ !Predicate.coerce(x: 2) }
-
-        it{ should eq(AttrList::EMPTY) }
-      end
-
-      describe "on a AND" do
-        let(:p){ Predicate.coerce(x: 2) & Predicate.coerce(y: 3) }
-
-        it{ should eq(AttrList[:x, :y]) }
-      end
-
-      describe "on a OR" do
-        let(:p){ Predicate.coerce(x: 2) | Predicate.coerce(y: 3) }
-
-        it{ should eq(AttrList::EMPTY) }
-      end
-
-      describe "on a negated OR" do
-        let(:p){ !(Predicate.coerce(x: 2) | Predicate.coerce(y: 3)) }
-
-        pending("NNF would make constant_variables smarter"){
-          it{ should eq(AttrList[:x, :y]) }
-        }
-      end
-
-    end
-  end
-end

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

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

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

@@ -1,70 +0,0 @@
-require 'spec_helper'
-module Alf
-  class Predicate
-    describe Predicate, "evaluate" do
-
-      subject{ predicate.evaluate(scope) }
-
-      context 'on a native predicate of arity 1, used through tuple#[]' do
-        let(:predicate){
-          Predicate.native(->(t){ t[:name] =~ /foo/ })
-        }
-
-        context 'on a matching tuple' do
-          let(:scope){ Support::TupleScope.new(:name => "foo") }
-
-          it{ should be_true }
-        end
-
-        context 'on a non-matching tuple' do
-          let(:scope){ Support::TupleScope.new(:name => "bar") }
-
-          it{ should be_false }
-        end
-      end
-
-      context 'on a native predicate of arity 1, used through tuple.xxx' do
-        let(:predicate){
-          Predicate.native(->(t){ t.name =~ /foo/ })
-        }
-
-        context 'on a matching tuple' do
-          let(:scope){ Support::TupleScope.new(:name => "foo") }
-
-          it{ should be_true }
-        end
-
-        context 'on a non-matching tuple' do
-          let(:scope){ Support::TupleScope.new(:name => "bar") }
-
-          it{ should be_false }
-        end
-      end
-
-      context 'on a factored predicate' do
-        let(:predicate){
-          Predicate.new(Factory.lte(:x => 2))
-        }
-
-        describe "on x == 2" do
-          let(:scope){ Support::TupleScope.new(:x => 2) }
-
-          it{ should be_true }
-        end
-
-        describe "on x == 1" do
-          let(:scope){ Support::TupleScope.new(:x => 1) }
-
-          it{ should be_true }
-        end
-
-        describe "on x == 3" do
-          let(:scope){ Support::TupleScope.new(:x => 3) }
-
-          it{ should be_false }
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,79 +0,0 @@
-require 'spec_helper'
-module Alf
-  class Predicate
-    describe Predicate, "factory methods" do
-
-      before do
-        subject.should be_a(Predicate)
-        subject.expr.should be_a(Expr)
-      end
-
-      context "tautology" do
-        subject{ Predicate.tautology }
-
-        specify{ subject.to_ruby_code.should eq("->(t){ true }") }
-      end
-
-      context "contradiction" do
-        subject{ Predicate.contradiction }
-
-        specify{ subject.to_ruby_code.should eq("->(t){ false }") }
-      end
-
-      context "identifier" do
-        subject{ Predicate.identifier(:x) }
-
-        specify{ subject.to_ruby_code.should eq("->(t){ t.x }") }
-      end
-
-      context "eq" do
-        subject{ Predicate.eq(:x, 2) }
-
-        specify{ subject.to_ruby_code.should eq("->(t){ t.x == 2 }") }
-      end
-
-      context "neq" do
-        subject{ Predicate.neq(:x, 2) }
-
-        specify{ subject.to_ruby_code.should eq("->(t){ t.x != 2 }") }
-      end
-
-      context "lt" do
-        subject{ Predicate.lt(:x, 2) }
-
-        specify{ subject.to_ruby_code.should eq("->(t){ t.x < 2 }") }
-      end
-
-      context "lte" do
-        subject{ Predicate.lte(:x, 2) }
-
-        specify{ subject.to_ruby_code.should eq("->(t){ t.x <= 2 }") }
-      end
-
-      context "gt" do
-        subject{ Predicate.gt(:x, 2) }
-
-        specify{ subject.to_ruby_code.should eq("->(t){ t.x > 2 }") }
-      end
-
-      context "gte" do
-        subject{ Predicate.gte(:x, 2) }
-
-        specify{ subject.to_ruby_code.should eq("->(t){ t.x >= 2 }") }
-      end
-
-      context "literal" do
-        subject{ Predicate.literal(2) }
-
-        specify{ subject.to_ruby_code.should eq("->(t){ 2 }") }
-      end
-
-      context "native" do
-        subject{ Predicate.native(lambda{}) }
-
-        specify{ subject.expr.should be_a(Native) }
-      end
-
-    end
-  end
-end