predicate 2.3.0 → 2.5.0

data/lib/predicate/nodes/set_op.rb

@@ -0,0 +1,26 @@
+class Predicate
+  module SetOp
+    include Expr
+
+    def priority; 80; end
+
+    def left
+      self[1]
+    end
+    alias :identifier :left
+
+    def right
+      self[2]
+    end
+    alias :values :right
+
+    def free_variables
+      @free_variables ||= left.free_variables | right.free_variables
+    end
+
+    def constant_variables
+      []
+    end
+
+  end
+end

data/lib/predicate/nodes/subset.rb

@@ -0,0 +1,11 @@
+class Predicate
+  module Subset
+    include SetOp
+
+    def evaluate(tuple)
+      x, y = left.evaluate(tuple), right.evaluate(tuple)
+      x && y && (x & y == x)
+    end
+
+  end
+end

data/lib/predicate/nodes/superset.rb

@@ -0,0 +1,11 @@
+class Predicate
+  module Superset
+    include SetOp
+
+    def evaluate(tuple)
+      x, y = left.evaluate(tuple), right.evaluate(tuple)
+      x && y && (x & y == y)
+    end
+
+  end
+end

data/lib/predicate/nodes/tautology.rb

@@ -18,13 +18,8 @@ class Predicate
       self
     end
 
-    def dyadic_priority
-      1000
-    end
-
-    def priority
-      100
-    end
+    def dyadic_priority; 1000; end
+    def priority; 100; end
 
     def free_variables
       @free_variables ||= []
@@ -38,5 +33,9 @@ class Predicate
       true
     end
 
+    def to_hash
+      {}
+    end
+
   end
 end

data/lib/predicate/nodes/unary_func.rb

@@ -0,0 +1,16 @@
+class Predicate
+  module UnaryFunc
+    include Expr
+
+    def priority; 80; end
+
+    def operand
+      self[1]
+    end
+
+    def free_variables
+      @free_variables ||= operand.free_variables
+    end
+
+  end
+end

data/lib/predicate/nodes/var.rb

@@ -0,0 +1,46 @@
+class Predicate
+  module Var
+    include Expr
+
+    def priority; 100; end
+
+    def formaldef
+      self[1]
+    end
+
+    def semantics
+      self[2]
+    end
+
+    def free_variables
+      @free_variables ||= [ [formaldef, semantics] ]
+    end
+
+    def dig_terms
+      @dig_terms ||= case formaldef
+      when String
+        formaldef.split(".").map{|elm|
+          elm =~ /^\d+$/ ? elm.to_i : elm.to_sym
+        }
+      when Array
+        formaldef
+      else
+        raise ArgumentError, "Unrecognized variable def `#{formaldef}`"
+      end
+    end
+
+    def evaluate(on)
+      case semantics
+      when :dig
+        dig_terms.inject(on){|ctx,elm| ctx.dig(elm) }
+      when :send
+        dig_terms.inject(on){|ctx,elm| ctx.__send__(elm.to_sym) }
+      when :public_send
+        dig_terms.inject(on){|ctx,elm| ctx.public_send(elm.to_sym) }
+      else
+        raise ArgumentError, "Unrecognized variable semantics `#{semantics}`"
+      end
+    end
+
+  end
+end

data/lib/predicate/processors.rb

@@ -1,4 +1,5 @@
 require_relative "processors/to_s"
 require_relative "processors/renamer"
 require_relative "processors/qualifier"
+require_relative "processors/unqualifier"
 require_relative "processors/binder"

data/lib/predicate/processors/qualifier.rb

@@ -22,6 +22,10 @@ class Predicate
       raise NotSupportedError
     end
 
+    def on_var(sexpr)
+      raise NotSupportedError
+    end
+
     alias :on_missing :copy_and_apply
 
   end

data/lib/predicate/processors/renamer.rb

@@ -19,6 +19,10 @@ class Predicate
       raise NotSupportedError
     end
 
+    def on_var(sexpr)
+      raise NotSupportedError
+    end
+
     alias :on_missing :copy_and_apply
 
   end

data/lib/predicate/processors/to_s.rb

@@ -57,6 +57,14 @@ class Predicate
       "#{apply(sexpr.identifier)} INTERSECTS #{to_literal(sexpr.values)}"
     end
 
+    def on_subset(sexpr)
+      "#{apply(sexpr.identifier)} IS SUBSET OF #{to_literal(sexpr.values)}"
+    end
+
+    def on_superset(sexpr)
+      "#{apply(sexpr.identifier)} IS SUPERSET OF #{to_literal(sexpr.values)}"
+    end
+
     def on_literal(sexpr)
       to_literal(sexpr.last)
     end
@@ -69,16 +77,36 @@ class Predicate
       "#{apply(sexpr.left)} =~ #{apply(sexpr.right)}"
     end
 
+    def on_empty(sexpr)
+      "EMPTY(#{commalist(sexpr.body)})"
+    end
+
+    def on_size(sexpr)
+      "SIZE(#{commalist(sexpr.body)})"
+    end
+
+    #jeny(predicate) def on_${op_name}(sexpr)
+    #jeny(predicate)   "${OP_NAME}(#{commalist(sexpr.body)})"
+    #jeny(predicate) end
+
     def on_native(sexpr)
       sexpr.last.inspect
     end
 
+    def on_var(sexpr)
+      "#{sexpr.semantics}(#{sexpr.formaldef})"
+    end
+
     def on_missing(sexpr)
       raise "Unimplemented: #{sexpr.first}"
     end
 
   protected
 
+    def commalist(of)
+      of.map{|o| apply(o) }.join(',')
+    end
+
     def to_literal(x)
       case x
       when Placeholder then "$#{x.object_id}"

data/lib/predicate/processors/unqualifier.rb

@@ -0,0 +1,21 @@
+class Predicate
+  class Unqualifier < Sexpr::Rewriter
+
+    grammar Grammar
+
+    def on_qualified_identifier(sexpr)
+      [ :identifier, sexpr.last ]
+    end
+
+    def on_native(sexpr)
+      raise NotSupportedError
+    end
+
+    def on_var(sexpr)
+      raise NotSupportedError
+    end
+
+    alias :on_missing :copy_and_apply
+
+  end
+end

data/lib/predicate/sequel/to_sequel.rb

@@ -110,10 +110,13 @@ class Predicate
       end
 
       def on_unsupported(sexpr)
-        raise NotSupportedError
+        raise NotSupportedError, "Unsupported predicate #{sexpr}"
       end
+      alias :on_var :on_unsupported
       alias :on_native :on_unsupported
       alias :on_intersect :on_unsupported
+      alias :on_subset :on_unsupported
+      alias :on_superset :on_unsupported
     end
     include Methods
   end # class ToSequel

data/lib/predicate/sugar.rb

@@ -0,0 +1,47 @@
+class Predicate
+  module Sugar
+
+    [ :eq, :neq, :lt, :lte, :gt, :gte ].each do |m|
+      define_method(m) do |left, right=nil|
+        return comp(m, left) if TupleLike===left && right.nil?
+        super(left, right)
+      end
+    end
+
+    def between(middle, lower_bound, upper_bound)
+      _factor_predicate [:and, [:gte, sexpr(middle), sexpr(lower_bound)],
+                               [:lte, sexpr(middle), sexpr(upper_bound)]]
+    end
+
+    def match(left, right, options = nil)
+      super(left, right, options)
+    end
+
+    def min_size(left, right)
+      unless right.is_a?(Integer)
+        raise ArgumentError, "Integer expected, got #{right}"
+      end
+      if RUBY_VERSION >= "2.6"
+        has_size(left, Range.new(right,nil))
+      else
+        has_size(left, Range.new(right,(2**32-1)))
+      end
+    end
+
+    def max_size(left, right)
+      unless right.is_a?(Integer)
+        raise ArgumentError, "Integer expected, got #{right}"
+      end
+      has_size(left, 0..right)
+    end
+
+    def is_null(operand)
+      eq(operand, nil)
+    end
+
+    #jeny(sugar) def ${op_name}(*args)
+    #jeny(sugar)   TODO
+    #jeny(sugar) end
+
+  end # module Sugar
+end # class Predicate

data/lib/predicate/version.rb

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

data/spec/dsl/test_dsl.rb

@@ -0,0 +1,204 @@
+require 'spec_helper'
+
+class Predicate
+  describe Dsl do
+    subject{
+      Predicate::Dsl.new(:x).instance_eval(&bl)
+    }
+
+    context 'when used on a comparison op' do
+      context 'curried' do
+        let(:bl){
+          Proc.new{ eq(6) }
+        }
+
+        it { expect(subject).to eq(Predicate.eq(:x, 6))}
+      end
+
+      context 'non curried' do
+        let(:bl){
+          Proc.new{ eq(:y, 6) }
+        }
+
+        it { expect(subject).to eq(Predicate.eq(:y, 6))}
+      end
+    end
+
+    context 'when used on between' do
+      context 'curried' do
+        let(:bl){
+          Proc.new{ between(2, 6) }
+        }
+
+        it { expect(subject).to eq(Predicate.gte(:x, 2) & Predicate.lte(:x, 6))}
+      end
+
+      context 'non curried' do
+        let(:bl){
+          Proc.new{ between(:y, 2, 6) }
+        }
+
+        it { expect(subject).to eq(Predicate.gte(:y, 2) & Predicate.lte(:y, 6))}
+      end
+    end
+
+    context 'when used on a sugar op' do
+      context 'curried' do
+        let(:bl){
+          Proc.new{ min_size(6) }
+        }
+
+        it { expect(subject).to eq(Predicate.has_size(:x, Range.new(6, nil)))}
+      end
+
+      context 'curried' do
+        let(:bl){
+          Proc.new{ min_size(:y, 6) }
+        }
+
+        it { expect(subject).to eq(Predicate.has_size(:y, Range.new(6, nil)))}
+      end
+    end if RUBY_VERSION >= "2.6"
+
+    context 'when used on match' do
+      context 'curryied' do
+        let(:bl){
+          Proc.new{ match(/a-z/) }
+        }
+
+        it { expect(subject).to eq(Predicate.match(:x, /a-z/, {}))}
+      end
+
+      context 'curryied with options' do
+        let(:bl){
+          Proc.new{ match(/a-z/, {case_sensitive: false}) }
+        }
+
+        it { expect(subject).to eq(Predicate.match(:x, /a-z/, {case_sensitive: false}))}
+      end
+
+      context 'non curried' do
+        let(:bl){
+          Proc.new{ match(:y, /a-z/) }
+        }
+
+        it { expect(subject).to eq(Predicate.match(:y, /a-z/, {}))}
+      end
+
+      context 'non curried with options' do
+        let(:bl){
+          Proc.new{ match(:y, /a-z/, {case_sensitive: false}) }
+        }
+
+        it { expect(subject).to eq(Predicate.match(:y, /a-z/, {case_sensitive: false}))}
+      end
+    end
+
+    context 'when used on size' do
+      context 'curried' do
+        let(:bl){
+          Proc.new{ size(1..10) }
+        }
+
+        it { expect(subject).to eq(Predicate.has_size(:x, 1..10))}
+      end
+
+      context 'curried with Integer' do
+        let(:bl){
+          Proc.new{ size(10) }
+        }
+
+        it { expect(subject).to eq(Predicate.has_size(:x, 10))}
+      end
+
+      context 'not curried' do
+        let(:bl){
+          Proc.new{ size(:y, 1..10) }
+        }
+
+        it { expect(subject).to eq(Predicate.has_size(:y, 1..10))}
+      end
+
+      context 'not curried with Integer' do
+        let(:bl){
+          Proc.new{ size(:y, 10) }
+        }
+
+        it { expect(subject).to eq(Predicate.has_size(:y, 10))}
+      end
+    end
+
+    context 'when used with some camelCase' do
+      context 'curried' do
+        let(:bl){
+          Proc.new{ hasSize(1..10) }
+        }
+
+        it { expect(subject).to eq(Predicate.has_size(:x, 1..10))}
+      end
+    end
+
+    context 'when used with full text versions and their negation' do
+      context 'less_than' do
+        let(:bl){
+          Proc.new{ less_than(:x, 1) }
+        }
+
+        it { expect(subject).to eq(Predicate.lt(:x, 1))}
+      end
+
+      context 'lessThan' do
+        let(:bl){
+          Proc.new{ lessThan(:x, 1) }
+        }
+
+        it { expect(subject).to eq(Predicate.lt(:x, 1))}
+      end
+
+      context 'notLessThan' do
+        let(:bl){
+          Proc.new{ notLessThan(:x, 1) }
+        }
+
+        it { expect(subject).to eq(!Predicate.lt(:x, 1))}
+      end
+    end
+
+    context 'when used with a negated form' do
+      context 'curried' do
+        let(:bl){
+          Proc.new{ notSize(1..10) }
+        }
+
+        it { expect(subject).to eq(!Predicate.has_size(:x, 1..10))}
+      end
+    end
+
+    context 'when used on null' do
+      context 'curried' do
+        let(:bl){
+          Proc.new{ null() }
+        }
+
+        it { expect(subject).to eq(Predicate.eq(:x, nil))}
+      end
+
+      context 'negated' do
+        let(:bl){
+          Proc.new{ notNull() }
+        }
+
+        it { expect(subject).to eq(Predicate.neq(:x, nil))}
+      end
+
+      context 'not curried' do
+        let(:bl){
+          Proc.new{ null(:y) }
+        }
+
+        it { expect(subject).to eq(Predicate.eq(:y, nil))}
+      end
+    end
+
+  end
+end