predicate 2.3.2 → 2.6.0

data/lib/predicate/factory.rb

@@ -1,78 +1,199 @@
 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 from a mapping between variables
+    # and values. This typically generates a AND(EQ)
+    # predicate, but a value can be an Array (IN) or a
+    # Regexp (MATCH).
+    def h(h)
+      from_hash(h, :eq)
     end
 
-    def between(middle, lower_bound, upper_bound)
-      _factor_predicate [:and, [:gte, sexpr(middle), sexpr(lower_bound)],
-                               [:lte, sexpr(middle), sexpr(upper_bound)]]
+    # Factors a predicate for a ruby Proc that returns
+    # truth-value for a single argument.
+    def native(arg)
+      _factor_predicate([:native, arg])
     end
 
+    # 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
       else
         terms = h.to_a.map{|(k,v)|
-          if v.is_a?(Array)
-            [:in, sexpr(k), sexpr(v)]
-          else
-            [op, sexpr(k), sexpr(v)]
+          case v
+          when Array  then [:in, sexpr(k), sexpr(v)]
+          when Regexp then [:match, sexpr(k), sexpr(v) ]
+          else             [op, sexpr(k), sexpr(v)]
           end
         }
         terms = terms.size == 1 ? terms.first : terms.unshift(:and)
@@ -80,22 +201,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}'

data/lib/predicate/grammar.sexp.yml

@@ -3,6 +3,8 @@ rules:
     - tautology
     - contradiction
     - identifier
+    - qualified_identifier
+    - var
     - not
     - and
     - or
@@ -14,8 +16,13 @@ rules:
     - gte
     - in
     - intersect
+    - subset
+    - superset
     - match
     - native
+    - empty
+    - has_size
+    #jeny(predicate) - ${op_name}
   tautology:
     - [ true ]
   contradiction:
@@ -24,6 +31,8 @@ rules:
     - [ name ]
   qualified_identifier:
     - [ name, name ]
+  var:
+    - [ formaldef, semantics ]
   not:
     - [ predicate ]
   and:
@@ -46,8 +55,18 @@ rules:
     - [ varref, term ]
   intersect:
     - [ term, term ]
+  subset:
+    - [ term, term ]
+  superset:
+    - [ term, term ]
   match:
     - [ term, term, options ]
+  empty:
+    - [ term ]
+  has_size:
+    - [ term, term ]
+#jeny(predicate)   ${op_name}:
+#jeny(predicate)     - [ TODO ]
   term:
     - varref
     - literal
@@ -56,6 +75,7 @@ rules:
   varref:
     - qualified_identifier
     - identifier
+    - var
   native:
     - [ "::Proc" ]
   literal:
@@ -68,3 +88,12 @@ rules:
     - "::Hash"
   name:
     !ruby/regexp /^[a-zA-Z0-9_]+[?!]?$/
+  semantics:
+    !ruby/regexp /^(dig)$/
+  formaldef:
+    - string_formaldef
+    - array_formaldef
+  string_formaldef:
+    - "::String"
+  array_formaldef:
+    - "::Array"

data/lib/predicate/nodes/${op_name}.rb.jeny

@@ -0,0 +1,12 @@
+#jeny(predicate)
+class Predicate
+  module ${OpName}
+    include ${Arity}Func
+
+    def evaluate(tuple)
+      # TODO: implement this
+      raise NotImplementedError
+    end
+
+  end
+end

data/lib/predicate/nodes/and.rb

@@ -53,5 +53,14 @@ class Predicate
       sexpr_body.all?{|operand| operand.evaluate(tuple) }
     end
 
+    def to_hash
+      sexpr_body.inject({}) do |p,term|
+        p.merge(term.to_hash){|k,v1,v2|
+          super unless v1 == v2
+          v1
+        }
+      end
+    end
+
   end
 end

data/lib/predicate/nodes/binary_func.rb

@@ -0,0 +1,20 @@
+class Predicate
+  module BinaryFunc
+    include Expr
+
+    def priority; 80; end
+
+    def left
+      self[1]
+    end
+
+    def right
+      self[2]
+    end
+
+    def free_variables
+      @free_variables ||= left.free_variables | right.free_variables
+    end
+
+  end
+end

data/lib/predicate/nodes/contradiction.rb

@@ -18,13 +18,8 @@ class Predicate
       other
     end
 
-    def dyadic_priority
-      1000
-    end
-
-    def priority
-      100
-    end
+    def dyadic_priority; 1000; end
+    def priority; 100; end
 
     def free_variables
       @free_variables ||= []

data/lib/predicate/nodes/dyadic_comp.rb

@@ -2,9 +2,7 @@ class Predicate
   module DyadicComp
     include Expr
 
-    def priority
-      50
-    end
+    def priority; 50; end
 
     def !
       Factory.send(OP_NEGATIONS[first], self[1], self[2])

data/lib/predicate/nodes/empty.rb

@@ -0,0 +1,14 @@
+class Predicate
+  module Empty
+    include UnaryFunc
+
+    def evaluate(tuple)
+      value = operand.evaluate(tuple)
+      unless value.respond_to?(:empty?)
+        raise TypeError, "Expected #{value} to respond to empty?"
+      end
+      value.empty?
+    end
+
+  end
+end

data/lib/predicate/nodes/eq.rb

@@ -40,13 +40,21 @@ class Predicate
       end
     end
 
-    def dyadic_priority
-      900
-    end
+    def dyadic_priority; 900; end
 
     def evaluate(tuple)
       left.evaluate(tuple) == right.evaluate(tuple)
     end
 
+    def to_hash
+      if left.identifier? && right.literal? && !right.has_placeholder?
+        { left.name => right.value }
+      elsif right.identifier? && left.literal? && !left.has_placeholder?
+        { right.name => left.value }
+      else
+        super
+      end
+    end
+
   end
 end

data/lib/predicate/nodes/expr.rb

@@ -35,9 +35,7 @@ class Predicate
       sexpr([:not, self])
     end
 
-    def dyadic_priority
-      0
-    end
+    def dyadic_priority; 0; end
 
     def &(other)
       return other if other.contradiction?
@@ -77,6 +75,10 @@ class Predicate
       Qualifier.new(qualifier).call(self)
     end
 
+    def unqualify
+      Unqualifier.new.call(self)
+    end
+
     def bind(binding)
       Binder.new(binding).call(self)
     end
@@ -93,6 +95,10 @@ class Predicate
       ToS.call(self, scope: scope)
     end
 
+    def to_hash
+      raise ArgumentError, "Unable to represent #{self} to a Hash"
+    end
+
     def sexpr(arg)
       Factory.sexpr(arg)
     end

data/lib/predicate/nodes/has_size.rb

@@ -0,0 +1,14 @@
+class Predicate
+  module HasSize
+    include BinaryFunc
+
+    def evaluate(tuple)
+      l, r = left.evaluate(tuple), right.evaluate(tuple)
+      r = r..r if r.is_a?(Integer)
+      raise Error, "Expected Range, got #{r}" unless r.is_a?(Range)
+      raise Error, "Expected #{l} to respond to :size" unless l.respond_to?(:size)
+      r === l.size
+    end
+
+  end
+end

data/lib/predicate/nodes/identifier.rb

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

data/lib/predicate/nodes/in.rb

@@ -2,9 +2,7 @@ class Predicate
   module In
     include Expr
 
-    def priority
-      80
-    end
+    def priority; 80; end
 
     def left
       self[1]
@@ -61,9 +59,7 @@ class Predicate
       end
     end
 
-    def dyadic_priority
-      800
-    end
+    def dyadic_priority; 800; end
 
     def evaluate(tuple)
       values = right.evaluate(tuple)
@@ -75,5 +71,10 @@ class Predicate
       left.identifier? && right.literal? && !right.has_placeholder?
     end
 
+    def to_hash
+      return super unless var_against_literal_value?
+      { identifier.name => right.value }
+    end
+
   end
 end

data/lib/predicate/nodes/intersect.rb

@@ -1,30 +1,10 @@
 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
-      []
-    end
+    include SetOp
 
     def evaluate(tuple)
-      t_x = identifier.evaluate(tuple)
-      t_x && !(t_x & values).empty?
+      x, y = left.evaluate(tuple), right.evaluate(tuple)
+      x && y && !(x & y).empty?
     end
 
   end

data/lib/predicate/nodes/literal.rb

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

data/lib/predicate/nodes/match.rb

@@ -1,23 +1,11 @@
 class Predicate
   module Match
-    include Expr
+    include BinaryFunc
 
     DEFAULT_OPTIONS = {
       case_sensitive: true
     }
 
-    def priority
-      80
-    end
-
-    def left
-      self[1]
-    end
-
-    def right
-      self[2]
-    end
-
     def options
       @options ||= DEFAULT_OPTIONS.merge(self[3] || {})
     end
@@ -26,14 +14,6 @@ class Predicate
       options[:case_sensitive]
     end
 
-    def free_variables
-      @free_variables ||= left.free_variables | right.free_variables
-    end
-
-    def dyadic_priority
-      800
-    end
-
     def evaluate(tuple)
       l = left.evaluate(tuple)
       r = right.evaluate(tuple)

data/lib/predicate/nodes/nadic_bool.rb

@@ -2,9 +2,7 @@ class Predicate
   module NadicBool
     include Expr
 
-    def priority
-      60
-    end
+    def priority; 60; end
 
     def free_variables
       @free_variables ||= sexpr_body.inject([]){|list,term| 

data/lib/predicate/nodes/native.rb

@@ -2,9 +2,7 @@ class Predicate
   module Native
     include Expr
 
-    def priority
-      90
-    end
+    def priority; 90; end
 
     def proc
       self[1]

data/lib/predicate/nodes/not.rb

@@ -6,9 +6,7 @@ class Predicate
       :'!'
     end
 
-    def priority
-      90
-    end
+    def priority; 90; end
 
     def !
       last

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 ||= []