predicate 1.1.3 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 301830894045bb25bd0641f77273a4924e8ff743
-  data.tar.gz: b04f894cb93548246b50085170cc83e3d1476acc
+  metadata.gz: 710a45c31d1350beeded48ea522d3e868925e600
+  data.tar.gz: 8e9acddd67b337218c749aa6744940b26ca8568e
 SHA512:
-  metadata.gz: 3e1968b96700a0cb15da2d143fa3d0776d26ee54855232dc0e30e2854748ffd5b12c3767cb8121d95aa006d6c6a6695bf091ea262d4a8de5e1c5c099e73d730c
-  data.tar.gz: 3f0c0192c97d90654b36de5dbaf4a94c18a86a1787a13d27ec9d127902b8c48cd5969bca338695024b33dbd62f8dcfcfc1513cb44bcc9adcfbd2d39ef74bd1a0
+  metadata.gz: e3d92a4dfa7227cbac8dc6b9dc9e4856861983103e2840ad041721269a66ecce74980750293178b3c3cdc9f34c06aa2d5a396880634f47e84a0b03aaac3a202d
+  data.tar.gz: ff1eee7dcc029585926d897eb5f3da17b68dd6f392f6e2c73bb50208ae00d22aedf0422feccea4cf747d869555b37dfa720407aa73746dd74935cfd52384f8de

data/lib/predicate/factory.rb

@@ -35,6 +35,11 @@ class Predicate
     end
     alias :among :in
 
+    def intersect(identifier, values)
+      identifier = sexpr(identifier) if identifier.is_a?(Symbol)
+      _factor_predicate([:intersect, identifier, values])
+    end
+
     def comp(op, h)
       from_hash(h, op)
     end

data/lib/predicate/grammar.rb

@@ -29,5 +29,6 @@ require_relative 'nodes/gte'
 require_relative 'nodes/lt'
 require_relative 'nodes/lte'
 require_relative 'nodes/in'
+require_relative 'nodes/intersect'
 require_relative 'nodes/literal'
 require_relative 'nodes/native'

data/lib/predicate/grammar.sexp.yml

@@ -13,6 +13,7 @@ rules:
     - gt
     - gte
     - in
+    - intersect
     - native
   tautology:
     - [ true ]
@@ -42,6 +43,8 @@ rules:
     - [ term, term ]
   in:
     - [ varref, values ]
+  intersect:
+    - [ varref, values ]
   term:
     - varref
     - literal

data/lib/predicate/nodes/and.rb

@@ -18,6 +18,16 @@ class Predicate
       end
     end
 
+    def attr_split
+      # Similar to and_split above, but the reasonning applies on
+      # attribute names this time.
+      sexpr_body.each_with_object({}) do |term, h|
+        term.attr_split.each_pair do |a,p|
+          h[a] = (h[a] || tautology) & p
+        end
+      end
+    end
+
     def constant_variables
       sexpr_body.inject([]) do |cvars,expr|
         cvars | expr.constant_variables

data/lib/predicate/nodes/contradiction.rb

@@ -26,5 +26,9 @@ class Predicate
       @free_variables ||= []
     end
 
+    def attr_split
+      { nil => self }
+    end
+
   end
 end

data/lib/predicate/nodes/expr.rb

@@ -40,6 +40,18 @@ class Predicate
       (free_variables & attr_list).empty? ? [ tautology, self ] : [ self, tautology ]
     end
 
+    def attr_split
+      # if I have only one variable reference, then I can return
+      # myself mapped to that variable...
+      if (vars = free_variables).size == 1
+        { vars.first => self }
+      else
+        # I must still map myself to nil to meet the conjunction
+        # specification
+        { nil => self }
+      end
+    end
+
     def rename(renaming)
       Renamer.call(self, :renaming => renaming)
     end

data/lib/predicate/nodes/intersect.rb

@@ -0,0 +1,26 @@
+class Predicate
+  module Intersect
+    include Expr
+
+    def priority
+      80
+    end
+
+    def identifier
+      self[1]
+    end
+
+    def values
+      self[2]
+    end
+
+    def free_variables
+      @free_variables ||= identifier.free_variables
+    end
+
+    def constant_variables
+      values.size == 1 ? free_variables : []
+    end
+
+  end
+end

data/lib/predicate/nodes/native.rb

@@ -10,12 +10,20 @@ class Predicate
       self[1]
     end
 
+    # overriden because parent relies on free_variables,
+    # which raises an exception
     def and_split(attr_list)
       # I possibly make references to those attributes, so
       # I can't be P2
       [ self, tautology ]
     end
 
+    # overriden because parent relies on free_variables,
+    # which raises an exception
+    def attr_split
+      { nil => self }
+    end
+
     def to_ruby_code(scope = 't')
       if proc.respond_to?(:source_code)
         code = proc.source_code

data/lib/predicate/nodes/tautology.rb

@@ -26,5 +26,9 @@ class Predicate
       @free_variables ||= []
     end
 
+    def attr_split
+      {}
+    end
+
   end
 end

data/lib/predicate/processors/qualifier.rb

@@ -9,8 +9,13 @@ class Predicate
     attr_reader :qualifier
 
     def on_identifier(sexpr)
-      return sexpr unless q = qualifier[sexpr.name]
-      [:qualified_identifier, q, sexpr.name]
+      case qualifier
+      when Symbol
+        [:qualified_identifier, qualifier, sexpr.name]
+      else
+        return sexpr unless q = qualifier[sexpr.name]
+        [:qualified_identifier, q, sexpr.name]
+      end
     end
 
     def on_native(sexpr)

data/lib/predicate/processors/to_ruby_code.rb

@@ -49,6 +49,10 @@ class Predicate
       "#{to_ruby_literal(sexpr.values)}.include?(#{apply(sexpr.identifier)})"
     end
 
+    def on_intersect(sexpr)
+      "!(#{apply(sexpr.identifier)} & #{to_ruby_literal(sexpr.values)}).empty?"
+    end
+
     def on_literal(sexpr)
       to_ruby_literal(sexpr.last)
     end

data/lib/predicate/sequel/to_sequel.rb

@@ -6,7 +6,7 @@ class Predicate
     end
 
     def on_qualified_identifier(sexpr)
-      ::Sequel.as(sexpr.qualifier, sexpr.name)
+      ::Sequel.identifier(sexpr.name).qualify(sexpr.qualifier)
     end
 
     def on_literal(sexpr)
@@ -44,6 +44,7 @@ class Predicate
 
     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
 
@@ -61,9 +62,11 @@ class Predicate
       body[1..-1].inject(apply(body.first)){|f,t| f | apply(t) }
     end
 
-    def on_native(sexpr)
+    def on_unsupported(sexpr)
       raise NotSupportedError
     end
+    alias :on_native :on_unsupported
+    alias :on_intersect :on_unsupported
 
   end # class ToSequel
 end # class Predicate

data/lib/predicate/version.rb

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

data/lib/predicate.rb

@@ -95,6 +95,20 @@ class Predicate
     expr.and_split(attr_list).map{|e| Predicate.new(e)}
   end
 
+  # Returns a hash `(attr -> Pattr)` associating attribute names
+  # to predicates, so that each predicate `Pattr` only makes
+  # reference to the corresponding attribute name `attr`, while
+  # the conjunction of `Pattr`s is still equivalent to the
+  # original predicate.
+  #
+  # A `nil` key may map a predicate that still makes references
+  # to more than one attribute.
+  def attr_split
+    expr.attr_split.each_pair.each_with_object({}) do |(k,v),h|
+      h[k] = Predicate.new(v)
+    end
+  end
+
   def ==(other)
     other.is_a?(Predicate) && (other.expr==expr)
   end

data/spec/factory/test_intersect.rb

@@ -0,0 +1,12 @@
+require_relative "shared/a_comparison_factory_method"
+class Predicate
+  describe Factory, 'intersect' do
+
+    subject{ Factory.intersect(:x, [2, 3]) }
+
+    it{ should be_a(Intersect) }
+
+    it{ should eq([:intersect, [:identifier, :x], [2, 3]]) }
+
+  end
+end

data/spec/grammar/test_sexpr.rb

@@ -7,10 +7,15 @@ class Predicate
     let(:contradiction){
       [:contradiction, false]
     }
+
     let(:identifier){
       [:identifier, :name]
     }
 
+    let(:values){
+      [12, 15]
+    }
+
     before do
       subject.should be_a(Sexpr)
     end
@@ -87,6 +92,18 @@ class Predicate
       it{ should be_a(Lte) }
     end
 
+    describe "in" do
+      let(:expr){ [:in, identifier, values] }
+
+      it{ should be_a(In) }
+    end
+
+    describe "intersect" do
+      let(:expr){ [:intersect, identifier, values] }
+
+      it{ should be_a(Intersect) }
+    end
+
     describe "literal" do
       let(:expr){ [:literal, 12] }
 

data/spec/nodes/and/test_attr_split.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+class Predicate
+  describe And, "attr_split" do
+
+    let(:tautology){ Factory.tautology  }
+
+    subject{ predicate.attr_split }
+
+    context 'when each side returns a singleton hash' do
+      let(:predicate){ Factory.eq(:x, 2) & Factory.eq(:y, 3) }
+
+      it 'returns the hash union' do
+        expect(subject).to eql({
+          :x => Factory.eq(:x, 2),
+          :y => Factory.eq(:y, 3)
+        })
+      end
+    end
+
+    context 'when right and left side share some attributes' do
+      let(:predicate){
+        Factory.eq(:x, 2) & (
+          Factory.eq(:y, 3) & Factory.in(:x, [1, 18])
+        )
+      }
+
+      it 'returns the hash union' do
+        expect(subject).to eql({
+          :x => Factory.eq(:x, 2) & Factory.in(:x, [1, 18]),
+          :y => Factory.eq(:y, 3)
+        })
+      end
+    end
+
+    context 'when right and left side share some attributes, but split cannot be made' do
+      let(:predicate){
+        Factory.eq(:x, 2) & (
+          Factory.eq(:y, 3) | Factory.in(:x, [1, 18])
+        )
+      }
+
+      it 'returns the hash union' do
+        expect(subject).to eql({
+          :x  => Factory.eq(:x, 2),
+          nil => Factory.eq(:y, 3) | Factory.in(:x, [1, 18])
+        })
+      end
+    end
+  end
+end

data/spec/predicate/test_attr_split.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+class Predicate
+  describe Predicate, "attr_split" do
+
+    let(:p){ Predicate }
+    subject{ pred.attr_split }
+
+    context "on tautology" do
+      let(:pred){ p.tautology }
+
+      it{ should eq({}) }
+    end
+
+    context "on contradiction" do
+      let(:pred){ p.contradiction }
+
+      it{ should eq({ nil => pred }) }
+    end
+
+    context "on identifier" do
+      let(:pred){ p.identifier(:x) }
+
+      it{ should eq({ x: pred }) }
+    end
+
+    context "on not" do
+      let(:pred){ p.not(:x) }
+
+      it{ should eq({ x: pred }) }
+    end
+
+    context "on eq" do
+      let(:pred){ p.eq(:x, 2) }
+
+      it{ should eq({ x: pred }) }
+    end
+
+  end
+end

data/spec/predicate/test_factory_methods.rb

@@ -73,5 +73,11 @@ class Predicate
       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] & [7, 8]).empty? }") }
+    end
+
   end
 end

data/spec/predicate/test_qualify.rb

@@ -6,27 +6,41 @@ class Predicate
 
     subject{ predicate.qualify(qualifier) }
 
-    let(:qualifier) { {:x => :t} }
+    context 'when the qualifier is a Symbol' do
+      let(:qualifier) { :t }
+      let(:predicate){ p.in(:x, [2]) & p.eq(:y, :z) }
+
+      it 'works as expected' do
+        left = p.in(Factory.qualified_identifier(:t, :x), [2])
+        right = p.eq(Factory.qualified_identifier(:t, :y), Factory.qualified_identifier(:t, :z))
+        expect(subject).to eql(left & right)
+      end
+    end
+
+    context 'when the qualifier is a Hash' do
 
-    context 'on a full AST predicate' do
-      let(:predicate){ p.in(:x, [2]) & p.eq(:y, 3) }
+      let(:qualifier) { {:x => :t} }
 
-      it{ should eq(p.in(Factory.qualified_identifier(:t, :x), [2]) & p.eq(:y, 3)) }
+      context 'on a full AST predicate' do
+        let(:predicate){ p.in(: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)
+        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
-    end
 
-    context 'on a predicate that contains natives' do
-      let(:predicate){ p.in(:x, [2]) & p.native(lambda{}) }
+      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)
+        it 'raises an error' do
+          lambda{
+            subject
+          }.should raise_error(NotSupportedError)
+        end
       end
     end
 

data/spec/sequel/test_to_sequel.rb

@@ -45,6 +45,14 @@ class Predicate
       end
     end
 
+    context 'qualified eq(name: "bob")' do
+      let(:predicate) { Predicate.eq(:name, "Bob").qualify(:t) }
+
+      it 'works as expected' do
+        expect(subject).to eql("SELECT * FROM `items` WHERE (`t`.`name` = 'Bob')")
+      end
+    end
+
     context 'eq(name: :address)' do
       let(:predicate) { Predicate.eq(:name, :address) }
 
@@ -77,6 +85,21 @@ class Predicate
       end
     end
 
+    context 'in with something responding to sql_literal' do
+      let(:operand){
+        Object.new.tap{|o|
+          def o.sql_literal(db)
+            "Hello World"
+          end
+        }
+      }
+      let(:predicate) { Predicate.in(:price, operand) }
+
+      it 'works as expected' do
+        expect(subject).to eql("SELECT * FROM `items` WHERE (`price` IN (Hello World))")
+      end
+    end
+
     context 'not' do
       let(:predicate) { !Predicate.in(:price, [10.0, 17.99]) }
 
@@ -109,6 +132,14 @@ class Predicate
       end
     end
 
+    context 'intersect' do
+      let(:predicate) { Predicate.intersect(:x, [8, 9]) }
+
+      it 'raises an error' do
+        expect { subject }.to raise_error(NotSupportedError)
+      end
+    end
+
     context 'native' do
       let(:predicate) { Predicate.native(->(t){ false }) }
 

data/spec/test_predicate.rb

@@ -2,11 +2,12 @@ require 'spec_helper'
 
 shared_examples_for "a predicate" do
 
+  let(:w){ [8, 9] }
   let(:x){ 12 }
   let(:y){ 13 }
 
   it 'provides a proc for easy evaluation' do
-    got = subject.to_proc.call(x: 12, y: 13)
+    got = subject.to_proc.call(w: w, x: x, y: y)
     [ TrueClass, FalseClass ].should include(got.class)
   end
 
@@ -24,7 +25,7 @@ shared_examples_for "a predicate" do
 
   it 'has free variables' do
     (fv = subject.free_variables).should be_a(Array)
-    (fv - [ :x, :y ]).should be_empty
+    (fv - [ :w, :x, :y ]).should be_empty
   end
 
   it 'always splits around and trivially when no free variables are touched' do
@@ -65,6 +66,12 @@ describe "Predicate.among" do
   it_should_behave_like "a predicate"
 end
 
+describe "Predicate.intersect" do
+  subject{ Predicate.intersect(:w, [2, 3]) }
+
+  it_should_behave_like "a predicate"
+end
+
 describe "Predicate.eq" do
   subject{ Predicate.eq(:x, 2) }
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: predicate
 version: !ruby/object:Gem::Version
-  version: 1.1.3
+  version: 1.2.0
 platform: ruby
 authors:
 - Bernard Lambeau
@@ -103,6 +103,7 @@ files:
 - lib/predicate/nodes/gte.rb
 - lib/predicate/nodes/identifier.rb
 - lib/predicate/nodes/in.rb
+- lib/predicate/nodes/intersect.rb
 - lib/predicate/nodes/literal.rb
 - lib/predicate/nodes/lt.rb
 - lib/predicate/nodes/lte.rb
@@ -135,6 +136,7 @@ files:
 - spec/factory/test_gte.rb
 - spec/factory/test_identifier.rb
 - spec/factory/test_in.rb
+- spec/factory/test_intersect.rb
 - spec/factory/test_literal.rb
 - spec/factory/test_lt.rb
 - spec/factory/test_lte.rb
@@ -147,6 +149,7 @@ files:
 - spec/grammar/test_match.rb
 - spec/grammar/test_sexpr.rb
 - spec/nodes/and/test_and_split.rb
+- spec/nodes/and/test_attr_split.rb
 - spec/nodes/dyadic_comp/test_and_split.rb
 - spec/nodes/identifier/test_and_split.rb
 - spec/nodes/identifier/test_free_variables.rb
@@ -158,6 +161,7 @@ files:
 - spec/nodes/qualified_identifier/test_name.rb
 - spec/nodes/qualified_identifier/test_qualifier.rb
 - spec/predicate/test_and_split.rb
+- spec/predicate/test_attr_split.rb
 - spec/predicate/test_bool_and.rb
 - spec/predicate/test_bool_not.rb
 - spec/predicate/test_bool_or.rb