predicate 2.3.2 → 2.6.0

data/lib/predicate/nodes/qualified_identifier.rb

@@ -2,9 +2,7 @@ class Predicate
   module QualifiedIdentifier
     include Expr
 
-    def priority
-      100
-    end
+    def priority; 100; end
 
     def qualifier
       self[1]

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/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/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/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,8 +1,8 @@
 class Predicate
   module Version
     MAJOR = 2
-    MINOR = 3
-    TINY  = 2
+    MINOR = 6
+    TINY  = 0
   end
   VERSION = "#{Version::MAJOR}.#{Version::MINOR}.#{Version::TINY}"
 end

data/lib/predicate.rb

@@ -2,12 +2,16 @@ require 'sexpr'
 require_relative 'predicate/version'
 require_relative 'predicate/placeholder'
 require_relative 'predicate/factory'
+require_relative 'predicate/sugar'
 require_relative 'predicate/grammar'
 require_relative 'predicate/processors'
+require_relative 'predicate/dsl'
 class Predicate
 
-  class NotSupportedError < StandardError; end
-  class UnboundError < StandardError; end
+  class Error < StandardError; end
+  class NotSupportedError < Error; end
+  class UnboundError < Error; end
+  class TypeError < Error; end
 
   TupleLike = ->(t){ t.is_a?(Hash) }
 
@@ -21,6 +25,7 @@ class Predicate
 
   class << self
     include Factory
+    include Sugar
 
     def coerce(arg)
       case arg
@@ -36,6 +41,14 @@ class Predicate
     end
     alias :parse :coerce
 
+    def dsl(var = var(".", :dig), &bl)
+      Predicate::Dsl.new(var, false).instance_eval(&bl)
+    end
+
+    def currying(var = var(".", :dig), &bl)
+      Predicate::Dsl.new(var, true).instance_eval(&bl)
+    end
+
   private
 
     def _factor_predicate(arg)
@@ -88,6 +101,10 @@ class Predicate
     Predicate.new(expr.qualify(qualifier))
   end
 
+  def unqualify
+    Predicate.new(expr.unqualify)
+  end
+
   def rename(renaming)
     Predicate.new(expr.rename(renaming))
   end
@@ -138,4 +155,11 @@ class Predicate
     expr.to_s(scope)
   end
 
+  # If possible, converts this predicate back to a `{ attr: value, ... }`
+  # hash. Raises an IllegalArgumentError if the predicate cannot be
+  # represented that way.
+  def to_hash
+    expr.to_hash
+  end
+
 end # class Predicate

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

data/spec/dsl/test_evaluate.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe 'Predicate in a curried form' do
+
+  context 'with a variable name' do
+    it 'supports tautology, contradiction' do
+      p = Predicate.currying(:x){ tautology }
+      expect(p).to eql(Predicate.tautology)
+
+      p = Predicate.currying(:x){ contradiction }
+      expect(p).to eql(Predicate.contradiction)
+    end
+
+    it 'support comparison operators' do
+      p = Predicate.currying(:x){
+        gt(0) & lt(12)
+      }
+      expect(p.evaluate(x: 0)).to be_falsy
+      expect(p.evaluate(x: 1)).to be_truthy
+      expect(p.evaluate(x: 11)).to be_truthy
+      expect(p.evaluate(x: 12)).to be_falsy
+    end
+
+    it 'supports between shortcut' do
+      p = Predicate.currying(:x){
+        between(1, 11)
+      }
+      expect(p.evaluate(x: 0)).to be_falsy
+      expect(p.evaluate(x: 1)).to be_truthy
+      expect(p.evaluate(x: 11)).to be_truthy
+      expect(p.evaluate(x: 12)).to be_falsy
+    end
+
+    it 'supports match' do
+      p = Predicate.currying(:x){
+        match(/a/)
+      }
+      expect(p.evaluate(x: "zzz")).to be_falsy
+      expect(p.evaluate(x: "abc")).to be_truthy
+    end
+  end
+
+  context 'without a variable name' do
+    it 'applies to the object passed' do
+      p = Predicate.currying{
+        gt(0) & lt(12)
+      }
+      expect(p.evaluate(0)).to be_falsy
+      expect(p.evaluate(1)).to be_truthy
+      expect(p.evaluate(11)).to be_truthy
+      expect(p.evaluate(12)).to be_falsy
+    end
+  end
+
+  context 'on shortcuts' do
+    it 'applies to the object passed' do
+      p = Predicate.currying{
+        min_size(5)
+      }
+      expect(p.evaluate("1")).to be_falsy
+      expect(p.evaluate("013456789")).to be_truthy
+    end
+  end
+
+end

data/spec/dsl/test_respond_to_missing.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+class Predicate
+  describe Dsl do
+    subject{
+      Predicate::Dsl.new(:x)
+    }
+
+    it 'respond to negated forms' do
+      [
+        :notSize,
+        :notEq
+      ].each do |m|
+        expect(subject.send(:respond_to_missing?, m)).to eql(true)
+      end
+    end
+
+    it 'respond to camelCased forms' do
+      [
+        :hasSize
+      ].each do |m|
+        expect(subject.send(:respond_to_missing?, m)).to eql(true)
+      end
+    end
+
+    it 'respond false otherwise' do
+      [
+        :nosuchone,
+        :notsuchone
+      ].each do |m|
+        expect(subject.send(:respond_to_missing?, m)).to eql(false)
+      end
+    end
+  end
+end