mort666-wongi-engine 0.2.9

data/lib/wongi-engine/core_ext.rb

@@ -0,0 +1,63 @@
+module Wongi::Engine
+
+  module CoreExt
+
+    module ClassMethods
+
+      def attr_predicate *names
+
+        names_hash = names.inject( {} ) do |hash, element|
+          if Hash === element
+            hash.merge element
+          else
+            hash[element] = false
+            hash
+          end
+        end
+
+        names_hash.each do |name, def_value|
+
+          varname = "@#{name}".to_sym
+          predname = "#{name}?".to_sym
+          setname = "#{name}=".to_sym
+          exclname = "#{name}!".to_sym
+          noexclname = "no_#{name}!".to_sym
+
+          define_method predname do
+            if instance_variable_defined?( varname )
+              instance_variable_get( varname )
+            else
+              def_value
+            end
+          end
+
+          define_method setname do |newvalue|
+            instance_variable_set( varname, newvalue == true )
+          end
+
+          define_method exclname do
+            instance_variable_set( varname, true )
+          end
+
+          define_method noexclname do
+            instance_variable_set( varname, false )
+          end
+
+        end
+      end
+
+      def abstract name
+        define_method name do |*args|
+          raise NoMethodError.new "#{name} is not implemented for #{self.class.name}", name
+        end
+      end
+
+    end
+
+    def self.included mod
+      mod.extend ClassMethods
+    end
+
+  end
+
+end

data/lib/wongi-engine/data_overlay.rb

@@ -0,0 +1,144 @@
+module Wongi::Engine
+  class DataOverlay
+
+    attr_reader :rete
+    attr_reader :parent
+
+    def initialize(rete, parent = nil)
+      @rete = rete
+      @parent = parent
+      @raw_wmes = Hash.new { |h, k| h[k] = [] }
+      @raw_tokens = Hash.new { |h, k| h[k] = [] }
+      rete.add_overlay(self)
+    end
+
+    def new_child
+      DataOverlay.new(rete, self)
+    end
+
+    def with_child
+      return unless block_given?
+      new_child.tap do |overlay|
+        begin
+          result = yield overlay
+        ensure
+          overlay.dispose
+        end
+        result
+      end
+    end
+
+    def ancestor?(other)
+      return false if parent.nil?
+      return true if parent == other
+      parent.ancestor?(other)
+    end
+
+    def dispose
+      return if self == rete.default_overlay
+      rete.remove_overlay(self)
+      @raw_tokens.values.each do |tokens|
+        tokens.each(&:dispose!)
+      end
+      @raw_tokens.clear
+    end
+
+    def <<(thing)
+      case thing
+      when Array
+        assert WME.new(*thing).tap { |wme| wme.overlay = self }
+      when WME
+        assert(thing)
+      else
+        raise Error, "overlays can only accept data"
+      end
+    end
+
+    def assert wme
+      @next_cascade ||= []
+      @next_cascade << [:assert, wme]
+      if @current_cascade.nil?
+        @current_cascade = @next_cascade
+        @next_cascade = nil
+        process_cascade
+      end
+    end
+
+    def retract wme, options = { }
+      if wme.is_a? Array
+        wme = WME.new(*wme)
+      end
+      @next_cascade ||= []
+      @next_cascade << [:retract, wme, options]
+      if @current_cascade.nil?
+        @current_cascade = @next_cascade
+        @next_cascade = nil
+        process_cascade
+      end
+    end
+
+    def process_cascade
+      while @current_cascade
+        @current_cascade.each do |(operation, wme, options)|
+          case operation
+          when :assert
+            wme.overlay = self
+            rete.real_assert(wme)
+          when :retract
+            rete.real_retract(wme, options)
+            wme.overlay = nil
+          end
+        end
+        @current_cascade = @next_cascade
+        @next_cascade = nil
+      end
+    end
+
+    def highest(other)
+      return self if self == other
+      return self if other.nil?
+      return self if ancestor?(other)
+      return other if other.ancestor?(self)
+      nil # unrelated lineages
+    end
+
+    # TODO: this is inconsistent.
+    # A WME retracted in-flight will be visible in active enumerators
+    # but a token will not.
+    # But this is how it works.
+
+    def wmes(alpha)
+      DuplicatingEnumerator.new(raw_wmes(alpha))
+    end
+
+    def tokens(beta)
+      DeleteSafeEnumerator.new(raw_tokens(beta))
+    end
+
+    def add_wme(wme, alpha)
+      wmes = raw_wmes(alpha)
+      wmes << wme unless wmes.include?(wme)
+    end
+
+    def remove_wme(wme, alpha)
+      raw_wmes(alpha).delete(wme)
+    end
+
+    def add_token(token, beta)
+      tokens = raw_tokens(beta)
+      tokens << token unless tokens.include?(token)
+    end
+
+    def remove_token(token, beta)
+      raw_tokens(beta).delete(token)
+    end
+
+    def raw_wmes(alpha)
+      @raw_wmes[alpha.object_id]
+    end
+
+    def raw_tokens(beta)
+      @raw_tokens[beta.object_id]
+    end
+  end
+end

data/lib/wongi-engine/dsl.rb

@@ -0,0 +1,132 @@
+module Wongi::Engine
+  module DSL
+    extend self
+
+    def ruleset name = nil, &definition
+      rs = Ruleset.new
+      if ! name.nil?
+        rs.name name
+      end
+      rs.instance_eval &definition if block_given?
+      rs
+    end
+
+    def rule name = nil, &definition
+      r = Rule.new name
+      r.instance_eval &definition
+      r
+    end
+
+    def query name, &definition
+      q = Query.new name
+      q.instance_eval &definition
+      q
+    end
+
+    def dsl &definition
+      Builder.new.build &definition
+    end
+  end
+
+end
+
+require 'wongi-engine/dsl/generated'
+require 'wongi-engine/dsl/builder'
+require 'wongi-engine/dsl/clause/generic'
+require 'wongi-engine/dsl/clause/fact'
+require 'wongi-engine/dsl/clause/assign'
+require 'wongi-engine/dsl/clause/gen'
+require 'wongi-engine/dsl/action/base'
+require 'wongi-engine/dsl/rule'
+require 'wongi-engine/dsl/ncc_subrule'
+require 'wongi-engine/dsl/any_rule'
+require 'wongi-engine/dsl/query'
+require 'wongi-engine/dsl/assuming'
+require 'wongi-engine/dsl/action/simple_action'
+require 'wongi-engine/dsl/action/statement_generator'
+require 'wongi-engine/dsl/action/simple_collector'
+require 'wongi-engine/dsl/action/trace_action'
+require 'wongi-engine/dsl/action/error_generator'
+
+module Wongi::Engine::DSL
+  dsl {
+    section :forall
+
+    clause :has, :fact
+    accept Clause::Has
+
+    clause :missing, :neg
+    accept Clause::Neg
+
+    clause :none, :ncc
+    accept NccSubrule
+
+    clause :any
+    accept AnyRule
+
+    clause :maybe, :optional
+    accept Clause::Opt
+
+    clause :same, :eq, :equal
+    accept Wongi::Engine::EqualityTest
+
+    clause :diff, :ne
+    accept Wongi::Engine::InequalityTest
+
+    clause :less
+    accept Wongi::Engine::LessThanTest
+
+    clause :greater
+    accept Wongi::Engine::GreaterThanTest
+
+    clause :assert, :dynamic
+    accept Wongi::Engine::AssertingTest
+
+    clause :assign, :introduce
+    accept Clause::Assign
+
+    clause :asserted, :added
+    body { |s, p, o|
+      has s, p, o, time: 0
+      missing s, p, o, time: -1
+    }
+
+    clause :retracted, :removed
+    body { |s, p, o|
+      has s, p, o, time: -1
+      missing s, p, o, time: 0
+    }
+
+    clause :kept, :still_has
+    body { |s, p, o|
+      has s, p, o, time: -1
+      has s, p, o, time: 0
+    }
+
+    clause :kept_missing, :still_missing
+    body { |s, p, o|
+      missing s, p, o, time: -1
+      missing s, p, o, time: 0
+    }
+
+    clause :assuming
+    accept Wongi::Engine::AssumingClause
+
+    section :make
+
+    clause :gen
+    accept Clause::Gen
+
+    clause :trace
+    action Action::TraceAction
+
+    clause :error
+    action Action::ErrorGenerator
+
+    clause :collect
+    action Action::SimpleCollector
+
+    clause :action
+    action Action::SimpleAction
+  }
+end

data/lib/wongi-engine/dsl/action/base.rb

@@ -0,0 +1,11 @@
+module Wongi::Engine
+  module DSL::Action
+    class Base
+      include CoreExt
+      attr_accessor :production
+      attr_accessor :rule
+      attr_accessor :name
+      attr_accessor :rete
+    end
+  end
+end

data/lib/wongi-engine/dsl/action/error_generator.rb

@@ -0,0 +1,31 @@
+module Wongi::Engine
+  module DSL::Action
+    class ErrorGenerator < Base
+
+      def initialize message = nil, &messenger
+        @message, @messenger = message, messenger
+      end
+
+      def rete=(*)
+        super
+        rete.add_collector self, :error
+      end
+
+      def errors
+        production.tokens.map do |token|
+          message = if @messenger
+            @messenger.call token.assignments
+          else
+            @message
+          end
+          ReteError.new token, message, literate?
+        end
+      end
+
+      def literate?
+        not @messenger.nil?
+      end
+
+    end
+  end
+end

data/lib/wongi-engine/dsl/action/simple_action.rb

@@ -0,0 +1,60 @@
+module Wongi::Engine
+  module DSL::Action
+    class SimpleAction < Base
+      def initialize action = nil, *args, &block
+        @args = args
+        case action
+        when Class
+          @action = @deaction = @reaction = action.new *args, &block
+        when Hash
+          @action   = instance_or_proc action[:activate]
+          @deaction = instance_or_proc action[:deactivate]
+          @reaction = instance_or_proc action[:reactivate]
+        end
+        @action ||= block
+      end
+
+      def execute token
+        return unless @action
+        if @action.is_a?( Proc ) || @action.respond_to?( :to_proc )
+          rete.instance_exec token, &@action
+        elsif @action.respond_to? :call
+          @action.call token
+        elsif @action.respond_to? :execute
+          @action.execute token
+        end
+      end
+
+      def deexecute token
+        return unless @deaction
+        if @deaction.is_a?( Proc ) || @deaction.respond_to?( :to_proc )
+          rete.instance_exec token, &@deaction
+        elsif @deaction.respond_to? :call
+          @deaction.call token
+        elsif @deaction.respond_to? :deexecute
+          @deaction.execute token
+        end
+      end
+
+      def reexecute token, newtoken
+        return unless @reaction
+        if @reaction.is_a?( Proc ) || @reaction.respond_to?( :to_proc )
+          rete.instance_exec token, newtoken, &@reaction
+        elsif @reaction.respond_to? :call
+          @reaction.call token, newtoken
+        elsif @reaction.respond_to? :reexecute
+          @reaction.execute token, newtoken
+        end
+      end
+
+      def instance_or_proc thing
+        case thing
+        when Class
+          thing.new
+        when Proc
+          thing
+        end
+      end
+    end
+  end
+end

data/lib/wongi-engine/dsl/action/simple_collector.rb

@@ -0,0 +1,52 @@
+module Wongi::Engine
+  module DSL::Action
+    class SimpleCollector < Base
+
+      def self.collector
+        Class.new self
+      end
+
+      def initialize variable, name = nil
+        @variable = variable
+        @name = name if name
+        #(class << self; self; end).instance_eval do
+            #        define_method method do
+            #          collect variable
+            #        end
+        #    alias_method method, :default_collect
+        #  end
+      end
+
+      def default_collect
+        collect @variable
+      end
+
+      def name= n
+        @name = n unless @name
+      end
+
+      def rete= rete
+        rete.add_collector self, name
+      end
+
+      def collect var
+        production.tokens.map { |token| token[var] }
+      end
+
+    end
+
+    class GenericCollectClause
+
+      def initialize name, variable
+
+      end
+
+      def import_into rete
+        collector = SimpleCollector.new @variable
+
+      end
+
+    end
+
+  end
+end