khammurabi 0.2

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

@@ -0,0 +1,32 @@
+module MK
+
+  require 'nist/khammurabi/GraphNode'
+	require 'nist/khammurabi/ArrayAddon'
+	
+  # A GraphNode that has many children and one parent. It just marshalls tokens from parent to each child
+  class RootNode < GraphNode
+
+	  def RootNode.init( name, engine, debug = false )
+      rootNode = RootNode.new
+      rootNode.name = name
+      rootNode.engine = engine
+			rootNode.debug = debug
+      rootNode
+    end
+
+    def initialize
+      super
+      self.maxChildren = -1
+		end
+    
+    # Passes tokens to each child
+    def execute
+			super
+			self.notice( "Execute" )
+			self.registerPassedTokens( self.tokens )
+			self.manageTokens
+		end
+
+  end
+end
+

data/khammurabi-0.2/lib/nist/khammurabi/TODO

@@ -0,0 +1,7 @@
+Add a verification test that makes sure that the 
+Token -> objectGraphWrapper -> object is the type that is needed
+
+I.E. for 'engine + [ Person ..... ]', after the engine is complete and
+compiled and objects are passed into it, make sure that those objects
+are of type Person
+

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

@@ -0,0 +1,63 @@
+module MK
+
+  require 'nist/khammurabi/ObjectAddon'
+
+  # This class is used to register and deregister tokens within an Engine.
+  # Registering/deregistering is used to determine if a Token is part of a 
+  # Token cluster. A Token cluster is two or more disjoint tokens that collectively 
+  # represent a larger, cohesive Token. A cluster is formed when two or more tokens match in
+  # a VariableObjectOperation test. A cluster is broken apart when two or more 
+  # tokens do not pass a VariableObjectOperation test. 
+  class TestIDRegistrar
+    
+    attr_accessor :currentID
+    
+    def initialize
+      self.currentID = 0
+    end
+
+    
+    # If a testID of a Token is -1, it acts as a wildcard that matches with
+    # any other testID (it also means that the Token hasn't been tested yet).
+    # This method returns true if any of the following hold:
+    # #1 testObject1.testID == -1
+    # #2 testObject2.testID == -1
+    # #3 testObject1.testID == testObject2.testID
+    def testIDsMatch?( testObject1, testObject2 )
+      retval = false
+      retval = true if testObject1.testID == -1 or testObject2.testID == -1 or testObject1.testID == testObject2.testID
+      retval
+    end
+
+    # Sets both testID's to -1
+    def deRegisterMatch( testObject1, testObject2 )
+      testObject1.testID = testObject2.testID = -1
+    end
+
+		def deRegisterIfMatched( testObject1, testObject2 )
+			if ( testObject1.testID == testObject2.testID )
+				deRegisterMatch( testObject1, testObject2 )
+			end
+		end
+		
+    # Fails if testObject1 && testObject2's testID's aren't -1 and they aren't the same either
+    # If testObject1 or testObject2 is part of a cluster (then by default the other one isn't part of a cluster)
+    # then join the other testObject into the cluster.
+    # If both aren't part of a clutser, then create a new cluster.
+    # A cluster is signified by its testID
+    def registerMatch( testObject1, testObject2 )
+      # sanity check
+      self.error( "TestIDRegistrar#registerMatch error -- testID's aren't same, and not -1 either  they are: #{testObject1.testID} #{testObject2.testID}\n" ) if testObject1.testID != -1 and testObject2.testID != -1 and testObject1.testID != testObject2.testID
+
+      if testObject1.testID == -1 and testObject2.testID == -1
+	  		testObject1.testID = testObject2.testID = self.currentID
+				self.currentID = self.currentID + 1
+      elsif testObject1.testID != -1 and testObject2.testID == -1
+	  		testObject2.testID = testObject1.testID
+      elsif testObject1.testID == -1 and testObject2.testID != -1
+	  		testObject1.testID = testObject2.testID
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,33 @@
+module MK
+
+  require 'nist/khammurabi/GraphNode'
+  require 'nist/khammurabi/ObjectOperation'
+
+  # An abstract class used as a framework for testing GraphNodes. Subclasses of
+  # this class are used by subclasses of ObjectOperation to perform testing
+  class TestNode < GraphNode
+
+    attr :objectOperationTest, true  # should be set once.. an ObjectOperation
+    attr :testIDMap, true # Hash { int => ObjectGraphWrapper }
+
+    # uses to test incoming Tokens
+    def initialize
+      super
+    end
+    
+    def TestNode.init
+      self.warning( "this is an abstract class and should not be inited by itself" )
+      testNode = TestNode.new
+      testNode
+    end
+    
+		#def debug=( _debug )
+		#	self.debug = _debug
+		#	self.objectOperationTest.debug = _debug
+		#end
+		
+    # Performs <=> on name
+    def <=>( otherNode ); self.objectOperationTest.name <=> otherNode.objectOperationTest.name; end
+    
+  end
+end

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

@@ -0,0 +1,168 @@
+module MK
+
+	require 'stringio'
+  require 'nist/khammurabi/GraphNode'
+  require 'nist/khammurabi/ObjectAddon'
+  require 'nist/khammurabi/ArrayAddon'
+	require 'nist/khammurabi/Hostilities'
+	
+  # This class wraps ObjectGraphWrapper, and adds functionality to it, such as
+  # a GraphNode owner, a creation timeStamp, and some others.
+  # This is the class that gets passed around in the Engine.
+  class Token
+    
+		include Hostilities
+		
+    attr :tag, true # String
+		attr :tokenID, true # Fixnum
+		attr :inheritedIDs, true  # if this token is composed of other tokens
+    attr :timeStamp, true  # Time
+    attr :owner, true # Array( GraphNode )
+		attr :cluster, true # The cluster this belongs to
+		attr :mcan, true    # A possible MultiChildrenArbitratorNode
+		attr :variableTop, true # VariableTestNode 
+														# This is used to skip back to the first VariableTestNode reached
+														# in case the testing doesn't work
+		attr :hostilities, true # tokens that this token can't join with
+		attr :rootNodeWatcher, true # A root node watcher
+		attr :objectGraphWrappers, true #, true  # ObjectGraphWrapper
+		attr :name, true # String representation of the tokenID and the inheritedIDs
+
+		@@tokenIDCount = 0
+
+    def Token.init( objectGraphWrappers, tag, timeStamp, tokenID = -1 )
+      token = Token.new
+      objectGraphWrappers = [ objectGraphWrappers ] if objectGraphWrappers.class != Array
+      objectGraphWrappers.each { |ogw| ogw.token = token }
+      token.objectGraphWrappers = objectGraphWrappers
+      token.tag = tag
+      token.timeStamp = timeStamp
+      token
+    end
+
+    # Concatenates left and right into a new token and returns it.
+    def Token.newFromTwo( left, right ); token = Token[ left, right ]; end
+
+    # A construction method that takes an array of Token's and creates a Token from them 
+    def Token.[]( *tokens )
+      token = Token.new
+			token.tokenID = @@tokenIDCount
+			@@tokenIDCount = @@tokenIDCount + 1
+			nameStr = String.new
+      tokens.each do |t|
+	  		t.objectGraphWrappers.each do |ogw|
+					token.addObjectGraphWrapper( ogw ) if !token.objectGraphWrappers.includeID?( ogw )
+				end
+				nameStr = "{#{nameStr}}, {#{t.tokenID}}" if nameStr != ""
+				nameStr = "#{t.tokenID}" if nameStr == ""
+				token.inheritedIDs.push( t.tokenID )
+			end
+			token.name = nameStr if nameStr != ""
+			token
+		end
+
+		def Token.add;    "+"; end
+		def Token.delete; "-"; end
+
+		def Token.resetTokenIDCount
+			@@tokenIDCount = 0
+		end
+		
+    def initialize
+			self.tag = String.new
+      self.objectGraphWrappers = Array.new
+      self.owner = nil # Array.new
+      self.cluster = nil
+			self.tokenID = @@tokenIDCount
+			@@tokenIDCount = @@tokenIDCount + 1
+			self.inheritedIDs = Array.new
+			self.variableTop = nil
+			self.rootNodeWatcher = nil
+			self.hostilities = Array.new
+			self.name = "#{@@tokenIDCount}"
+		end
+		
+		def clone
+			token = Token.new
+			token.tag = self.tag
+			token.owner = self.owner
+			token.cluster = self.cluster
+			self.objectGraphWrappers.each do |ogw|
+				token.objectGraphWrappers.push( ogw.clone )
+			end
+			token.tokenID = self.tokenID
+			token
+		end
+
+    # Alias for concat
+    def <<( token ); self.concat( token ); end
+
+    # Adds to self the objectGraphWrappers from otherToken (notice nothign else is added)
+    def concat!( otherToken )
+      self.error( "Can't concat! with self" ) if otherToken.equal?( self )
+      otherToken.objectGraphWrappers.each { |o| self.addObjectGraphWrapper( o.clone ) }
+      self
+    end
+
+    # Calls concat! on a clone of self
+    def concat( otherToken )
+      retToken = self.clone
+      retToken.concat!( otherToken )
+      retToken
+    end
+
+		def ==( other )
+			# test for bijection
+			if other.class != Token
+				print "other class isn't Token, it is: #{other.class}\n"
+				return false
+			end
+			
+			return false if self.objectGraphWrappers.size != other.objectGraphWrappers.size
+			equal = true
+			#print "my ogws sizE: #{self.objectGraphWrappers.first} others: #{other.objectGraphWrappers.first}\n"
+			self.objectGraphWrappers.each do |ogw|
+				if !other.objectGraphWrappers.include?( ogw )
+					equal = false
+					break
+				end
+			end
+			equal
+		end
+		
+    # Adds objectGraphWrapper to objectGraphWrappers
+    def addObjectGraphWrapper( objectGraphWrapper ); @objectGraphWrappers.push( objectGraphWrapper ); end
+    # Convenience method to set tag
+    def setTag( val ); self.tag = val; end
+
+    # Sets this object's objectGraphWrappers, and sets each objectGraphWrapper's token to self.
+    def setObjectGraphWrappers( _objectGraphWrappers )
+      @objectGraphWrappers = _objectGraphWrappers
+      @objectGraphWrappers.each { |ogw| ogw.token = self }
+    end
+
+    # Prints object data onto stream
+    def printOn( stream )
+			stream << "<Token> id: #{self.tokenID} owner: #{self.owner} with objectGraphWrappers: "
+      @objectGraphWrappers.each do |object|
+				object.printOn( stream )
+				stream << "    "
+			end
+      stream << "</Token>"
+      stream
+    end
+
+    # Uses printOn to print to stdout
+    def to_s; printOn( StringIO.new ).string; end
+
+    # Registers graphNode as an owner.
+    def registerOwner( graphNode )
+			self.owner = graphNode # ) if !owners.includeID?( graphNode )
+		end
+		
+    # Deregisters graphNode as an owner.
+    def deRegisterOwner; self.owner = nil; end
+		
+  end
+
+end

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

@@ -0,0 +1,177 @@
+module MK
+
+	require 'nist/khammurabi/Cluster'
+
+	class TokenCluster < Cluster
+
+		attr :joinLevels, true # Hash( Object => int )
+		attr :kLevel, true # Number of VariableTestNode's in the current level
+
+		@@matchValues = Hash[ 1 => "hostileValue", 2 => "wrongOwnerTypeValue", 3 => "sameOwnerValue", 4 => "matchValue",
+													5 => "matchFailureValue", 6 => "inClusterValue" ]
+		def TokenCluster.hostileValue;        1; end
+		def TokenCluster.wrongOwnerTypeValue; 2; end
+		def TokenCluster.sameOwnerValue;      3; end
+		def TokenCluster.matchValue;          4; end
+		def TokenCluster.matchFailureValue;   5; end
+		def TokenCluster.inClusterValue;      6; end
+		def TokenCluster.valueToStringMap( value ); @@matchValues[ value ]; end
+		
+		def initialize
+			super
+			self.joinLevels = Hash.new
+		end
+		
+		def add( tokens )
+			tokens = [ tokens ] if tokens.class != Array
+			tokens.each do |token|
+				self.error( "You can only add a Token or TokenCluster or an Array of either to this type of Cluster" ) if token.class != Array and !token.kind_of?( MK::Token ) and !token.kind_of?( MK::TokenCluster )
+			end
+			super
+			tokens.each do |token|
+				self.joinLevels[ token  ] = Array.new if self.joinLevels[ token ] == nil
+				# sanity check
+				if token.owner and token.owner.respond_to?( :level )
+					level = token.owner.level
+				else
+					level = 0
+				end
+				self.error( "Graph wasn't initialized correctly -- VariableTestNode has incorrect level of #{token.owner.level}" ) if level < 0
+				self.joinLevels[ token ].push( level )
+				token.cluster = self
+			end
+		end
+
+		def delete( token )
+			self.joinLevels[ token ] = nil
+			super
+		end
+
+		def matchesWith?( object ) #, owner = nil )
+			# Marshall the object to the correct method
+			if object.kind_of?( MK::Token )
+				self.matchesWithToken?( object )
+			elsif object.kind_of?( MK::TokenCluster )
+				self.matchesWithTokenCluster?( object )
+			else
+				self.error( "I don't know how to match with objects of type #{object.class}" )
+			end
+		end
+
+		def matchesWithTokenCluster?( cluster )
+			matches = true
+			retval = [ [], [] ]
+			cluster.elements.each do |token|
+				matchReturn = self.matchesWithToken?( token )
+				if matchReturn.first.include?( TokenCluster.matchFailureValue ) or \
+					 matchReturn.first.include?( TokenCluster.hostileValue ) or \
+					 matchReturn.first.include?( TokenCluster.sameOwnerValue )
+					matchReturn.first.each { |value| retval.first.pushUnique( value ) }
+					matches = false
+					retval.second.push( token )
+				end
+			end
+			retval.first.push( TokenCluster.matchValue ) if matches == true
+			retval
+		end
+
+		def matchesWithToken?( token )
+			# Sanity check
+			self.error( "Token's owner must be initialized" ) if token.owner == nil
+			self.notice( "Entering matchesWithToken?  token: #{token.tokenID} token's parent: #{token.owner.name}" )
+			#return 1
+			########### Failure and other cases ####################################################################
+			## return values:
+			## -1  this is for a do-nothing repsonse, like when the test isn't run at all
+			## 0   the token didn't match
+			## 1   the token matched
+			retval = [ [], [] ]
+			self.elements.each do |t|
+				if t.hostilities.includeID?( token )
+					self.notice( "I am hostile to this token, so I am not letting it join" )
+					retval.first.push( TokenCluster.hostileValue )
+					return retval
+				end
+			end
+
+			if !token.owner.kind_of?( VariableTestNode )
+				self.notice( "Trying to match with a Token that isn't in a VariableTestNode (owner has class: #{token.owner.class}), so not letting it join" )
+				retval.first.push( TokenCluster.wrongOwnerTypeValue )
+				return retval
+			end
+			## Test can't happen if token's owner is the same as any of the tokens owned by this cluster
+			self.notice( "Element's size: #{self.elements.size}" )
+			self.elements.each do |t|
+				self.notice( "Looking at token: #{token.tokenID} and t: #{t.tokenID}" )
+				## Don't match with any tokens that are already in the cluster
+				if token.equal?( t )
+					self.notice( "The token being matched is the same as one of the Tokens in this cluster, so adding TokenCluster.inClusterValue" )
+					retval.first.push( TokenCluster.inClusterValue )
+				end
+			end
+			self.elements.each do |t|
+				if ( t.owner.equal?( token.owner ) and !retval.first.include?( TokenCluster.inClusterValue ) ) or \
+				     ( t.owner.equal?( token.owner ) and self.size == 1 )
+					self.notice( "Token that is being matched against has the same parent #{token.owner.class} as this token, so returning -1" )
+					retval.first.push( TokenCluster.sameOwnerValue )
+					return retval
+				end
+			end
+			
+			###############################################################################################
+
+			########### Token test ########################################################################
+			## If the token matches with every other token in this cluster, it is passed
+			failRecord = Array.new
+			pass = true
+			node = token.owner
+			self.elements.each do |token2|
+				next if ( token2.equal?( token ) ) or token2.owner.class != VariableTestNode
+				node2 = token2.owner
+				self.notice( "&&&& comparing #{node.objectOperationTest.variableName} with #{node2.objectOperationTest.variableName}" )
+				next if !node.objectOperationTest.variableName.eql?( node2.objectOperationTest.variableName )
+				node.objectOperationTest.testObject = token.objectGraphWrappers.first
+				node2.objectOperationTest.testObject = token2.objectGraphWrappers.first
+				testperformed = true
+				self.notice( "\tComparing token #{token.tokenID} to token #{token2.tokenID} via variableName #{node.objectOperationTest.name}}" ) 
+				matchResult = node.objectOperationTest.match( node2.objectOperationTest )
+				self.notice( "\tGot a match result of: #{matchResult} and pass is: #{pass}" )
+				if matchResult == false
+					self.notice( "\tSETTING pass to false" )
+					failRecord.push( token2 )
+					pass = false
+				end
+			end # self.elements.each do |e|
+			truthicity = pass
+			self.notice( "pass: #{pass} truthicity: #{truthicity}" )
+			retval.second = failRecord
+			self.notice( "before modification of retval's first. it is: #{retval.first.join( ", " )}" )
+			retval.first.push( TokenCluster.matchValue ) if truthicity == true
+			retval.first.push( TokenCluster.matchFailureValue ) if truthicity == false 
+			###############################################################################################
+			self.notice( "Exiting matchesWith? retval.first is #{retval.first.join( ", " )}" )
+			retval
+		end
+
+		def complete?( vtne )
+			# check to see if the Tokens in this cluster are in each node in vtne
+			hitNodes = 0
+			owners = Array.new
+			self.elements.each do	|token|
+				owners.pushUnique( token.owner )
+			end
+			#print "owner is: #{owners.printList( :name )}\n"
+			vtne.variableTestNodes.each do |vtn|
+				#print "\tvtn is: #{vtn.name}\n"
+				if owners.includeID?( vtn )
+					hitNodes = hitNodes + 1
+				end
+			end
+			( hitNodes == vtne.variableTestNodes.size )
+		end
+
+		def printTo( stream ); stream << "MK::Cluster with id: #{self.clusterID} and elements: <#{self.elements.printList( :tokenID )}>"; end
+		
+	end # class TokenCluster
+end # module MK
+