wongi-engine 0.0.1

data/lib/wongi-engine/beta/join_node.rb

@@ -0,0 +1,127 @@
+module Wongi
+  module Engine
+
+    class BetaTest
+
+      attr_reader :field
+      attr_reader :variable
+
+      def initialize field, variable
+        @field, @variable = field, variable
+      end
+
+      def matches? token, wme
+        assignment = token[ self.variable ]
+        field = wme.send( self.field )
+        #field.nil? ||
+        assignment && field == assignment
+      end
+
+      def equivalent? other
+        other.field == self.field && other.variable == self.variable
+      end
+
+    end
+
+    class JoinNode < BetaNode
+
+      attr_accessor :alpha
+      attr_reader :tests
+      attr_reader :assignment_pattern
+
+      def initialize parent, tests, assignment
+        super(parent)
+        @tests = tests
+        @assignment_pattern = assignment
+      end
+
+      def equivalent? alpha, tests, assignment_pattern
+        return false unless self.alpha == alpha
+        return false unless self.assignment_pattern == assignment_pattern
+        return false unless (self.tests.empty? && tests.empty?) || self.tests.all? { |my_test|
+          tests.any? { |new_test|
+            my_test.equivalent? new_test
+          }
+        }
+        true
+      end
+
+      def alpha= a
+        @alpha = a
+        # puts "\talpha = #{alpha}"
+      end
+
+      def right_activate wme
+        ws = '  ' * depth
+        # puts "#{ws}JOIN #{@id} right-activated with #{wme}"
+        collected = collect_assignments( wme )
+        # puts "PARENT HAS #{parent.tokens.length} TOKENS"
+        self.parent.tokens.each do |token|
+          # puts "#{ws}matching with token"
+          if matches?( token, wme )
+            # puts "#{ws}JOIN RIGHT-MATCHED, PROPAGATING"
+            propagate_activation token, wme, collected
+          end
+        end
+      end
+
+      def left_activate token
+        ws = '  ' * depth
+        self.alpha.wmes.uniq.each do |wme|
+          if matches?( token, wme )
+            propagate_activation token, wme, collect_assignments( wme )
+          end
+        end
+      end
+
+      def self.compile condition, earlier, parameters
+        tests = []
+        assignment = Template.new
+        [:subject, :predicate, :object].each do |field|
+          member = condition.send field
+          if Template.variable?( member )
+
+            contains = parameters.include? member
+            if earlier.any? do |ec|
+                ! ec.kind_of?( NegTemplate ) and ec.contains?( member )
+              end
+              contains = true
+            end
+
+            if contains
+              tests << BetaTest.new( field, member )
+            else
+              method = (field.to_s + "=").to_sym
+              assignment.send method, member
+            end
+
+          end
+        end
+        return tests, assignment
+      end
+
+      protected
+
+      def matches? token, wme
+        @tests.each do |test|
+          return false unless test.matches?( token, wme )
+        end
+        true
+      end
+
+      def collect_assignments wme
+        assignments = {}
+        return assignments if self.assignment_pattern.nil?
+        # puts "more assignments"
+        [:subject, :predicate, :object].each do |field|
+          if self.assignment_pattern.send(field)
+            #puts "#{self.assignment_pattern.send(field)} = #{wme.send(field)}"
+            assignments[ self.assignment_pattern.send(field) ] = wme.send(field)
+          end
+        end
+        assignments
+      end
+
+    end
+  end
+end

data/lib/wongi-engine/beta/ncc_node.rb

@@ -0,0 +1,46 @@
+module Wongi
+  module Engine
+    class NccSet
+
+      attr_reader :children
+      def initialize conditions
+        @children = conditions
+      end
+
+      def compile context
+        context.node = context.node.beta_memory.ncc_node( self, context.earlier, context.parameters, false )
+        context.earlier << self
+        context
+      end
+
+    end
+
+    class NccNode < BetaNode
+
+      attr_reader :tokens
+      attr_accessor :partner
+
+      def initialize parent
+        super
+        @tokens = []
+      end
+
+      #  def left_activate token, wme, assignments
+      #    t = Token.new token, wme, assignments
+      #    t.node = self
+      def left_activate token, wme = nil, assignments = { } # => FIXME: left_activate has different signatures for storing and non-storing nodes...
+        t = Token.new token, nil, {}
+        tokens << t
+        partner.tokens.each do |ncc_token|
+          t.ncc_results << ncc_token
+          ncc_token.owner = t
+        end
+        if t.ncc_results.empty?
+          children.each do |child|
+            child.left_activate t, nil, {}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wongi-engine/beta/ncc_partner.rb

@@ -0,0 +1,43 @@
+module Wongi
+  module Engine
+    class NccPartner < BetaNode
+
+      attr_reader :tokens
+      #  attr_accessor :conjuncts
+      attr_accessor :ncc
+      attr_accessor :divergent
+
+      def initialize parent
+        super
+        #    @conjuncts = 0
+        @tokens = []
+      end
+
+      def left_activate token
+        t = Token.new token, nil, {}
+        t.node = self
+        #    owners_t = t
+        #  #  owners_w = t.wme
+        #    conjuncts.times do
+        #  #    owners_w = owners_t.wme
+        #      owners_t = owners_t.parent
+        #    end
+        owner = nil
+        ncc.tokens.each do |ncc_token|
+          # if ncc_token.parent == owners_t
+          if ncc_token.parent.node == divergent
+            owner = ncc_token
+            break
+          end
+        end
+        if owner
+          owner.ncc_results << t
+          t.owner = owner
+          owner.delete_children
+        else
+          tokens << t
+        end
+      end
+    end
+  end
+end

data/lib/wongi-engine/beta/neg_node.rb

@@ -0,0 +1,58 @@
+module Wongi
+  module Engine
+
+    NegJoinResult = Struct.new :owner, :wme
+
+    class NegNode < BetaNode
+
+      attr_reader :tokens, :alpha, :tests
+
+      def initialize parent, tests, alpha
+        super(parent)
+        @tests, @alpha = tests, alpha
+        @tokens = []
+      end
+
+      def right_activate wme
+        self.tokens.each do |token|
+          if matches?( token, wme )
+            token.delete_children if token.neg_join_results.empty?
+            make_join_result(token, wme)
+          end
+        end
+      end
+
+      def left_activate token, newwme, assignments
+        t = Token.new token, newwme, assignments
+        t.node = self
+        self.tokens << t
+        @alpha.wmes.each do |wme|
+          if matches?( t, wme )
+            make_join_result(t, wme)
+          end
+        end
+        if t.neg_join_results.empty?
+          self.children.each do |child|
+            child.left_activate t, nil, {}
+          end
+        end
+      end
+
+      protected
+
+      def matches? token, wme
+        puts "matching #{wme} against #{token}" if debug?
+        @tests.each do |test|
+          return false unless test.matches?( token, wme )
+        end
+        true
+      end
+
+      def make_join_result token, wme
+        njr = NegJoinResult.new token, wme
+        token.neg_join_results << njr
+        wme.neg_join_results << njr
+      end
+    end
+  end
+end

data/lib/wongi-engine/beta/optional_node.rb

@@ -0,0 +1,43 @@
+module Wongi
+  module Engine
+
+    OptionalJoinResult = Struct.new :owner, :wme
+
+    class OptionalNode < JoinNode
+
+      def right_activate wme
+        parent.tokens.each do |token|
+          if matches? token, wme
+            if token.has_optional?
+              token.has_optional = false
+              token.delete_children
+            end
+            propagate_activation(token, wme, collect_assignments(wme))
+            jr = OptionalJoinResult.new token, wme
+            token.opt_join_results << jr
+            wme.opt_join_results << jr
+          end
+        end
+      end
+
+      def left_activate token
+        match = false
+        alpha.wmes.each do |wme|
+          assignments = collect_assignments(wme)
+          if matches? token, wme
+            match = true
+            propagate_activation(token, wme, assignments)
+            jr = OptionalJoinResult.new token, wme
+            token.opt_join_results << jr
+            wme.opt_join_results << jr
+          end
+        end
+        unless match
+          token.has_optional = true
+          propagate_activation(token, nil, {})
+        end
+      end
+
+    end
+  end
+end

data/lib/wongi-engine/beta/or_node.rb

@@ -0,0 +1,76 @@
+module Wongi
+  module Engine
+    class AnySet
+
+      attr_reader :variants
+      def initialize variants
+        @variants = variants
+      end
+
+      def compile context
+        added = []
+        branches = variants.map do |variant|
+          ctx = BetaNode::CompilationContext.new context.node, context.rete, context.earlier.dup, context.parameters, context.alpha_deaf
+          members = context.earlier.size
+          variant.compile ctx
+          added += ctx.earlier[ (members - ctx.earlier.size) .. -1 ]  # newly added elements
+          ctx.node
+        end
+        context.earlier += added
+        context.node = OrNode.new( branches )
+        context.node.update_above
+        context
+      end
+
+    end
+
+    class VariantSet
+
+      attr_reader :children
+      def initialize conditions
+        @children = conditions
+      end
+
+      def compile context
+        context.node = context.node.beta_memory.network( children, context.earlier, context.parameters, false )
+        context.earlier << self
+        context
+      end
+
+    end
+
+    class OrNode < BetaMemory
+
+      attr_reader :parents
+      attr_reader :rete
+
+      def initialize parents
+        super nil
+        @parents = parents
+        parents.each do |parent|
+          parent.children << self
+        end
+        retes = parents.map( &:rete ).uniq
+        raise "Cannot combine variants from several Retes" if retes.size > 1
+        @rete = retes.first
+      end
+
+      def ident
+        ids = parents.map( &:id ).join ", "
+        "<R> #{self.class} #{id}, parents #{ids}"
+      end
+
+
+      def depth
+        parents.map( &:depth ).max + 1
+      end
+
+      def update_above
+        parents.each do |parent|
+          update_from parent
+        end
+      end
+
+    end
+  end
+end

data/lib/wongi-engine/beta/production_node.rb

@@ -0,0 +1,31 @@
+module Wongi
+  module Engine
+    
+    class ProductionNode < BetaMemory
+
+      attr_accessor :tracer
+
+      def initialize parent, actions
+        super(parent)
+        @actions = actions
+        @actions.each { |action| action.production = self }
+      end
+
+      def left_activate token, wme, assignments
+        super
+        @actions.each do |action|
+          # @tokens.each do |t|
+          #  action.execute t
+          # end
+          action.execute last_token if action.respond_to? :execute
+        end
+      end
+
+      # => TODO: investigate
+      def deexecute token
+
+      end
+    end
+
+  end
+end

data/lib/wongi-engine/core_ext.rb

@@ -0,0 +1,57 @@
+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
+          getname = "#{name}?".to_sym
+          setname = "#{name}=".to_sym
+          exclname = "#{name}!".to_sym
+          noexclname = "no_#{name}!".to_sym
+
+          define_method getname 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
+
+    end
+
+    def self.included mod
+      mod.extend ClassMethods
+    end
+
+  end
+
+end