predicate 2.3.0 → 2.5.0

data/bin/g

@@ -0,0 +1,2 @@
+#!/bin/sh
+jeny -d name:$1 s .

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/lib/predicate/dsl.rb

@@ -0,0 +1,138 @@
+class Predicate
+  class Dsl
+
+    def initialize(var = nil, allow_currying = true)
+      @var = var || ::Predicate.var(".", :dig)
+      @allow_currying = allow_currying
+    end
+
+  public # No injection
+
+    [
+      :tautology,
+      :contradiction,
+      :literal,
+      :var,
+      :vars,
+      :identifier,
+      :qualified_identifier,
+      :placeholder
+    ].each do |name|
+      define_method(name) do |*args|
+        ::Predicate.send(name)
+      end
+    end
+
+  public # All normal
+
+    [
+      :in,
+      :intersect,
+      :subset,
+      :superset,
+      #
+      :eq,
+      :neq,
+      :lt,
+      :lte,
+      :gt,
+      :gte,
+      #
+      :empty,
+      :has_size,
+      #jeny(predicate) :${op_name},
+    ].each do |name|
+      define_method(name) do |*args|
+        args = apply_curry(name, args, Factory)
+        ::Predicate.send(name, *args)
+      end
+    end
+
+  public # Operators with options as last arg
+
+    [
+      :match
+    ].each do |name|
+      define_method(name) do |*args|
+        args << {} unless args.last.is_a?(::Hash)
+        args = apply_curry(name, args, ::Predicate::Factory)
+        ::Predicate.send(name, *args)
+      end
+    end
+
+  public # Sugar operators
+
+    [
+      :between,
+      :min_size,
+      :max_size,
+      :is_null,
+      #jeny(sugar) :${op_name},
+    ].each do |name|
+      define_method(name) do |*args|
+        args = apply_curry(name, args, ::Predicate::Sugar)
+        ::Predicate.send(name, *args)
+      end
+    end
+
+  public # Extra names
+
+    {
+      :null => :is_null,
+      :size => :has_size,
+      :equal => :eq,
+      :less_than => :lt,
+      :less_than_or_equal => :lte,
+      :greater_than => :gt,
+      :greater_than_or_equal => :gte
+    }.each_pair do |k,v|
+      define_method(k) do |*args|
+        __send__(v, *args)
+      end
+    end
+
+  public
+
+    def method_missing(n, *args, &bl)
+      snaked, to_negate = missing_method_pair(n)
+      if snaked == n.to_s && !to_negate
+        super
+      elsif self.respond_to?(snaked)
+        got = __send__(snaked.to_sym, *args, &bl)
+        to_negate ? !got : got
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(n, include_private = false)
+      snaked, to_negate = missing_method_pair(n)
+      return super if snaked == n.to_s
+      self.respond_to?(snaked)
+    end
+
+  private
+
+    def missing_method_pair(n)
+      name, to_negate = n.to_s, false
+      if name.to_s[0..2] == "not"
+        name, to_negate = name[3..-1], true
+      end
+      [to_snake_case(name), to_negate]
+    end
+
+    def to_snake_case(str)
+      str.gsub(/[A-Z]/){|x| "_#{x.downcase}" }.gsub(/^_/, "")
+    end
+
+    def apply_curry(name, args, on)
+      m = on.instance_method(name)
+      if @allow_currying and m.arity == 1+args.length
+        [@var] + args
+      else
+        args
+      end
+    end
+
+  end # class Dsl
+end # class Predicate

data/lib/predicate/factory.rb

@@ -1,69 +1,182 @@
 class Predicate
   module Factory
 
+  public # Boolean
+
+    # Factors a Predicate that captures True
     def tautology
       _factor_predicate([:tautology, true])
     end
 
+    # Factors a Predicate that captures False
     def contradiction
       _factor_predicate([:contradiction, false])
     end
 
+  public # Literals
+
+    # Factors a Literal node for some ruby value.
+    def literal(literal)
+      _factor_predicate([:literal, literal])
+    end
+
+  public # Vars & identifiers
+
+    # Factors a var node, using a given extractor semantics
+    def var(formaldef, semantics = :dig)
+      _factor_predicate([:var, formaldef, semantics])
+    end
+
+    # Factors a couple of variables at once. The semantics can
+    # be passed as a Symbol as last argument and defaults to :dig
+    def vars(*args)
+      args << :dig unless args.last.is_a?(Symbol)
+      args[0...-1].map{|v| var(v, args.last) }
+    end
+
+    # Factors a Predicate for a free variable whose
+    # name is provided. If the variable is a Boolean
+    # variable, this is a valid Predicate, otherwise
+    # it must be used in a higher-level expression.
     def identifier(name)
       _factor_predicate([:identifier, name])
     end
 
+    # Factors a Predicate for a qualified free variable.
+    # Same remark as in `identifier`.
     def qualified_identifier(qualifier, name)
       _factor_predicate([:qualified_identifier, qualifier, name])
     end
 
+    # Builds and returns a placeholder that can be used
+    # everywhere a literal can be used. Placeholders can
+    # be bound later, using `Predicate#bind`.
     def placeholder
       Placeholder.new
     end
 
+  public # Boolean logic
+
+    # Builds a AND predicate using two sub predicates.
+    #
+    # Please favor `Predicate#&` instead.
     def and(left, right = nil)
       _factor_predicate([:and, sexpr(left), sexpr(right)])
     end
 
+    # Builds a OR predicate using two sub predicates.
+    #
+    # Please favor `Predicate#|` instead.
     def or(left, right = nil)
       _factor_predicate([:or, sexpr(left), sexpr(right)])
     end
 
+    # Negates an existing predicate.
+    #
+    # Please favor `Predicate#!` instead.
     def not(operand)
       _factor_predicate([:not, sexpr(operand)])
     end
 
+  public # Comparison operators
+
+    # :nodoc:
+    def comp(op, h)
+      from_hash(h, op)
+    end
+
+    # Factors =, !=, <, <=, >, >= predicates between
+    # a variable and either a literal or another variable.
+    [ :eq, :neq, :lt, :lte, :gt, :gte ].each do |m|
+      define_method(m) do |left, right|
+        _factor_predicate([m, sexpr(left), sexpr(right)])
+      end
+    end
+
+  # Set operators
+
+    # Factors a IN predicate between a variable and
+    # either a list of values of another variable.
     def in(left, right)
-      left, right = sexpr(left), sexpr(right)
-      if right.literal? && right.empty_value?
-        contradiction
+      case right
+      when Range
+        return contradiction if right.size == 0
+        rl = gte(left, right.begin)
+        rr = right.exclude_end? ? lt(left, right.end) : lte(left, right.end)
+        self.and(rl, rr)
       else
-        _factor_predicate([:in, left, right])
+        left, right = sexpr(left), sexpr(right)
+        if right.literal? && right.empty_value?
+          contradiction
+        else
+          _factor_predicate([:in, left, right])
+        end
       end
     end
     alias :among :in
 
-    def intersect(identifier, values)
-      identifier = sexpr(identifier) if identifier.is_a?(Symbol)
-      _factor_predicate([:intersect, identifier, values])
+    # Factors an INTERSECT predicate between a
+    # variable and a list of values.
+    [:intersect, :subset, :superset].each do |name|
+      define_method(name) do |left, right|
+        identifier = sexpr(identifier) if identifier.is_a?(Symbol)
+        _factor_predicate([name, sexpr(left), sexpr(right)])
+      end
     end
 
-    def comp(op, h)
-      from_hash(h, op)
+  public # Other operators
+
+    # Factors a MATCH predicate between a variable
+    # and a literal or another variable.
+    #
+    # Matching options can be passes and are specific
+    # to the actual usage of the library.
+    def match(left, right, options)
+      s = [:match, sexpr(left), sexpr(right)]
+      s << options unless options.nil?
+      _factor_predicate(s)
     end
 
-    [ :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?
-        _factor_predicate([m, sexpr(left), sexpr(right)])
-      end
+    # Factors an EMPTY predicate that responds true
+    # when its operand is something empty.
+    #
+    # Default evaluation uses ruby `empty?` method.
+    def empty(operand)
+      _factor_predicate([:empty, sexpr(operand)])
+    end
+
+    # Factors a SIZE predicate that responds true when
+    # its operand has a size meeting the right constraint
+    # (typically a Range literal)
+    def has_size(left, right)
+      _factor_predicate([:has_size, sexpr(left), sexpr(right)])
+    end
+
+    #jeny(predicate) # TODO
+    #jeny(predicate) def ${op_name}(*args)
+    #jeny(predicate)   args = args.map{|arg| sexpr(arg) }
+    #jeny(predicate)   _factor_predicate([:${op_name}] + args)
+    #jeny(predicate) end
+
+  public # Low-level
+
+    # Factors a predicate for a ruby Proc that returns
+    # truth-value for a single argument.
+    def native(arg)
+      _factor_predicate([:native, arg])
     end
 
-    def between(middle, lower_bound, upper_bound)
-      _factor_predicate [:and, [:gte, sexpr(middle), sexpr(lower_bound)],
-                               [:lte, sexpr(middle), sexpr(upper_bound)]]
+    # Converts `arg` to an opaque predicate, whose semantics
+    # depends on the actual usage of the library.
+    def opaque(arg)
+      _factor_predicate([:opaque, arg])
     end
 
+  public # Semi protected
+
+    # Builds a AND predicate between all key/value pairs
+    # of the provided Hash, using the comparison operator
+    # specified.
     def from_hash(h, op = :eq)
       if h.empty?
         tautology
@@ -80,22 +193,6 @@ class Predicate
       end
     end
 
-    def literal(literal)
-      _factor_predicate([:literal, literal])
-    end
-
-    def opaque(arg)
-      _factor_predicate([:opaque, arg])
-    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
-
   protected
 
     def sexpr(expr)

data/lib/predicate/grammar.rb

@@ -10,13 +10,14 @@ class Predicate
       Expr
     end
 
-  end
+  end # module Grammar
 end # class Predicate
 require_relative 'nodes/expr'
 require_relative 'nodes/dyadic_comp'
 require_relative 'nodes/nadic_bool'
 require_relative 'nodes/tautology'
 require_relative 'nodes/contradiction'
+require_relative 'nodes/var'
 require_relative 'nodes/identifier'
 require_relative 'nodes/qualified_identifier'
 require_relative 'nodes/and'
@@ -29,8 +30,16 @@ require_relative 'nodes/gte'
 require_relative 'nodes/lt'
 require_relative 'nodes/lte'
 require_relative 'nodes/in'
+require_relative 'nodes/set_op'
 require_relative 'nodes/intersect'
+require_relative 'nodes/subset'
+require_relative 'nodes/superset'
 require_relative 'nodes/literal'
-require_relative 'nodes/match'
 require_relative 'nodes/native'
 require_relative 'nodes/opaque'
+require_relative 'nodes/unary_func'
+require_relative 'nodes/binary_func'
+require_relative 'nodes/match'
+require_relative 'nodes/empty'
+require_relative 'nodes/has_size'
+#jeny(predicate) require_relative 'nodes/${op_name}'