predicate 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: '07778e150b98d73bf35ce337d9874395f1f58e1c'
+  data.tar.gz: 9d0e523c2f41b8b5c530e67a14a69f3dbdf31914
+SHA512:
+  metadata.gz: 84111b7fe5dc17da15f9cb3afb1cee966cedb9a29ed2e420348071c348d6f7c0cd94265c116afc7cae987ca7a96f6f29e52035c9540db85b817ee219da958c59
+  data.tar.gz: cb5d7863db1db730e22b7fd6fe1b7023b89a8a2ef442333d8762ff1fe0b585805d10a2dd832ab07fc98453d7186daeac793c8963e4e38da2ea94fdb94c73db3a

data/Gemfile

@@ -0,0 +1,2 @@
+source "https://rubygems.org"
+gemspec

data/LICENSE.md

@@ -0,0 +1,22 @@
+# The MIT Licence
+
+    Copyright (c) 2017 - Enspirit SPRL (Bernard Lambeau)
+
+    Permission is hereby granted, free of charge, to any person obtaining
+    a copy of this software and associated documentation files (the
+    "Software"), to deal in the Software without restriction, including
+    without limitation the rights to use, copy, modify, merge, publish,
+    distribute, sublicense, and/or sell copies of the Software, and to
+    permit persons to whom the Software is furnished to do so, subject to
+    the following conditions:
+
+    The above copyright notice and this permission notice shall be
+    included in all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+    LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,11 @@
+require 'path'
+
+#
+# Install all tasks found in tasks folder
+#
+# See .rake files there for complete documentation.
+#
+Dir["tasks/*.rake"].each do |taskfile|
+  load taskfile
+end
+task :default => :test

data/lib/predicate/factory.rb

@@ -0,0 +1,107 @@
+class Predicate
+  module Factory
+
+    def tautology
+      _factor_predicate([:tautology, true])
+    end
+
+    def contradiction
+      _factor_predicate([:contradiction, false])
+    end
+
+    def identifier(name)
+      _factor_predicate([:identifier, name])
+    end
+
+    def qualified_identifier(qualifier, name)
+      _factor_predicate([:qualified_identifier, qualifier, 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(identifier, values)
+      identifier = sexpr(identifier) if identifier.is_a?(Symbol)
+      _factor_predicate([:in, identifier, values])
+    end
+    alias :among :in
+
+    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(arg)
+      _factor_predicate([:native, arg])
+    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([:identifier, 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

data/lib/predicate/grammar.rb

@@ -0,0 +1,33 @@
+class Predicate
+  Grammar = Sexpr.load File.expand_path('../grammar.sexp.yml', __FILE__)
+  module Grammar
+
+    def tagging_reference
+      Predicate
+    end
+
+    def default_tagging_module
+      Expr
+    end
+
+  end
+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/identifier'
+require_relative 'nodes/qualified_identifier'
+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/predicate/grammar.sexp.yml

@@ -0,0 +1,58 @@
+rules:
+  predicate:
+    - tautology
+    - contradiction
+    - identifier
+    - not
+    - and
+    - or
+    - eq
+    - neq
+    - lt
+    - lte
+    - gt
+    - gte
+    - in
+    - native
+  tautology:
+    - [ true ]
+  contradiction:
+    - [ false ]
+  identifier:
+    - [ name ]
+  qualified_identifier:
+    - [ name, 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:
+    - [ varref, values ]
+  term:
+    - varref
+    - literal
+  varref:
+    - qualified_identifier
+    - identifier
+  native:
+    - [ "::Proc" ]
+  literal:
+    - "::Object"
+  values:
+    - "::Object"
+  name:
+    !ruby/regexp /^[a-zA-Z0-9_]+[?!]?$/

data/lib/predicate/nodes/and.rb

@@ -0,0 +1,23 @@
+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([]) do |cvars,expr|
+        cvars | expr.constant_variables
+      end
+    end
+
+  end
+end

data/lib/predicate/nodes/contradiction.rb

@@ -0,0 +1,34 @@
+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 ||= []
+    end
+
+    def and_split(*args)
+      [tautology, self]
+    end
+
+  end
+end

data/lib/predicate/nodes/dyadic_comp.rb

@@ -0,0 +1,26 @@
+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

data/lib/predicate/nodes/eq.rb

@@ -0,0 +1,15 @@
+class Predicate
+  module Eq
+    include DyadicComp
+
+    def operator_symbol
+      :==
+    end
+
+    def constant_variables
+      fv = free_variables
+      fv.size == 1 ? fv : []
+    end
+
+  end
+end

data/lib/predicate/nodes/expr.rb

@@ -0,0 +1,68 @@
+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)
+    end
+
+    def qualify(qualifier)
+      Qualifier.new(qualifier).call(self)
+    end
+
+    def constant_variables
+      []
+    end
+
+    def to_ruby_code(scope = 't')
+      code = ToRubyCode.call(self, scope: scope)
+      "->(t){ #{code} }"
+    end
+
+    def to_proc(scope = 't')
+      Kernel.eval(to_ruby_code(scope))
+    end
+
+    def sexpr(arg)
+      Factory.sexpr(arg)
+    end
+
+  end
+end

data/lib/predicate/nodes/gt.rb

@@ -0,0 +1,10 @@
+class Predicate
+  module Gt
+    include DyadicComp
+
+    def operator_symbol
+      :>
+    end
+
+  end
+end

data/lib/predicate/nodes/gte.rb

@@ -0,0 +1,10 @@
+class Predicate
+  module Gte
+    include DyadicComp
+
+    def operator_symbol
+      :>=
+    end
+
+  end
+end

data/lib/predicate/nodes/identifier.rb

@@ -0,0 +1,18 @@
+class Predicate
+  module Identifier
+    include Expr
+
+    def priority
+      100
+    end
+
+    def name
+      self[1]
+    end
+
+    def free_variables
+      @free_variables ||= [ name ]
+    end
+
+  end
+end

data/lib/predicate/nodes/in.rb

@@ -0,0 +1,26 @@
+class Predicate
+  module In
+    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
+      values.size == 1 ? free_variables : []
+    end
+
+  end
+end

data/lib/predicate/nodes/literal.rb

@@ -0,0 +1,18 @@
+class Predicate
+  module Literal
+    include Expr
+
+    def priority
+      100
+    end
+
+    def free_variables
+      @free_variables ||= []
+    end
+
+    def value
+      last
+    end
+
+  end
+end

data/lib/predicate/nodes/lt.rb

@@ -0,0 +1,10 @@
+class Predicate
+  module Lt
+    include DyadicComp
+
+    def operator_symbol
+      :<
+    end
+
+  end
+end

data/lib/predicate/nodes/lte.rb

@@ -0,0 +1,10 @@
+class Predicate
+  module Lte
+    include DyadicComp
+
+    def operator_symbol
+      :<=
+    end
+
+  end
+end

data/lib/predicate/nodes/nadic_bool.rb

@@ -0,0 +1,16 @@
+class Predicate
+  module NadicBool
+    include Expr
+
+    def priority
+      60
+    end
+
+    def free_variables
+      @free_variables ||= sexpr_body.inject([]){|list,term| 
+        list | term.free_variables
+      }
+    end
+
+  end
+end

data/lib/predicate/nodes/native.rb

@@ -0,0 +1,30 @@
+class Predicate
+  module Native
+    include Expr
+
+    def priority
+      90
+    end
+
+    def proc
+      self[1]
+    end
+
+    def to_ruby_code(scope = 't')
+      if proc.respond_to?(:source_code)
+        code = proc.source_code
+        return code if code
+      end
+      raise NotSupportedError
+    end
+
+    def to_proc(scope = 't')
+      proc
+    end
+
+    def free_variables
+      raise NotSupportedError
+    end
+
+  end
+end

data/lib/predicate/nodes/neq.rb

@@ -0,0 +1,10 @@
+class Predicate
+  module Neq
+    include DyadicComp
+
+    def operator_symbol
+      :'!='
+    end
+
+  end
+end

data/lib/predicate/nodes/not.rb

@@ -0,0 +1,22 @@
+class Predicate
+  module Not
+    include Expr
+
+    def operator_symbol
+      :'!'
+    end
+
+    def priority
+      90
+    end
+
+    def !
+      last
+    end
+
+    def free_variables
+      @free_variables ||= last.free_variables
+    end
+
+  end
+end

data/lib/predicate/nodes/or.rb

@@ -0,0 +1,10 @@
+class Predicate
+  module Or
+    include NadicBool
+
+    def operator_symbol
+      :'||'
+    end
+
+  end
+end

data/lib/predicate/nodes/qualified_identifier.rb

@@ -0,0 +1,22 @@
+class Predicate
+  module QualifiedIdentifier
+    include Expr
+
+    def priority
+      100
+    end
+
+    def qualifier
+      self[1]
+    end
+
+    def name
+      self[2]
+    end
+
+    def free_variables
+      @free_variables ||= [ name ]
+    end
+
+  end
+end

data/lib/predicate/nodes/tautology.rb

@@ -0,0 +1,30 @@
+class Predicate
+  module Tautology
+    include Expr
+
+    def tautology?
+      true
+    end
+
+    def !
+      contradiction
+    end
+
+    def &(other)
+      other
+    end
+
+    def |(other)
+      self
+    end
+
+    def priority
+      100
+    end
+
+    def free_variables
+      @free_variables ||= []
+    end
+
+  end
+end