predicate 1.0.0

data/spec/predicate/test_bool_or.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+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

data/spec/predicate/test_coerce.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+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 Hash (multiple)" do
+      let(:arg){ {status: 10, name: "Jones"} }
+
+      specify{
+        subject.should eq(Predicate.eq(status: 10) & Predicate.eq(name: "Jones"))
+      }
+    end
+
+  end
+end

data/spec/predicate/test_constant_variables.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+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{ expect(subject).to eql([:x, :y]) }
+    end
+
+    describe "on a in with one value" do
+      let(:p){ Predicate.in(:x, [2]) }
+
+      it{ expect(subject).to eql([:x]) }
+    end
+
+    describe "on a in with mutiple values" do
+      let(:p){ Predicate.in(:x, [2, 3]) }
+
+      it{ expect(subject).to eql([]) }
+    end
+
+    describe "on a NOT" do
+      let(:p){ !Predicate.coerce(x: 2) }
+
+      it{ expect(subject).to eql([]) }
+    end
+
+    describe "on a AND" do
+      let(:p){ Predicate.coerce(x: 2) & Predicate.coerce(y: 3) }
+
+      it{ expect(subject).to eql([:x, :y]) }
+    end
+
+    describe "on a OR" do
+      let(:p){ Predicate.coerce(x: 2) | Predicate.coerce(y: 3) }
+
+      it{ expect(subject).to eql([]) }
+    end
+
+    describe "on a negated OR" do
+      let(:p){ !(Predicate.coerce(x: 2) | Predicate.coerce(y: 3)) }
+
+      pending("NNF would make constant_variables smarter"){
+        expect(subject).to eql([:x, :y])
+      }
+    end
+
+  end
+end

data/spec/predicate/test_contradiction.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+class Predicate
+  describe Predicate, "contradiction?" do
+
+    context "tautology" do
+      subject{ Predicate.tautology }
+
+      it{ expect(subject.contradiction?).to be(false) }
+    end
+
+    context "contradiction" do
+      subject{ Predicate.contradiction }
+
+      it{ expect(subject.contradiction?).to be(true) }
+    end
+
+    context "identifier" do
+      subject{ Predicate.identifier(:x) }
+
+      it{ expect(subject.contradiction?).to be(false) }
+    end
+
+  end
+end

data/spec/predicate/test_evaluate.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+class Predicate
+  describe Predicate, "evaluate" do
+
+    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){ { :name => "foo" } }
+
+        it{ expect(predicate.evaluate(scope)).to be_truthy }
+      end
+
+      context 'on a non-matching tuple' do
+        let(:scope){ { :name => "bar" } }
+
+        it{ expect(predicate.evaluate(scope)).to be_falsy }
+      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){ { :name => "foo" } }
+
+        it{ expect(predicate.evaluate(scope)).to be_truthy }
+      end
+
+      context 'on a non-matching tuple' do
+        let(:scope){ { :name => "bar" } }
+
+        it{ expect(predicate.evaluate(scope)).to be_falsy }
+      end
+    end
+
+    context 'on a factored predicate' do
+      let(:predicate){
+        Predicate.new(Factory.lte(:x => 2))
+      }
+
+      describe "on x == 2" do
+        let(:scope){ { :x => 2 } }
+
+        it{ expect(predicate.evaluate(scope)).to be_truthy }
+      end
+
+      describe "on x == 1" do
+        let(:scope){ { :x => 1 } }
+
+        it{ expect(predicate.evaluate(scope)).to be_truthy }
+      end
+
+      describe "on x == 3" do
+        let(:scope){ { :x => 3 } }
+
+        it{ expect(predicate.evaluate(scope)).to be_falsy }
+      end
+    end
+
+  end
+end

data/spec/predicate/test_factory_methods.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+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

data/spec/predicate/test_free_variables.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+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([:x]) }
+    end
+    
+  end
+end

data/spec/predicate/test_hash_and_equal.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+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

data/spec/predicate/test_qualify.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+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

data/spec/predicate/test_rename.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+class Predicate
+  describe Predicate, "rename" do
+
+    let(:p){ Predicate }
+
+    subject{ predicate.rename(renaming) }
+
+    context 'on a pure renaming hash' do
+      let(: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

data/spec/predicate/test_tautology.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+class Predicate
+  describe Predicate, "tautology?" do
+
+    context "tautology" do
+      subject{ Predicate.tautology }
+
+      it{ expect(subject.tautology?).to be(true) }
+    end
+
+    context "contradiction" do
+      subject{ Predicate.contradiction }
+
+      it{ expect(subject.tautology?).to be(false) }
+    end
+
+    context "identifier" do
+      subject{ Predicate.identifier(:x) }
+
+      it{ expect(subject.tautology?).to be(false) }
+    end
+
+  end
+end

data/spec/predicate/test_to_proc.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+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

data/spec/predicate/test_to_ruby_code.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+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

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require "rspec"
+require 'predicate'
+
+module Helpers
+
+end
+
+RSpec.configure do |c|
+  c.include Helpers
+  c.extend  Helpers
+end

data/spec/test_predicate.rb

@@ -0,0 +1,127 @@
+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(x: 12, y: 13)
+    [ TrueClass, FalseClass ].should include(got.class)
+  end
+
+  it 'can be negated easily' do
+    (!subject).should be_a(Predicate)
+  end
+
+  it 'detects stupid AND' do
+    (subject & Predicate.tautology).should be(subject)
+  end
+
+  it 'detects stupid OR' do
+    (subject | Predicate.contradiction).should be(subject)
+  end
+
+  it 'has free variables' do
+    (fv = subject.free_variables).should be_a(Array)
+    (fv - [ :x, :y ]).should be_empty
+  end
+
+  it 'always splits around and trivially when no free variables are touched' do
+    top, down = subject.and_split([:z])
+    top.should be_tautology
+    down.should eq(subject)
+  end
+
+end
+
+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
+  

data/tasks/test.rake

@@ -0,0 +1,11 @@
+namespace :test do
+
+  desc %q{Run all RSpec tests}
+  task :unit do
+    require 'rspec'
+    RSpec::Core::Runner.run(%w[-I. -Ilib -Ispec --pattern=spec/**/test_*.rb --color .])
+  end
+
+  task :all => :"unit"
+end
+task :test => :"test:all"