alf-core 0.13.0

data/lib/alf-predicate/alf/predicate.rb

@@ -0,0 +1,110 @@
+require_relative 'predicate/parser'
+require_relative 'predicate/factory'
+require_relative 'predicate/grammar'
+require_relative 'predicate/processors'
+module Alf
+  class Predicate
+
+    def initialize(expr)
+      @expr = expr
+    end
+    attr_reader :expr
+
+    class << self
+      include Factory
+
+      def coerce(arg)
+        case arg
+        when Predicate   then arg
+        when TrueClass   then tautology
+        when FalseClass  then contradiction
+        when Symbol      then var_ref(arg)
+        when Proc        then native(arg)
+        when Hash, Tuple then eq(arg)
+        when String      then Predicate.new(Grammar.parse(arg))
+        when Relation    then relation(arg)
+        else
+          raise ArgumentError, "Unable to coerce `#{arg}` to a predicate"
+        end
+      end
+      alias :parse :coerce
+
+    private
+
+      def _factor_predicate(arg)
+        Predicate.new Grammar.sexpr(arg)
+      end
+
+    end
+
+    def tautology?
+      expr.tautology?
+    end
+
+    def contradiction?
+      expr.contradiction?
+    end
+
+    def free_variables
+      expr.free_variables
+    end
+
+    def constant_variables
+      expr.constant_variables
+    end
+
+    def &(other)
+      return self  if other.tautology? or other==self
+      return other if tautology?
+      Predicate.new(expr & other.expr)
+    end
+
+    def |(other)
+      return self  if other.contradiction? or other==self
+      return other if contradiction?
+      Predicate.new(expr | other.expr)
+    end
+
+    def !
+      Predicate.new(!expr)
+    end
+
+    def rename(renaming)
+      Predicate.new(expr.rename(renaming))
+    end
+
+    def evaluate(scope)
+      scope.instance_exec(&to_proc)
+    end
+
+    def and_split(attr_list)
+      expr.and_split(attr_list).map{|e| Predicate.new(e)}
+    end
+
+    def ==(other)
+      other.is_a?(Predicate) && (other.expr==expr)
+    end
+
+    def hash
+      expr.hash
+    end
+
+    def to_ruby_code
+      @ruby_code ||= expr.to_ruby_code(:scope => "self")
+    end
+    alias :to_s :to_ruby_code
+
+    def to_proc
+      @proc ||= expr.to_proc(:scope => "self")
+    end
+
+    def to_lispy
+      "->{ #{to_ruby_code} }"
+    end
+
+    def to_ruby_literal
+      to_proc.to_ruby_literal
+    end
+
+  end # class Predicate
+end # module Alf

data/lib/alf-predicate/alf/predicate/factory.rb

@@ -0,0 +1,104 @@
+module Alf
+  class Predicate
+    module Factory
+
+      def tautology
+        _factor_predicate([:tautology, true])
+      end
+
+      def contradiction
+        _factor_predicate([:contradiction, false])
+      end
+
+      def var_ref(name)
+        _factor_predicate([:var_ref, name])
+      end
+
+      def and(left, right = nil)
+        _factor_predicate([:and, sexpr(left), sexpr(right)])
+      end
+
+      def or(left, right = nil)
+        _factor_predicate([:or, sexpr(left), sexpr(right)])
+      end
+
+      def not(operand)
+        _factor_predicate([:not, sexpr(operand)])
+      end
+
+      def relation(r)
+        tuples = r.to_a
+        case tuples.size
+        when 0 then contradiction
+        when 1 then eq(tuples.first)
+        else
+          if tuples.first.size==1
+            k = tuples.first.keys.first
+            self.in(k, tuples.map{|t| t[k]})
+          else
+            tuples.inject(contradiction){|p,t| p | eq(t) }
+          end
+        end
+      end
+
+      def in(var_ref, values)
+        var_ref = sexpr(var_ref) if var_ref.is_a?(Symbol)
+        _factor_predicate([:in, var_ref, values])
+      end
+
+      def comp(op, h)
+        h = h.to_hash
+        if h.empty?
+          return tautology
+        elsif h.size==1
+          _factor_predicate [op, sexpr(h.keys.first), sexpr(h.values.last)]
+        else
+          terms = h.to_a.inject([:and]) do |anded,pair|
+            anded << ([op] << sexpr(pair.first) << sexpr(pair.last))
+          end
+          _factor_predicate terms
+        end
+      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
+      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 literal(literal)
+        _factor_predicate([:literal, literal])
+      end
+
+      def native(proc)
+        _factor_predicate([:native, proc])
+      end
+
+      def sexpr(expr)
+        case expr
+        when Expr       then expr
+        when Predicate  then expr.expr
+        when TrueClass  then Grammar.sexpr([:tautology, true])
+        when FalseClass then Grammar.sexpr([:contradiction, false])
+        when Symbol     then Grammar.sexpr([:var_ref, expr])
+        when Proc       then Grammar.sexpr([:native, expr])
+        when Array      then Grammar.sexpr(expr)
+        else
+          Grammar.sexpr([:literal, expr])
+        end
+      end
+
+      def _factor_predicate(arg)
+        sexpr(arg)
+      end
+
+      extend(self)
+    end # module Factory
+  end # class Predicate
+end # module Alf

data/lib/alf-predicate/alf/predicate/grammar.rb

@@ -0,0 +1,38 @@
+module Alf
+  class Predicate
+    Grammar = Sexpr.load Path.relative('grammar.sexp.yml')
+    module Grammar
+
+      def tagging_reference
+        Predicate
+      end
+
+      def default_tagging_module
+        Expr
+      end
+
+      def parser
+        Parser.new
+      end
+
+    end
+  end # class Predicate
+end # module Alf
+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_ref'
+require_relative 'nodes/and'
+require_relative 'nodes/or'
+require_relative 'nodes/not'
+require_relative 'nodes/eq'
+require_relative 'nodes/neq'
+require_relative 'nodes/gt'
+require_relative 'nodes/gte'
+require_relative 'nodes/lt'
+require_relative 'nodes/lte'
+require_relative 'nodes/in'
+require_relative 'nodes/literal'
+require_relative 'nodes/native'

data/lib/alf-predicate/alf/predicate/grammar.sexp.yml

@@ -0,0 +1,54 @@
+rules:
+  predicate:
+    - tautology
+    - contradiction
+    - var_ref
+    - not
+    - and
+    - or
+    - eq
+    - neq
+    - lt
+    - lte
+    - gt
+    - gte
+    - in
+    - native
+  tautology:
+    - [ true ]
+  contradiction:
+    - [ false ]
+  var_ref:
+    - [ var_name ]
+  not:
+    - [ predicate ]
+  and:
+    - [ predicate+ ]
+  or:
+    - [ predicate+ ]
+  eq:
+    - [ term, term ]
+  neq:
+    - [ term, term ]
+  lt:
+    - [ term, term ]
+  lte:
+    - [ term, term ]
+  gt:
+    - [ term, term ]
+  gte:
+    - [ term, term ]
+  in:
+    - [ var_ref, values ]
+  term:
+    - var_ref
+    - literal
+  native:
+    - [ "::Proc" ]
+  literal:
+    - "::Object"
+  values:
+    - "::Object"
+  var_name:
+    !ruby/regexp /^[a-zA-Z0-9_]+[?!]?$/
+

data/lib/alf-predicate/alf/predicate/nodes/and.rb

@@ -0,0 +1,25 @@
+module Alf
+  class Predicate
+    module And
+      include NadicBool
+
+      def operator_symbol
+        :'&&'
+      end
+
+      def and_split(attr_list)
+        sexpr_body.inject([tautology, tautology]) do |(top,down),term|
+          pair = term.and_split(attr_list)
+          [top & pair.first, down & pair.last]
+        end
+      end
+
+      def constant_variables
+        sexpr_body.inject(AttrList::EMPTY) do |cvars,expr|
+          cvars | expr.constant_variables
+        end
+      end
+
+    end
+  end
+end

data/lib/alf-predicate/alf/predicate/nodes/contradiction.rb

@@ -0,0 +1,36 @@
+module Alf
+  class Predicate
+    module Contradiction
+      include Expr
+
+      def contradiction?
+        true
+      end
+
+      def !
+        tautology
+      end
+
+      def &(other)
+        self
+      end
+
+      def |(other)
+        other
+      end
+
+      def priority
+        100
+      end
+
+      def free_variables
+        @free_variables ||= AttrList::EMPTY
+      end
+
+      def and_split(*args)
+        [tautology, self]
+      end
+
+    end
+  end
+end

data/lib/alf-predicate/alf/predicate/nodes/dyadic_comp.rb

@@ -0,0 +1,28 @@
+module Alf
+  class Predicate
+    module DyadicComp
+      include Expr
+
+      def priority
+        50
+      end
+
+      def !
+        Factory.send(OP_NEGATIONS[first], self[1], self[2])
+      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
+end

data/lib/alf-predicate/alf/predicate/nodes/eq.rb

@@ -0,0 +1,17 @@
+module Alf
+  class Predicate
+    module Eq
+      include DyadicComp
+
+      def operator_symbol
+        :==
+      end
+
+      def constant_variables
+        fv = free_variables
+        fv.size == 1 ? fv : AttrList::EMPTY
+      end
+
+    end
+  end
+end

data/lib/alf-predicate/alf/predicate/nodes/expr.rb

@@ -0,0 +1,65 @@
+module Alf
+  class Predicate
+    module Expr
+      include Factory
+
+      OP_NEGATIONS = {
+        :eq  => :neq,
+        :neq => :eq,
+        :lt  => :gte,
+        :lte => :gt,
+        :gt  => :lte,
+        :gte => :lt
+      }
+
+      def tautology?
+        false
+      end
+
+      def contradiction?
+        false
+      end
+
+      def !
+        sexpr([:not, self])
+      end
+
+      def &(other)
+        return other if other.contradiction?
+        return self  if other.tautology?
+        sexpr([:and, self, other])
+      end
+
+      def |(other)
+        return other if other.tautology?
+        return self  if other.contradiction?
+        sexpr([:or, self, other])
+      end
+
+      def and_split(attr_list)
+        (free_variables & attr_list).empty? ? [ tautology, self ] : [ self, tautology ]
+      end
+
+      def rename(renaming)
+        Renamer.call(self, :renaming => renaming.to_hash)
+      end
+
+      def constant_variables
+        AttrList::EMPTY
+      end
+
+      def to_ruby_code(options = {})
+        ToRubyCode.call(self, options)
+      end
+
+      def to_proc(options = {})
+        ToProc.call(self, options)
+      end
+
+      def sexpr(arg)
+        Factory.sexpr(arg)
+      end
+
+    end
+  end
+end