predicate 2.3.3 → 2.7.0

data/lib/predicate/nodes/opaque.rb

@@ -2,9 +2,7 @@ class Predicate
   module Opaque
     include Expr
 
-    def priority
-      100
-    end
+    def priority; 100; end
 
     def free_variables
       @free_variables ||= []

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/postgres/ext/factory.rb

@@ -0,0 +1,28 @@
+class Predicate
+  module Factory
+    def pg_array_literal(value, type = :varchar)
+      _factor_predicate([
+        :pg_array_literal,
+        value,
+        type
+      ], Postgres::PgArray::Literal)
+    end
+
+    def pg_array_overlaps(left, right, type = :varchar)
+      _factor_predicate([
+        :pg_array_overlaps,
+        sexpr(left),
+        sexpr(right),
+        type
+      ], Postgres::PgArray::Overlaps)
+    end
+
+    def pg_array_empty(operand, type = :varchar)
+      _factor_predicate([
+        :pg_empty,
+        sexpr(operand),
+        type
+      ], Postgres::PgArray::Empty)
+    end
+  end
+end

data/lib/predicate/postgres/ext/to_sequel.rb

@@ -0,0 +1,26 @@
+class Predicate
+  module Postgres
+    module ToSequel
+      def on_pg_array_literal(sexpr)
+        PgArray.to_pg_array(sexpr[1], sexpr[2])
+      end
+
+      def on_pg_array_overlaps(sexpr)
+        type = sexpr.last
+        l = PgArray.to_pg_array(apply(sexpr.left), type)
+        r = PgArray.to_pg_array(apply(sexpr.right), type)
+        l.overlaps(r)
+      end
+
+      def on_pg_array_empty(sexpr)
+        left = PgArray.to_pg_array(apply(sexpr.operand))
+        right = PgArray.to_pg_array([], sexpr.last)
+        ::Sequel.expr(left => right)
+      end
+    end
+  end
+end
+
+class Predicate::ToSequel
+  include Predicate::Postgres::ToSequel
+end

data/lib/predicate/postgres/ext.rb

@@ -0,0 +1,2 @@
+require_relative 'ext/factory'
+require_relative 'ext/to_sequel'

data/lib/predicate/postgres/pg_array/empty.rb

@@ -0,0 +1,10 @@
+class Predicate
+  module Postgres
+    module PgArray
+      module Empty
+        include Predicate::UnaryFunc
+
+      end # module Empty
+    end # module PgArray
+  end # module Postgres
+end # class Predicate

data/lib/predicate/postgres/pg_array/literal.rb

@@ -0,0 +1,10 @@
+class Predicate
+  module Postgres
+    module PgArray
+      module Literal
+        include Predicate::Literal
+
+      end # module Literal
+    end # module PgArray
+  end # module Postgres
+end # class Predicate

data/lib/predicate/postgres/pg_array/overlaps.rb

@@ -0,0 +1,10 @@
+class Predicate
+  module Postgres
+    module PgArray
+      module Overlaps
+        include Predicate::BinaryFunc
+
+      end # module Overlaps
+    end # module PgArray
+  end # module Postgres
+end # class Predicate

data/lib/predicate/postgres/pg_array.rb

@@ -0,0 +1,25 @@
+class Predicate
+  module Postgres
+    module PgArray
+
+      def to_pg_array(arg, type = :varchar)
+        if arg.is_a?(Sequel::Postgres::PGArray)
+          arg
+        elsif arg.is_a?(Sequel::SQL::Wrapper)
+          ::Sequel.pg_array(arg.value, type)
+        elsif arg.is_a?(Array)
+          ::Sequel.pg_array(arg, type)
+        elsif arg.respond_to?(:pg_array)
+          arg.pg_array
+        else
+          raise NotSupportedError, "Unexpected pg_array arg `#{arg}`::`#{arg.class}`"
+        end
+      end
+      module_function :to_pg_array
+
+    end # module PgArray
+  end # module Postgres
+end # class Predicate
+require_relative 'pg_array/empty'
+require_relative 'pg_array/overlaps'
+require_relative 'pg_array/literal'

data/lib/predicate/postgres/rewriter.rb

@@ -0,0 +1,49 @@
+class Predicate
+  module Postgres
+    class Rewriter < Sexpr::Rewriter
+      grammar Grammar
+
+      class ToLiteral < Sexpr::Rewriter
+        grammar Grammar
+
+        def on_literal(sexpr)
+          if sexpr.last.is_a?(Array)
+            [ :pg_array_literal, sexpr.last, :varchar ]
+          else
+            sexpr
+          end
+        end
+
+        alias :on_missing :copy_and_apply
+      end
+
+      def on_intersect(sexpr)
+        rewriter = ToLiteral.new
+        rewritten = sexpr[1..-1]
+          .map{|expr| rewriter.call(expr) }
+          .unshift(:pg_array_overlaps)
+        rewritten.extend(PgArray::Overlaps)
+      end
+
+      def on_empty(sexpr)
+        rewritten = sexpr[1..-1]
+          .map{|expr| apply(expr) }
+          .unshift(:pg_array_empty)
+          .push(:varchar)
+        rewritten.extend(PgArray::Empty)
+      end
+
+      alias :on_missing :copy_and_apply
+    end
+  end
+
+  module Expr
+    def to_postgres(*args)
+      Postgres::Rewriter.new(*args).call(self)
+    end
+  end
+
+  def to_postgres(*args)
+    Predicate.new(expr.to_postgres(*args))
+  end
+end

data/lib/predicate/postgres.rb

@@ -0,0 +1,4 @@
+require_relative 'sequel'
+require_relative 'postgres/pg_array'
+require_relative 'postgres/rewriter'
+require_relative 'postgres/ext'

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

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

data/lib/predicate/sequel/to_sequel.rb

@@ -106,14 +106,18 @@ class Predicate
 
       def on_opaque(sexpr)
         return [sexpr.last] if sexpr.last.respond_to?(:sql_literal)
+        return [sexpr.last] if sexpr.last.respond_to?(:sql)
         raise Error, "Unable to compile #{sexpr} to Sequel"
       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  = 3
+    MINOR = 7
+    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,10 +41,22 @@ 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)
-      Predicate.new Grammar.sexpr(arg)
+    def _factor_predicate(arg, *mods)
+      expr = Grammar.sexpr(arg)
+      mods.each do |mod|
+        expr.extend(mod)
+      end
+      Predicate.new(expr)
     end
 
   end
@@ -142,4 +159,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