predicate 1.3.4 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e429a75b5eeee0831bc034adf4f541277eff98aa
-  data.tar.gz: 7186388fb19923f92f5617a7c33e9e070111630f
+  metadata.gz: 95da7e03712cd1ef82ff2668c4411005c006e8b4
+  data.tar.gz: 1e65d370752b431a2a6da2d8aee641a37529c4ce
 SHA512:
-  metadata.gz: b3e1045f4fca26cc8eb11786bf211617f128294a2dbef01843061f16afed69395ba06c69a19e1e8762c81c6881d9fea535586609fac496f0c55659cdae89d59b
-  data.tar.gz: 5ff49f5827934a546e8df8b39e8dc95d8af354ccd82d0fef368d7bfa4e41ac3843ea95148e0305c84488103d4a9c6dec02826aff94039a4d8464503fa0256fc4
+  metadata.gz: 97451f6bf7310bc89fe7093c08a8ae33d2032d243b54f8db20457b12511d70645329581ffde5e440da076ee8dbc269ddea09e039ee616a364e55274eedb9e581
+  data.tar.gz: b2d8cbd6d1986176745fdda9db7c9e66621e48324f02163e3021c42bb122c95fe57e385c899c2513496a637763a97f7ed86afb3e374c6a71b0ad4773cade69fc

data/lib/predicate/factory.rb

@@ -77,6 +77,10 @@ class Predicate
       _factor_predicate([:literal, literal])
     end
 
+    def match(left, right, options = nil)
+      _factor_predicate([:match, sexpr(left), sexpr(right)] + (options.nil? ? [] : [options]))
+    end
+
     def native(arg)
       _factor_predicate([:native, arg])
     end

data/lib/predicate/grammar.rb

@@ -31,4 +31,5 @@ require_relative 'nodes/lte'
 require_relative 'nodes/in'
 require_relative 'nodes/intersect'
 require_relative 'nodes/literal'
+require_relative 'nodes/match'
 require_relative 'nodes/native'

data/lib/predicate/grammar.sexp.yml

@@ -14,6 +14,7 @@ rules:
     - gte
     - in
     - intersect
+    - match
     - native
   tautology:
     - [ true ]
@@ -45,6 +46,8 @@ rules:
     - [ varref, values ]
   intersect:
     - [ varref, values ]
+  match:
+    - [ term, term, options ]
   term:
     - varref
     - literal
@@ -57,5 +60,7 @@ rules:
     - "::Object"
   values:
     - "::Object"
+  options:
+    - "::Hash"
   name:
     !ruby/regexp /^[a-zA-Z0-9_]+[?!]?$/

data/lib/predicate/nodes/expr.rb

@@ -81,20 +81,11 @@ class Predicate
       {}
     end
 
-    def to_ruby_code(scope = 't')
-      code = ToRubyCode.call(self, scope: scope)
-      "->(t){ #{code} }"
-    end
-
     def to_s(scope = nil)
       ToS.call(self, scope: scope)
     end
     alias :inspect :to_s
 
-    def to_proc(scope = 't')
-      Kernel.eval(to_ruby_code(scope))
-    end
-
     def sexpr(arg)
       Factory.sexpr(arg)
     end

data/lib/predicate/nodes/match.rb

@@ -0,0 +1,54 @@
+class Predicate
+  module Match
+    include Expr
+
+    DEFAULT_OPTIONS = {
+      case_sensitive: true
+    }
+
+    def priority
+      80
+    end
+
+    def left
+      self[1]
+    end
+
+    def right
+      self[2]
+    end
+
+    def options
+      @options ||= DEFAULT_OPTIONS.merge(self[3] || {})
+    end
+
+    def case_sentitive?
+      options[:case_sensitive]
+    end
+
+    def free_variables
+      @free_variables ||= left.free_variables | right.free_variables
+    end
+
+    def dyadic_priority
+      800
+    end
+
+    def evaluate(tuple)
+      l = left.evaluate(tuple)
+      r = right.evaluate(tuple)
+      if l.nil? or r.nil?
+        nil
+      elsif l.is_a?(Regexp)
+        l =~ r.to_s
+      elsif r.is_a?(Regexp)
+        r =~ l.to_s
+      elsif options[:case_sensitive]
+        l.to_s.include?(r.to_s)
+      else
+        l.to_s.downcase.include?(r.to_s.downcase)
+      end
+    end
+
+  end
+end

data/lib/predicate/nodes/native.rb

@@ -24,18 +24,6 @@ class Predicate
       { nil => self }
     end
 
-    def to_ruby_code(scope = 't')
-      if proc.respond_to?(:source_code)
-        code = proc.source_code
-        return code if code
-      end
-      raise NotSupportedError
-    end
-
-    def to_proc(scope = 't')
-      proc
-    end
-
     def evaluate(tuple)
       proc.call(tuple)
     end

data/lib/predicate/processors/to_s.rb

@@ -61,6 +61,10 @@ class Predicate
       to_literal(sexpr.last)
     end
 
+    def on_match(sexpr)
+      "#{apply(sexpr.left)} =~ #{apply(sexpr.right)}"
+    end
+
     def on_native(sexpr)
       sexpr.last.inspect
     end

data/lib/predicate/processors.rb

@@ -1,4 +1,3 @@
 require_relative "processors/to_s"
-require_relative "processors/to_ruby_code"
 require_relative "processors/renamer"
 require_relative "processors/qualifier"

data/lib/predicate/sequel/to_sequel.rb

@@ -1,72 +1,85 @@
 class Predicate
   class ToSequel < Sexpr::Processor
+    module Methods
+      def on_identifier(sexpr)
+        ::Sequel.identifier(sexpr.last)
+      end
 
-    def on_identifier(sexpr)
-      ::Sequel.identifier(sexpr.last)
-    end
+      def on_qualified_identifier(sexpr)
+        ::Sequel.identifier(sexpr.name).qualify(sexpr.qualifier)
+      end
 
-    def on_qualified_identifier(sexpr)
-      ::Sequel.identifier(sexpr.name).qualify(sexpr.qualifier)
-    end
+      def on_literal(sexpr)
+        sexpr.last.nil? ? nil : ::Sequel.expr(sexpr.last)
+      end
 
-    def on_literal(sexpr)
-      sexpr.last.nil? ? nil : ::Sequel.expr(sexpr.last)
-    end
+      ###
 
-    ###
+      def on_tautology(sexpr)
+        ::Sequel::SQL::BooleanConstant.new(true)
+      end
 
-    def on_tautology(sexpr)
-      ::Sequel::SQL::BooleanConstant.new(true)
-    end
+      def on_contradiction(sexpr)
+        ::Sequel::SQL::BooleanConstant.new(false)
+      end
 
-    def on_contradiction(sexpr)
-      ::Sequel::SQL::BooleanConstant.new(false)
-    end
+      def on_eq(sexpr)
+        left, right = apply(sexpr.left), apply(sexpr.right)
+        ::Sequel.expr(left => right)
+      end
 
-    def on_eq(sexpr)
-      left, right = apply(sexpr.left), apply(sexpr.right)
-      ::Sequel.expr(left => right)
-    end
+      def on_neq(sexpr)
+        left, right = apply(sexpr.left), apply(sexpr.right)
+        ~::Sequel.expr(left => right)
+      end
 
-    def on_neq(sexpr)
-      left, right = apply(sexpr.left), apply(sexpr.right)
-      ~::Sequel.expr(left => right)
-    end
+      def on_dyadic_comp(sexpr)
+        left, right = apply(sexpr.left), apply(sexpr.right)
+        left.send(sexpr.operator_symbol, right)
+      end
+      alias :on_lt  :on_dyadic_comp
+      alias :on_lte :on_dyadic_comp
+      alias :on_gt  :on_dyadic_comp
+      alias :on_gte :on_dyadic_comp
 
-    def on_dyadic_comp(sexpr)
-      left, right = apply(sexpr.left), apply(sexpr.right)
-      left.send(sexpr.operator_symbol, right)
-    end
-    alias :on_lt  :on_dyadic_comp
-    alias :on_lte :on_dyadic_comp
-    alias :on_gt  :on_dyadic_comp
-    alias :on_gte :on_dyadic_comp
+      def on_in(sexpr)
+        left, right = apply(sexpr.identifier), sexpr.last
+        right = [right] if !right.is_a?(Array) && right.respond_to?(:sql_literal)
+        ::Sequel.expr(left => right)
+      end
 
-    def on_in(sexpr)
-      left, right = apply(sexpr.identifier), sexpr.last
-      right = [right] if !right.is_a?(Array) && right.respond_to?(:sql_literal)
-      ::Sequel.expr(left => right)
-    end
+      def on_not(sexpr)
+        ~apply(sexpr.last)
+      end
 
-    def on_not(sexpr)
-      ~apply(sexpr.last)
-    end
+      def on_and(sexpr)
+        body = sexpr.sexpr_body
+        body[1..-1].inject(apply(body.first)){|f,t| f & apply(t) }
+      end
 
-    def on_and(sexpr)
-      body = sexpr.sexpr_body
-      body[1..-1].inject(apply(body.first)){|f,t| f & apply(t) }
-    end
+      def on_or(sexpr)
+        body = sexpr.sexpr_body
+        body[1..-1].inject(apply(body.first)){|f,t| f | apply(t) }
+      end
 
-    def on_or(sexpr)
-      body = sexpr.sexpr_body
-      body[1..-1].inject(apply(body.first)){|f,t| f | apply(t) }
-    end
+      def on_match(sexpr)
+        left, right = sexpr.left, sexpr.right
+        left  = [ left.first,  "%#{left.last}%"  ] if left.first  == :literal && !left.last.is_a?(Regexp)
+        right = [ right.first, "%#{right.last}%" ] if right.first == :literal && !right.last.is_a?(Regexp)
+        left, right = apply(left), apply(right)
+        if sexpr.case_sentitive?
+          left.like(right)
+        else
+          left.ilike(right)
+        end
+      end
 
-    def on_unsupported(sexpr)
-      raise NotSupportedError
+      def on_unsupported(sexpr)
+        raise NotSupportedError
+      end
+      alias :on_native :on_unsupported
+      alias :on_intersect :on_unsupported
     end
-    alias :on_native :on_unsupported
-    alias :on_intersect :on_unsupported
-
+    include Methods
   end # class ToSequel
 end # class Predicate

data/lib/predicate/version.rb

@@ -1,8 +1,8 @@
 class Predicate
   module Version
-    MAJOR = 1
-    MINOR = 3
-    TINY  = 4
+    MAJOR = 2
+    MINOR = 0
+    TINY  = 0
   end
   VERSION = "#{Version::MAJOR}.#{Version::MINOR}.#{Version::TINY}"
 end

data/lib/predicate.rb

@@ -122,16 +122,8 @@ class Predicate
     expr.hash
   end
 
-  def to_ruby_code(scope = "t")
-    expr.to_ruby_code(scope)
-  end
-
   def to_s(scope = nil)
     expr.to_s(scope)
   end
 
-  def to_proc
-    @proc ||= expr.to_proc("t")
-  end
-
 end # class Predicate

data/spec/factory/test_match.rb

@@ -0,0 +1,27 @@
+require_relative 'shared/a_predicate_ast_node'
+class Predicate
+  describe Factory, 'match' do
+    include Factory
+
+    context 'without options' do
+      subject{ match(:name, "London") }
+
+      it_should_behave_like "a predicate AST node"
+
+      it{ should be_a(Match) }
+
+      it{ should eql([:match, [:identifier, :name], [:literal, "London"]]) }
+    end
+
+    context 'with options' do
+      subject{ match(:name, "London", case_sensitive: false) }
+
+      it_should_behave_like "a predicate AST node"
+
+      it{ should be_a(Match) }
+
+      it{ should eql([:match, [:identifier, :name], [:literal, "London"], {case_sensitive: false}]) }
+    end
+
+  end
+end

data/spec/grammar/test_match.rb

@@ -78,6 +78,18 @@ class Predicate
       end
     end
 
+    context "match" do
+      subject{ Grammar[:match] }
+
+      it 'matches valid ASTs' do
+        subject.should be_match([:match, [:identifier, :name], [:literal, "London"], {}])
+        subject.should be_match([:match, [:identifier, :name], [:literal, /London/], {}])
+      end
+      it 'does not match invalid ASTs' do
+        subject.should_not be_match([:native, 12])
+      end
+    end
+
     context "native" do
       subject{ Grammar[:native] }
 

data/spec/nodes/and/test_and.rb

@@ -17,10 +17,6 @@ class Predicate
         expect(subject).to be_a(And)
         expect(subject.size).to eql(4)
       end
-
-      it 'is as expected' do
-        expect(subject.to_ruby_code).to eql("->(t){ (t[:x] == 2) && (t[:y] == 3) && (t[:z] == 4) }")
-      end
     end
 
     context 'with another and' do
@@ -32,10 +28,6 @@ class Predicate
         expect(subject).to be_a(And)
         expect(subject.size).to eql(5)
       end
-
-      it 'is as expected' do
-        expect(subject.to_ruby_code).to eql("->(t){ (t[:x] == 2) && (t[:y] == 3) && (t[:w] == 5) && (t[:z] == 4) }")
-      end
     end
 
   end

data/spec/predicate/test_and_split.rb

@@ -53,5 +53,23 @@ class Predicate
       it{ should eq([ p.tautology, pred ]) }
     end
 
+    context "on match (included)" do
+      let(:pred){ p.match(:x, "London") }
+
+      it{ should eq([ pred, p.tautology ]) }
+    end
+
+    context "on match (excluded)" do
+      let(:pred){ p.match(:y, "London") }
+
+      it{ should eq([ p.tautology, pred ]) }
+    end
+
+    context "on match (included on right)" do
+      let(:pred){ p.match(:y, :x) }
+
+      it{ should eq([ pred, p.tautology ]) }
+    end
+
   end
 end

data/spec/predicate/test_attr_split.rb

@@ -35,5 +35,17 @@ class Predicate
       it{ should eq({ x: pred }) }
     end
 
+    context "on match" do
+      let(:pred){ p.match(:x, "London") }
+
+      it{ should eq({ x: pred }) }
+    end
+
+    context "on match with two identifiers" do
+      let(:pred){ p.match(:x, :y) }
+
+      it{ should eq({ nil => pred }) }
+    end
+
   end
 end

data/spec/predicate/test_bool_and.rb

@@ -22,14 +22,6 @@ class Predicate
       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
-
     context 'with tautology' do
       let(:right){ Predicate.tautology }
 

data/spec/predicate/test_bool_or.rb

@@ -22,13 +22,5 @@ class Predicate
       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

@@ -40,7 +40,6 @@ class Predicate
 
       specify{
         subject.expr.should be_a(Native)
-        subject.to_proc.should be(arg)
       }
     end
 

data/spec/predicate/test_constants.rb

@@ -101,6 +101,12 @@ class Predicate
       it{ should eq({}) }
     end
 
+    context "on match" do
+      let(:pred){ p.match(:x, "London") }
+
+      it{ should eq({}) }
+    end
+
     context "on native" do
       let(:pred){ p.native(->(t){}) }
 

data/spec/predicate/test_evaluate.rb

@@ -98,5 +98,123 @@ class Predicate
       end
     end
 
+    context 'on a match against a string' do
+      let(:predicate){
+        Predicate.match(:x, "12")
+      }
+
+      it "matches when expected" do
+        [
+          { x: 12 },
+          { x: "12" },
+          { x: "Once upon a time, in 12" },
+          { x: "Once upon a time, in 12!" },
+        ].each do |tuple|
+          expect(predicate.evaluate(tuple)).to be_truthy
+        end
+      end
+
+      it "does not match when not expected" do
+        [
+          { x: 17 },
+          { x: nil },
+          { x: "Londan" },
+          { x: "london" },
+          { x: "Once upon a time, in Londan" },
+          { x: "Once upon a time, in Londan!" },
+          { },
+          { y: "London" }
+        ].each do |tuple|
+          expect(predicate.evaluate(tuple)).to be_falsy
+        end
+      end
+    end
+
+    context 'on a match against a string, case insensitive' do
+      let(:predicate){
+        Predicate.match(:x, "London", case_sensitive: false)
+      }
+
+      it "matches when expected" do
+        [
+          { x: "London" },
+          { x: "london" },
+          { x: "Once upon a time, in London" },
+          { x: "Once upon a time, in London!" },
+          { x: "Once upon a time, in london!" },
+        ].each do |tuple|
+          expect(predicate.evaluate(tuple)).to be_truthy
+        end
+      end
+
+      it "does not match when not expected" do
+        [
+          { x: "Londan" },
+          { x: "Once upon a time, in Londan" },
+          { x: "Once upon a time, in Londan!" },
+          { },
+          { y: "London" }
+        ].each do |tuple|
+          expect(predicate.evaluate(tuple)).to be_falsy
+        end
+      end
+    end
+
+    context 'on a match against a regexp' do
+      let(:predicate){
+        Predicate.match(:x, /London/i)
+      }
+
+      it "matches when expected" do
+        [
+          { x: "London" },
+          { x: "london" },
+          { x: "Once upon a time, in London" },
+          { x: "Once upon a time, in London!" },
+          { x: "Once upon a time, in london!" },
+        ].each do |tuple|
+          expect(predicate.evaluate(tuple)).to be_truthy
+        end
+      end
+
+      it "does not match when not expected" do
+        [
+          { x: 17 },
+          { x: "Londan" },
+          { x: "Once upon a time, in Londan" },
+          { x: "Once upon a time, in Londan!" },
+          { },
+          { y: "London" }
+        ].each do |tuple|
+          expect(predicate.evaluate(tuple)).to be_falsy
+        end
+      end
+    end
+
+    context 'on a match against a another attribute' do
+      let(:predicate){
+        Predicate.match(:x, :y)
+      }
+
+      it "matches when expected" do
+        [
+          { x: "London", y: "London" },
+          { x: "Once upon a time in London", y: "London" },
+        ].each do |tuple|
+          expect(predicate.evaluate(tuple)).to be_truthy
+        end
+      end
+
+      it "does not match when not expected" do
+        [
+          { x: 17 },
+          { x: "Londan", y: "London" },
+          { x: "London", y: "Once upon a time in London" },
+        ].each do |tuple|
+          expect(predicate.evaluate(tuple)).to be_falsy
+        end
+      end
+    end
+
   end
 end

data/spec/sequel/test_to_sequel.rb

@@ -140,6 +140,39 @@ class Predicate
       end
     end
 
+    context 'match' do
+      let(:predicate) { Predicate.match(left, right, options) }
+      let(:options){ nil }
+
+      context '(attr, String)' do
+        let(:left){ :x }
+        let(:right){ "London" }
+
+        it 'works as expected' do
+          expect(subject).to eql("SELECT * FROM `items` WHERE (`x` LIKE '%London%' ESCAPE '\\')")
+        end
+      end
+
+      context '(attr, String, case_sensitive: false)' do
+        let(:left){ :x }
+        let(:right){ "London" }
+        let(:options){ { case_sensitive: false } }
+
+        it 'works as expected' do
+          expect(subject).to eql("SELECT * FROM `items` WHERE (UPPER(`x`) LIKE UPPER('%London%') ESCAPE '\\')")
+        end
+      end
+
+      context '(attr, Regexp)' do
+        let(:left){ :x }
+        let(:right){ /London/i }
+
+        pending 'works as expected' do
+          expect(subject).to eql("SELECT * FROM `items` WHERE (`x` LIKE '%London%' ESCAPE '\\')")
+        end
+      end
+    end
+
     context 'native' do
       let(:predicate) { Predicate.native(->(t){ false }) }
 

data/spec/test_predicate.rb

@@ -6,11 +6,6 @@ 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(w: w, x: x, y: y)
-    [ TrueClass, FalseClass ].should include(got.class)
-  end
-
   it 'can be negated easily' do
     (!subject).should be_a(Predicate)
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: predicate
 version: !ruby/object:Gem::Version
-  version: 1.3.4
+  version: 2.0.0
 platform: ruby
 authors:
 - Bernard Lambeau
@@ -107,6 +107,7 @@ files:
 - lib/predicate/nodes/literal.rb
 - lib/predicate/nodes/lt.rb
 - lib/predicate/nodes/lte.rb
+- lib/predicate/nodes/match.rb
 - lib/predicate/nodes/nadic_bool.rb
 - lib/predicate/nodes/native.rb
 - lib/predicate/nodes/neq.rb
@@ -117,13 +118,10 @@ files:
 - lib/predicate/processors.rb
 - lib/predicate/processors/qualifier.rb
 - lib/predicate/processors/renamer.rb
-- lib/predicate/processors/to_ruby_code.rb
 - lib/predicate/processors/to_s.rb
 - lib/predicate/sequel.rb
 - lib/predicate/sequel/to_sequel.rb
 - lib/predicate/version.rb
-- spec/expr/test_to_proc.rb
-- spec/expr/test_to_ruby_code.rb
 - spec/factory/shared/a_comparison_factory_method.rb
 - spec/factory/shared/a_predicate_ast_node.rb
 - spec/factory/test_and.rb
@@ -141,6 +139,7 @@ files:
 - spec/factory/test_literal.rb
 - spec/factory/test_lt.rb
 - spec/factory/test_lte.rb
+- spec/factory/test_match.rb
 - spec/factory/test_native.rb
 - spec/factory/test_neq.rb
 - spec/factory/test_not.rb
@@ -174,14 +173,11 @@ files:
 - spec/predicate/test_constants.rb
 - spec/predicate/test_contradiction.rb
 - spec/predicate/test_evaluate.rb
-- spec/predicate/test_factory_methods.rb
 - spec/predicate/test_free_variables.rb
 - spec/predicate/test_hash_and_equal.rb
 - spec/predicate/test_qualify.rb
 - spec/predicate/test_rename.rb
 - spec/predicate/test_tautology.rb
-- spec/predicate/test_to_proc.rb
-- spec/predicate/test_to_ruby_code.rb
 - spec/sequel/test_to_sequel.rb
 - spec/spec_helper.rb
 - spec/test_predicate.rb

data/lib/predicate/processors/to_ruby_code.rb

@@ -1,76 +0,0 @@
-class Predicate
-  class ToRubyCode < Sexpr::Processor
-
-    def on_tautology(sexpr)
-      "true"
-    end
-
-    def on_contradiction(sexpr)
-      "false"
-    end
-
-    def on_qualified_identifier(sexpr)
-      "#{sexpr.qualifier}[:#{sexpr.name}]"
-    end
-
-    def on_identifier(sexpr)
-      if s = options[:scope]
-        "#{s}[:#{sexpr.last.to_s}]"
-      else
-        sexpr.last.to_s
-      end
-    end
-
-    def on_not(sexpr)
-      "#{sexpr.operator_symbol}" << apply(sexpr.last, sexpr)
-    end
-
-    def on_nadic_bool(sexpr)
-      sexpr.sexpr_body.map{|term|
-        apply(term, sexpr)
-      }.join(" #{sexpr.operator_symbol} ")
-    end
-    alias :on_and :on_nadic_bool
-    alias :on_or  :on_nadic_bool
-
-    def on_dyadic(sexpr)
-      sexpr.sexpr_body.map{|term|
-        apply(term, sexpr)
-      }.join(" #{sexpr.operator_symbol} ")
-    end
-    alias :on_eq  :on_dyadic
-    alias :on_neq :on_dyadic
-    alias :on_lt  :on_dyadic
-    alias :on_lte :on_dyadic
-    alias :on_gt  :on_dyadic
-    alias :on_gte :on_dyadic
-
-    def on_in(sexpr)
-      "#{to_ruby_literal(sexpr.values)}.include?(#{apply(sexpr.identifier)})"
-    end
-
-    def on_intersect(sexpr)
-      t_x = apply(sexpr.identifier)
-      "!#{t_x}.nil? && !(#{t_x} & #{to_ruby_literal(sexpr.values)}).empty?"
-    end
-
-    def on_literal(sexpr)
-      to_ruby_literal(sexpr.last)
-    end
-
-  protected
-
-    def to_ruby_literal(x)
-      x.inspect
-    end
-
-    def apply(sexpr, parent = nil)
-      code = super(sexpr)
-      if parent && (parent.priority >= sexpr.priority)
-        code = "(" << code << ")"
-      end
-      code
-    end
-
-  end
-end

data/spec/expr/test_to_proc.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-class Predicate
-  describe Expr, "to_proc" do
-
-    let(:expr){ Factory.lte(:x, 2) }
-
-    subject{ expr.to_proc }
-
-    it{ should be_a(Proc) }
-
-    it 'has arity 1' do
-      subject.arity.should eq(1)
-    end
-
-  end
-end

data/spec/expr/test_to_ruby_code.rb

@@ -1,152 +0,0 @@
-require 'spec_helper'
-class Predicate
-  describe Expr, "to_ruby_code" do
-
-    let(:f){ Factory }
-
-    subject{ expr.to_ruby_code }
-
-    after do
-      unless expr.is_a?(Native)
-        lambda{
-          eval(subject)
-        }.should_not raise_error
-      end
-    end
-
-    context 'tautology' do
-      let(:expr){ f.tautology }
-
-      it{ should eq("->(t){ true }") }
-    end
-
-    context 'contradiction' do
-      let(:expr){ f.contradiction }
-
-      it{ should eq("->(t){ false }") }
-    end
-
-    describe "identifier" do
-      let(:expr){ f.identifier(:name) }
-
-      it{ should eq("->(t){ t[:name] }") }
-    end
-
-    describe "and" do
-      let(:expr){ f.and(f.contradiction, f.contradiction) }
-
-      it{ should eq("->(t){ false && false }") }
-    end
-
-    describe "or" do
-      let(:expr){ f.or(f.contradiction, f.contradiction) }
-
-      it{ should eq("->(t){ false || false }") }
-    end
-
-    describe "not" do
-      let(:expr){ f.not(f.contradiction) }
-
-      it{ should eq("->(t){ !false }") }
-    end
-
-    describe "comp" do
-      let(:expr){ f.comp(:lt, {:x => 2}) }
-
-      it{ should eq("->(t){ t[:x] < 2 }") }
-    end
-
-    describe "eq" do
-      let(:expr){ f.eq(:x, 2) }
-
-      it{ should eq("->(t){ t[:x] == 2 }") }
-    end
-
-    describe "eq (parentheses required)" do
-      let(:expr){ f.eq(f.eq(:y, 2), true) }
-
-      it{ should eq("->(t){ (t[:y] == 2) == true }") }
-    end
-
-    describe "comp (multiple)" do
-      let(:expr){ f.comp(:eq, :x => 2, :y => 3) }
-
-      it{ should eq("->(t){ (t[:x] == 2) && (t[:y] == 3) }") }
-    end
-
-    describe "in" do
-      let(:expr){ f.in(:x, [2, 3]) }
-
-      it{ should eq("->(t){ [2, 3].include?(t[:x]) }") }
-    end
-
-    describe "neq" do
-      let(:expr){ f.neq(:x, 2) }
-
-      it{ should eq("->(t){ t[:x] != 2 }") }
-    end
-
-    describe "gt" do
-      let(:expr){ f.gt(:x, 2) }
-
-      it{ should eq("->(t){ t[:x] > 2 }") }
-    end
-
-    describe "gte" do
-      let(:expr){ f.gte(:x, 2) }
-
-      it{ should eq("->(t){ t[:x] >= 2 }") }
-    end
-
-    describe "lt" do
-      let(:expr){ f.lt(:x, 2) }
-
-      it{ should eq("->(t){ t[:x] < 2 }") }
-    end
-
-    describe "lte" do
-      let(:expr){ f.lte(:x, 2) }
-
-      it{ should eq("->(t){ t[:x] <= 2 }") }
-    end
-
-    describe "literal" do
-      let(:expr){ f.literal(12) }
-
-      it{ should eq("->(t){ 12 }") }
-    end
-
-    describe "native" do
-      let(:expr){ f.native(lambda{}) }
-
-      specify{
-        lambda{ subject }.should raise_error(NotSupportedError)
-      }
-    end
-
-    describe "conjunction of two eqs" do
-      let(:expr){
-        f.and(f.eq(:x, 2), f.eq(:y, 3))
-      }
-
-      it{ should eq("->(t){ (t[:x] == 2) && (t[:y] == 3) }") }
-    end
-
-    describe "conjunction of two comps" do
-      let(:expr){
-        f.and(f.comp(:eq, :x => 2), f.comp(:eq, :y => 3))
-      }
-
-      it{ should eq("->(t){ (t[:x] == 2) && (t[:y] == 3) }") }
-    end
-
-    describe "or and and" do
-      let(:expr){
-        f.and(f.eq(:x, 2), f.or(true, false))
-      }
-
-      it{ should eq("->(t){ (t[:x] == 2) && (true || false) }") }
-    end
-
-  end
-end

data/spec/predicate/test_factory_methods.rb

@@ -1,83 +0,0 @@
-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
-
-    context 'intersect' do
-      subject{ Predicate.intersect(:x, [7,8]) }
-
-      specify{ subject.to_ruby_code.should eq("->(t){ !t[:x].nil? && !(t[:x] & [7, 8]).empty? }") }
-    end
-
-  end
-end

data/spec/predicate/test_to_proc.rb

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

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