khammurabi 0.2

data/khammurabi-0.2/lib/nist/khammurabi/ConstantObjectOperation.rb

@@ -0,0 +1,92 @@
+module MK
+
+  require 'stringio'
+  require 'nist/khammurabi/ObjectOperation'
+  require 'nist/khammurabi/ValueTestSuite'
+	require 'nist/khammurabi/ArrayAddon'
+
+  # Tests an object against a fixed value. Differs from VariableObjectOperation
+  # in that VariableObjectOepration tests equality of two (variable) objects.
+  class ConstantObjectOperation < ObjectOperation
+
+    def initialize
+      super
+      self
+    end
+
+    def ConstantObjectOperation.init( vs, name, testMe )
+      coo = ConstantObjectOperation.new
+			vs = [ vs ] if vs.class != Array
+      coo.valueTests = vs
+      coo.name = name
+      coo.testMe = testMe
+      coo
+    end
+    
+    # Clones the object
+    def clone
+      cologne = ConstantObjectOperation.new
+			self.valueTests.each do |valueTest|
+				next if valueTest == nil
+				cologne.valueTests.push( valueTest.clone )
+			end
+      cologne.name   = self.name.clone
+      cologne.testMe = self.testMe
+      cologne
+    end
+
+		def templateTestValue
+			retval = Array.new
+			self.valueTests.each do |vt|
+				vt == nil and next
+				retval.push( vt.testValue )
+			end
+			retval
+		end
+
+    # Tests equality based on equality of valueTest
+    def ==( otherObject )
+      retval = super 
+      retval = ( retval and ( self.class == otherObject.class ) )
+			retval = ( retval and ( self.templateTestValue === otherObject.templateTestValue ) )
+			retval = ( retval and ( self.valueTests === otherObject.valueTests ) )
+			retval
+    end
+
+    # The brains of the class. This method tests object using templateTestValue and valueTest.
+    # For example, let valueTest = EqualityTest and objectTestValue = 5.
+    # Then if object = 3, match would perform the operation:
+    # 3 == 5
+    # Hence, match would return false. ValueTest can be a myraid of class types, see
+    # above for reference classes
+    def match( object )
+			super
+			
+      return true if self.testMe == false
+      variables = object.instance_variables
+      return false if !variables.include?( self.name )
+      objectTestValue = object.instance_eval( self.name )
+			#print "ObjectTestValue: #{objectTestValue} my name: #{self.name}\n"
+			self.error( "valueTests is nil or has size 0 so I can't perform this test" ) if self.valueTests == nil or self.valueTests.size == 0
+			retval = true
+			self.valueTests.each do |valueTest|
+				#print " valueTest.testValue: #{valueTest.testValue} and ID: #{valueTest.object_id}\n"
+				self.notice( "Looking at valueTest: #{valueTest}" )
+				retval = valueTest.match( objectTestValue )
+				break if retval == false
+      end
+			retval
+    end
+
+    # Prints object data onto stream
+    def printOn( stream )
+      stream << "<ConstantObjectOperation> <templateTestValue: #{self.templateTestValue}>   "
+      super
+      stream << " </ConstantObjectOperation>"
+      stream
+    end
+
+    def to_s; printOn( StringIO.new ).string; end
+
+  end
+end

data/khammurabi-0.2/lib/nist/khammurabi/ConstantTestNode.rb

@@ -0,0 +1,59 @@
+module MK
+
+  require 'nist/khammurabi/GraphNode'
+  require 'nist/khammurabi/TestNode'
+  require 'nist/khammurabi/ObjectOperation'
+  require 'nist/khammurabi/ObjectGraphWrapper'
+
+  # This class uses a ConstantObjectOperation to perform tests on 
+  # incoming Tokens to determine eligibility of passing
+  class ConstantTestNode < TestNode
+    
+    def initialize
+      super
+      self.objectOperationTest = nil
+      self
+    end
+    
+    def ConstantTestNode.init( name, objectOperationTest, engine, parent )
+      testNode = ConstantTestNode.new
+      testNode.name = name
+      testNode.objectOperationTest = objectOperationTest
+      testNode.engine = engine
+      testNode.parents = [ parent ]
+      testNode
+    end
+    
+    # The heart of the class. Execute iterates through each of the object's tokens,
+    # and makes objectOperationTest perform its test on it. If this test
+    # returns false, registerRejectedToken( token ) is called. If it returns true,
+    # registerPassedToken( token ) is called
+    def execute
+			super
+			return if ( !self.tokens or self.tokens.size == 0 )
+			!self.shouldExecute and return
+			
+			self.notice( "Executing, I have #{self.tokens.size} tokens" )
+      
+			# for each token, perform all the tests on it
+      self.tokens.each do |token|
+			token.objectGraphWrappers.each do |objectGraphWrapper|
+				object = objectGraphWrapper.object
+				self.notice( "My objectOperationTest name: #{self.objectOperationTest.name}" ) # size: #{self.objectOperationTest.size}" )
+				if !self.objectOperationTest.match( object )
+					self.notice( "Matching failed" )
+					#print "broadcasting token failed from class: #{token.class}\n"
+					token.broadcast( :tokenFailed, token )
+					self.registerRejectedToken( token )
+				else
+					self.notice( "Matching passed" )
+					objectGraphWrapper.operationsPerformed[ self.objectOperationTest.name ] = self.objectOperationTest
+					self.registerPassedToken( token )
+				end
+			end
+	 end
+   self.manageTokens
+  end
+  
+ end
+end

data/khammurabi-0.2/lib/nist/khammurabi/Engine.rb

@@ -0,0 +1,454 @@
+module MK
+
+	require 'nist/khammurabi/Cluster'
+	require 'nist/khammurabi/Message'
+  require 'nist/khammurabi/RootNode'
+  require 'nist/khammurabi/TestNode'
+  require 'nist/khammurabi/GraphNode'
+  require 'nist/khammurabi/ArrayAddon'
+	require 'nist/khammurabi/FixnumAddon'
+  require 'nist/khammurabi/ObjectAddon'
+	require 'nist/khammurabi/ClusterManager'
+  require 'nist/khammurabi/TestIDRegistrar'
+  require 'nist/khammurabi/GraphNodeJoiner'
+  require 'nist/khammurabi/ConstantTestNode'
+  require 'nist/khammurabi/VariableTestNode'
+  require 'nist/khammurabi/ObjectDescription'
+	require 'nist/khammurabi/TokenClustermanager'
+	require 'nist/khammurabi/UniqueTokenAssurerNode'
+  require 'nist/khammurabi/InstantiatorNode'
+  require 'nist/khammurabi/ConstantObjectOperation'
+  require 'nist/khammurabi/VariableObjectOperation'
+  require 'nist/khammurabi/VariableTestNodeExecutor'
+  require 'nist/khammurabi/MultiChildrenSelectorNode'
+
+  # The brains of the rete algorithm. This creates a graph structure
+  # composed of ConstantTestNode's, VariableTestNode's, GraphNodeJoiner's 
+  # and InstantiatorNode's.
+  # Class Engine (and the GraphNode tree it produces via <i>compile</i>
+  # utilizes a TokenRegistrar class which tags tokens passed into it. 
+  class Engine 
+    
+    attr :root, true         # RootNode
+    attr :objectProductions, true # Array( ObjectProduction )
+    attr :leaves, true # Hash( ObjectProduction => InstantiatorNode )
+    attr :workingMemoryElements, true # Array( Token )
+    attr :clusterManager, true # ClusterManager
+    attr :registeredTokens, true # Hash( Token => Boolean )
+    attr :debug, true  # Boolean
+		attr :messages, true # Array
+		attr :variableTestNodeExecutors, true # a query Array
+		attr :rootNodes, true # RootNodes (a query Array)
+		attr :processPermissions, true # Hash( Boolean )
+		
+    def initialize
+      self.root = nil
+      self.objectProductions = Array.new
+      self.leaves = Hash.new
+      self.workingMemoryElements = Array.new
+      self.registeredTokens = Hash.new { false }
+			self.clusterManager = TokenClusterManager.new
+      self.debug = false
+			self.messages = Array.new
+			self.variableTestNodeExecutors = Hash.new # Array.new
+			self.rootNodes = Hash.new #Array.new
+			self.processPermissions = Hash.new { true }
+			# variableLevel of 0 is reserved for the Cluster
+			@variableLevel = 1
+    end
+
+    # Object is wrapped in an objectGraphWrapper which is then again wrapped in
+    # a Token. objectGraphWrapper is a container class which helps track tests
+    # done on the object (tests are performed by ObjectOperation's). Token is a 
+    # container class as well, and has various tracking abilities (see above for
+    # references to both classes)
+    def addObject( object )
+			# Is this object a message?
+			if object.kind_of?( MK::Message )
+				self.messages.push( object )
+			else 
+				#self.notice( "Adding object with id: #{object.object_id}" )
+				objectGraphWrapper = ObjectGraphWrapper.init( object )
+				token = Token.init( objectGraphWrapper, "+", Time.now )
+				token.beginBroadcastingTo( self )
+				#self.clusterManager.addObjectToCluster( token, self.clusterManager.nilCluster )
+				cluster = self.clusterManager.createCluster( token, TokenCluster )
+				cluster.debug = self.debug
+				self.notice( "Made a token with cluster ID: #{token.cluster.clusterID}" )
+				self.addWorkingMemoryElement( token )
+				self.processWorkingMemoryElements
+			end
+    end
+    
+    # This adds element to workingMemoryElements
+    def addWorkingMemoryElement( element )
+      self.error( "Trying to add a working memory element which isn't a token.. it's a: #{element.class}" ) if element.class != Token
+      self.workingMemoryElements.push( element )
+    end
+    
+		# Deletes an element from the working memory -- uses ==
+		def deleteTokensFromWorkingMemoryWithObject( element )
+			toDelete = Array.new
+			self.workingMemoryElements.each do |wme|
+				wme.objectGraphWrappers.each do |ogw|
+					if ogw.object == element
+						toDelete.push( wme )
+						break
+					end
+				end
+			end
+			toDelete.each do |tod|
+				self.workingMemoryElements.reject! { |wme| wme.equal?( tod ) }
+			end
+		end
+
+		# Deletes an element from the working memory -- uses ==
+		def deleteFromWorkingMemory( element )
+			self.workingMemoryElements.reject! { |wme| wme == element }
+		end
+
+		def deleteFromWorkingMemoryUsingEqual?( element )
+			self.workingMemoryElements.reject! { |wme| wme.equal?( element ) }
+		end
+
+		def workingMemoryElementWasChanged( token )
+			return if !self.workingMemoryElements.includeID?( token )
+			self.processPermissions[ token ] = true
+			self.processWorkingMemoryElement( token )
+		end
+
+    # This (private) method iterates through workingMemoryElements and adds each
+    # element to root. Shouldn't be called manually	
+    def processWorkingMemoryElements
+			self.workingMemoryElements.each do |element| 
+				if self.okToProcessWorkingMemoryElement?( element )
+					self.processWorkingMemoryElement( element )
+				end
+			end
+		end
+			
+		def processWorkingMemoryElement( element )
+			self.error( "Trying to process a working memory element which isn't a token.. it's a: #{element.class}" ) if !element.kind_of?( Token )
+			#self.workingMemoryElements.delete( element )
+			self.notice( "ProcessWorkingMemoryElements root id: #{self.root.object_id}" ) 
+			self.root.addToken( element, self )
+    end
+
+		def okToProcessWorkingMemoryElement?( element )
+			self.processPermissions[ element ]
+		end
+
+		def tokenFailed( vars )
+			token = vars.first
+			self.processPermissions[ token ] = false
+		end
+
+    # An accessor for the leaf which corresponds to objectProduction 
+    def leaf( objectProduction ); self.leaves[ objectProduction ]; end
+    
+    # Returns "Engine"
+    def name; "Engine"; end
+ 
+    # Compiles objectProductions into a tree of GraphNode's. 
+    # The root of this tree is held in root. The algorithm
+    # works as follows:
+    # First there is RootNode. Then for each objectProduction in 
+    #  objectProductions, a subtree (attached to the RooteNode) with it's own RootNode is
+    #  created. Each node of this subtree is composed of either a ConstantTestNode
+    #  or a VariableTestNode. The ConstantTestNode's are pushed to the top of the
+    #  subtree, and the VariableTestNode's are pushed to the bottom
+    # If there is more than one objectProduction, there will exist a bunch of 
+    #  hanging leaves at the end of the compile. These will be 'joined' together --
+    #  via a GraphNodeJoiner -- into a single leaf. Onto this leaf will be attached
+    #  an ObjectInstantitorNode. This InstantiatorNode will, when executed,
+    #  insert a predetermined object into the workingMemoryElements
+    # See above for more documentation
+    def compile
+      self.root = RootNode.init( "0", self )
+      self.root.name = 0
+			self.root.debug = self.debug
+      name = 1
+			variableTestNodeExecutorName = 0
+			largestVariableTestNodeLevel = 0
+			variableTestNodeLevels = Hash.new { -1 }
+			
+      # if more than one description is the same, find them so that we cna 
+      # use an arbitrator for their input
+      matchedDescriptionsArray = findMatchedDescriptions
+			if matchedDescriptionsArray.first == true
+				errorStr = "Failed to parse input. Have #{matchedDescriptionsArray.second.values.first.size} similar (and thus ambiguous) inputs. They are:\n "
+				matchedDescriptionsArray.second.each_pair do |objectProduction, matchedDescriptions|
+					errorStr = "#{errorStr}\tFor object production: #{objectProduction}:"
+					matchedDescriptions.each do |md|
+						errorStr = "#{errorStr}\t\t#{md}\n"
+					end
+				end
+				self.error( errorStr )
+			end
+			
+      self.objectProductions.each do |objectProduction|
+				vtnes = Hash.new { nil } # maps variable name to executor
+      	graphLeaves = Array.new
+
+				# constantCount is used to sort the testNodes so that the testNodes with the most constant tests in them get used first
+				# (more constant test nodes = a more restrictive test)
+				constantCount = Hash.new
+				constantTestNodesMap = Hash.new
+				variableTestNodesMap = Hash.new
+				testNodes = Hash.new
+
+				self.rootNodes[ objectProduction ] = Array.new
+				productionRoot = MultiChildrenSelectorNode.init( "mcsn", self, self.debug ) # RootNode.init( name, self, self.debug )
+				self.rootNodes[ objectProduction ].push( productionRoot )
+
+				name = name + 1
+				self.root.makeChildConnection( productionRoot )
+
+				bottom = nil
+				# setup the constant and variable test nodes
+				objectProduction.objectDescriptions.each do |objectDescription|
+					constantTestNodesMap[ objectDescription.object_id ] = Array.new
+					variableTestNodesMap[ objectDescription.object_id ] = Array.new
+					bottom = productionRoot
+
+					graphNodes = Array.new
+					objectDescription.objectOperations.each_pair do |variableName, objectOperation|
+						testNodes[ objectDescription.object_id ] = Array.new if testNodes[ objectDescription.object_id ] == nil
+						constantCount[ objectDescription.object_id ] = -1 if constantCount[ objectDescription.object_id ] == nil
+						objectOperation.debug = self.debug
+						if objectOperation.class == VariableObjectOperation
+							vname = objectOperation.variableName # This is like <X> or <Y> in ops5
+							# This is stored in a hash to avoid creating more than one VTNE per vname
+							vtnes[ vname ] = VariableTestNodeExecutor.init( self ) if vtnes[ vname ] == nil
+							vtnes[ vname ].name = "VTNE #{variableTestNodeExecutorName}"
+							variableTestNodeExecutorName = variableTestNodeExecutorName + 1
+							vtnes[ vname ].debug = self.debug
+							
+							if variableTestNodeLevels[ vname ] == -1
+								variableTestNodeLevels[ vname ] = largestVariableTestNodeLevel
+								largestVariableTestNodeLevel = largestVariableTestNodeLevel + 1
+							end
+							vlevel = variableTestNodeLevels[ vname ]
+							#print "level: #{vlevel}\n"
+							self.error( "Level must be >= 0, it is: #{vlevel}" ) if vlevel < 0
+							variableTestNode = VariableTestNode.init( name, objectOperation, vtnes[ vname ], self, nil, variableTestNodeLevels[ vname ] )
+							
+							vtnes[ vname ].addVariableTestNode( variableTestNode )
+							variableTestNode.debug = self.debug
+							variableTestNodesMap[ objectDescription.object_id ].push( variableTestNode )
+						elsif objectOperation.class == ConstantObjectOperation
+							self.notice( "Construction : adding constantObjectOperation of: #{objectOperation}" )
+							constantTestNode = ConstantTestNode.init( name, objectOperation, self, nil )
+							constantTestNode.debug = self.debug
+							constantTestNodesMap[ objectDescription.object_id ].push( constantTestNode ) # , testNodes[ objectDescription.object_id ] ].flatten 
+							constantCount[ objectDescription.object_id ] = constantCount[ objectDescription.object_id ] + 1
+						end
+						name = name + 1
+					end # objectDescription.objectOperations.each_pair do
+				end # objectProduction.objectDescriptions.each do |objectDescription|
+				
+				
+				objectProduction.objectDescriptions.each do |objectDescription|
+					testNodes[ objectDescription.object_id ] = Array.new
+					variableTestNodesMap[ objectDescription.object_id ].sort! { |o1,o2| o1.level <=> o2.level }
+					testNodes[ objectDescription.object_id ].concat( constantTestNodesMap[ objectDescription.object_id ] )
+					testNodes[ objectDescription.object_id ].concat( variableTestNodesMap[ objectDescription.object_id ] )
+				end
+				
+				# sort the graphNode subtrees by number of constants they have
+				descriptionSort = Array.new
+				testNodes.each_pair do |key,value|
+					# find correct place to put into graphNodes
+					inserted = false
+					descriptionSort.each_index do |index|
+						if constantCount[ key ] > constantCount[ descriptionSort[ index ] ]
+							descriptionSort.insert( index, key )
+							inserted = true
+							break
+						end
+					end
+					descriptionSort.push( key ) if inserted == false
+				end
+
+				# Join the graph nodes for each objectDescription
+				descriptionSort.each do |description|
+					bottom = productionRoot
+					testNodes[ description ].each do |graphNode|
+						bottom.makeChildConnection( graphNode )
+						bottom = graphNode 
+					end
+					graphLeaves.push( bottom )
+				end
+
+				# Join all the leaves together
+				while graphLeaves.size > 1
+					joiner = GraphNodeJoiner.init( name, graphLeaves.first, graphLeaves.second, self )
+					joiner.debug = self.debug
+					name = name + 1
+					graphLeaves.first.setChild( joiner )
+					graphLeaves.second.setChild( joiner )
+					joiner.setParents( [ graphLeaves.first, graphLeaves.second ] )
+					bottom = joiner
+					graphLeaves.shift
+					graphLeaves.shift
+					graphLeaves.unshift( joiner )
+				end
+
+				# Join the leaf to an instantiator
+				instantiatorNode = InstantiatorNode.init( objectProduction, name, self )
+				name = name + 1
+				bottom.makeChildConnection( instantiatorNode )
+				self.leaves[ objectProduction ] = instantiatorNode
+			end # self.objectProductions.each do
+		end # def compile
+			
+    # Marshals the call into root
+    def execute; self.root.execute; end
+
+    # Adds production to objectProductions
+    def addObjectProduction( production )
+      production.engine = self
+      self.objectProductions.push( production )
+    end
+
+    # Returns false if token is already registered.
+    # Otherwise, flags the token as registered and returns true.
+    def registerToken( token )
+      if self.tokenIsRegistered?( token ) # registeredTokens[ token ]
+				self.notice( "Token: #{token.object_id} is already registered, but that's OK" )
+				return false
+			end
+			self.notice( "Token: #{token.object_id} isn't registered" );
+      self.registeredTokens[ token ] = true
+      return true
+    end
+    
+    # Unregisters the token
+    def deRegisterToken( token ); self.registeredTokens[ token ] = false; end
+		def tokenIsRegistered?( token ); self.registeredTokens[ token ]; end
+		
+ 		# A private method that finds objectDescriptions that match using ===
+		def findMatchedDescriptions
+			matchedDescriptions = Hash.new # Maps objectProduction => Array( Array( objectDescription ) ), or maps each object production to 
+																		 # a set of arrays, each of which contain object descriptions that === each other
+			fail = false
+      #print "number of objectProductions: #{self.objectProductions.size}\n"
+		  self.objectProductions.each do |objectProduction|
+				#print "objectProduction's number of object descriptions: #{objectProduction.objectDescriptions.size}\n"
+				matchedDescriptions[ objectProduction ] = Array.new
+				objectProduction.objectDescriptions.each do |objectDescription|
+					# Each objectDescription matches with itself, so put it into a group consisting of itself
+					# Each objectDescription (in this case) acts as a representative of an equivalence relation under ===
+					matchedDescriptions[ objectProduction ].push( [ objectDescription ] )
+				end
+				matchedDescriptions[ objectProduction ].each do |descriptionArray|
+					description = descriptionArray.first
+					matchedDescriptions[ objectProduction ].each do |otherDescriptionArray|
+						otherDescription = otherDescriptionArray.first
+						next if otherDescription.equal?( description )
+						if otherDescription === description and otherDescription != description and otherDescription.constants.size > 0 and description.constants.size > 0
+							print "id: #{otherDescription.object_id} #{description.object_id}\n"
+							fail = true
+							descriptionArray.lossyConcat( otherDescriptionArray )
+							#print "descriptionArray: #{descriptionArray.join( "\n\n" )}\n"
+						end
+					end # md.each do |otherDescriptionArray|
+				end # md.each do |descriptionArray|
+				# md should now be populated with arrays that match
+			end # self.objectProductions.each do |objectProduction|
+			#print "matchedDescriptions: #{matchedDescriptions.keys.join( "\n\n" )}\n"
+			[ fail, matchedDescriptions ]
+		end
+						
+    # Notifies that the token was rejected
+    def tokenWasRejected( token ); self.notice( "Token #{token.object_id} failed: #{token.to_s}" ); end
+    
+    # Notifies that the production was instantiated 
+    def objectProductionWasInstantiated( production ); self.notice( "object production was instantiated: #{production.to_s}" ); end
+
+    # Turns debugging on/off. This effects every node in the graph.
+    def setDebugging( yesno )
+			self.debug = yesno
+			self.setDebuggingHelper( self.root, yesno )
+			self.clusterManager.debug = yesno
+		end
+
+    # A private method used as a helper to setDebugging. Should not be called manually.
+    def setDebuggingHelper( node, yesno )
+			if !node
+				#self.warning( "There is a missing leaf in the graph" );
+				return
+			end
+      node.debug = yesno
+			#if node.class == MultiChildrenArbitratorNode
+			#	children = node.multiChildren
+			#else
+			children = node.children
+			#end
+			
+      children.each { |child| self.setDebuggingHelper( child, yesno ) }
+    end
+    
+		def variableTestNodes; self.nodes.select { |node| node.class == VariableTestNode }; end
+		def constantTestNodes; self.nodes.select { |node| node.class == ConstantTestNode }; end
+		
+		def nodes
+			nodeArray = Array.new
+			nodesHelper( self.root, nodeArray )
+			nodeArray
+		end
+		
+		def nodesHelper( node, array )
+			return if node == nil
+			array.push( node )
+			#if node.class == MultiChildrenArbitratorNode
+			#	children = node.multiChildren
+			#elsif node.kind_of?( GraphNode )
+			children = node.children
+			#else
+			#	self.error( "Not sure what to do with this kind of node: #{node.class}" )
+			#end
+			children.each { |child| nodesHelper( child, array ) }
+		end
+
+		# Private method
+		def recursivelyDeRegisterTokenByID( token, owner )
+			self.notice( "Recursively deleting token #{object_id}'s owners" )
+			token.inheritedIDs.each do |tokenID|
+				self.notice( "Got an inheritedID of #{tokenID}" ) 
+				self.nodes.each do |node|
+					next if node.equal?( owner )
+					node.deRegisterTokenByID( tokenID )
+					#node.deRegisterToken( token )
+				end
+			end
+		end
+		
+		def printTokenIDs
+			self.nodes.each do |node|
+				print "Node #{node.name} has #{node.tokens.size} tokens with IDs:"
+				tokenStr = ""
+				node.tokens.each { |token| tokenStr = "#{tokenStr} #{token.tokenID}" }
+				print "#{tokenStr}\n"
+			end
+		end
+
+		def makeChildConnection( oNode )
+			self.addChild( oNode )
+			oNode.addParent( self )
+		end
+
+		# Delete all tokens in graph whos objectGraphWrapper wraps object. This uses ==
+		def deleteTokensInGraphWithObject( object )
+			ns = self.nodes
+			ns.each do |node|
+				node.tokens.each do |token|
+					if token.objectGraphWrapper.object == object
+						node.deRegisterToken( token )
+					end
+				end
+			end # ns.each do |node|
+		end # def deleteTokensWithObject
+		
+  end
+end