khammurabi 0.2

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

@@ -0,0 +1,36 @@
+module MK
+
+	require 'nist/khammurabi/ClusterManager'
+	require 'nist/khammurabi/TokenCluster'
+	require 'nist/khammurabi/ObjectAddon'
+	
+	class TokenClusterManager < ClusterManager
+	
+		def initialize
+			super
+			self.name = "TokenClusterManager"
+		end
+		
+		def formClusterWithHostilities( tokens )
+			tokens.each do |token|
+				tokens.each do |otherToken|
+					next if otherToken.equal?( token )
+					self.error( "Token must have a cluster!" ) if token.cluster == nil 
+					self.error( "otherToken #{token.tokenID} must have a cluster!" ) if otherToken.cluster == nil
+					self.notice( "token's owner: #{token.owner.name} and otherToken's: #{otherToken.owner.name} token's cluster size: #{token.cluster.size}" )
+					rets = token.cluster.matchesWith?( otherToken )
+					self.notice( "rets are: #{rets.join( " " )}" )
+					retvals = rets.first
+					if rets.include?( TokenCluster.matchValue )
+						self.notice( "This token matches\n" )
+						token.cluster.add( otherToken )
+					else
+						token.becomeHostileTo( otherToken )
+					end # if ...
+				end # tokens.each do |otherToken|
+			end # tokens.each do |token|
+		end # def formCluster( tokens )
+
+	end # class TokenClusterManager
+end # module MK
+

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

@@ -0,0 +1,100 @@
+module MK
+
+ 	require 'nist/khammurabi/ArrayAddon'
+	require 'nist/khammurabi/GraphNode'
+	require 'nist/khammurabi/ObjectAddon'
+	
+  # If two nodes that are alike try to go down the same path in the graph,
+	# this class will hold one of the tokens so it doesn't create odd happenings
+	class UniqueTokenAssurerNode < GraphNode
+
+		attr :staticLevels, true  # Hash( Node => Fixnum )   how many groups of nodes under this
+		attr :managedTokens, true # Hash( Node => Fixnum )   how many tokens the group has
+		attr :multiChildren, true # Array 
+		
+    def UniqueTokenAssurerNode.init( name, engine, debug = false )
+      utan = UniqueTokenAssurerNode.new
+			utan.name = name
+			utan.engine = engine
+			utan.debug = debug
+			utan
+    end
+
+    def initialize
+      super
+      self.maxChildren = -1
+			self.staticLevels = Hash.new 
+			self.managedTokens = Hash.new 
+			self
+		end
+
+		#def stopManagingToken( token )
+		#	managedTokens.delete_if { |token| token.equal?( token ) }
+		#end
+		
+		def tokenFailed( token )
+			managedTokens.each_pair do |key,value|
+				value.reject! { |t| t.equal?( token ) }
+			end
+		end
+		
+		def setStaticLevel( node, level )
+			self.staticLevels[ node.object_id ] = level
+		end
+		
+		def getStaticLevel( node )
+			self.staticLevels[ node.object_id ]
+		end
+		
+    # Passes tokens to each child as long as it's not already being managed
+    def execute
+			self.tokens.each do |token|
+				token.beginBroadcastingTo( self )
+				assigned = false
+				childToAddTo = nil
+				self.children.each do |child|
+					#print "AT CHILD: #{child.name}\n"
+					if self.managedTokens[ child.object_id ] == nil \
+						 or self.managedTokens[ child.object_id ].size == 0 \
+						 or !self.managedTokens[ child.object_id ].include?( token ) \
+						 or self.managedTokens[ child.object_id ].size < self.staticLevels[ child.object_id ]
+						#print "#{self.managedTokens[ child.object_id ] == nil}\n"
+						#if self.managedTokens[ child.object_id ] != nil 
+						#	print "NOT NIL: #{self.managedTokens[ child.object_id ].size == 0} #{!self.managedTokens[ child.object_id ].include?( token )}\n"
+						#else
+						#	print "IS NIL\n"
+						#end
+						
+						self.notice( "Token isn't in this graph, so passing on " )
+						self.registerPassedToken( token )
+						assigned = true
+						childToAddTo = child
+						#print "size: #{self.managedTokens.size}\n"
+						self.managedTokens[ child.object_id ] = Array.new if self.managedTokens[ child.object_id ] == nil
+						self.managedTokens[ child.object_id ].push( token )
+						#print "0 it is: #{self.managedTokens[child.object_id].size}\n"
+						#print "1 it is: #{self.managedTokens[child.object_id].size}\n"
+						#print "total: "
+						#self.managedTokens[ child.object_id ].each do |key|
+						#	print "key: #{key}     "
+						#end
+						break
+					else
+						self.notice( "Token #{token.tokenID} is already in this graph, so not using" )
+						self.notice( "comparing: " )
+						#self.managedTokens[ child.object_id ].each do |element|
+						#	print "element ID: #{element.tokenID} == : #{element == token}\n"
+						#end
+						self.notice( "size: #{self.managedTokens[ child.object_id ].size}" )
+						self.notice( "Data: #{self.managedTokens[ child.object_id ] == nil} include: #{self.managedTokens[ child.object_id ].include?( token )}" )
+					end # if (big long statement)
+				end # self.children.each do |child|
+				if assigned == true
+					self.manageTokens( childToAddTo ) # self.children.each do |child|
+				end
+			end # self.tokens.each do |token|
+		end
+		
+  end
+end
+

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

@@ -0,0 +1,239 @@
+module MK
+
+  require 'nist/khammurabi/ObjectAddon'
+
+  # A suite of classes that define tests done on objects
+  class ValueTest
+    attr :testValue, true
+		attr :testString, true
+		attr :name, true
+    def initialize
+			self.testValue = nil
+			self.name = "ValueTest"
+		end
+		def match?( object ); self.match( object ); end
+    def match( object ); self.match2( self.testValue, object ); end
+    def match2?( object1, object2 ); self.match2( object1, object2 ); end
+		def match2( object1, object2 )
+			self.error( "Subclass responsibility" ) if self.class == ValueTest
+			#object1Str = object1
+			#object1Str = "nil" if object1 == nil #or object1 = ""
+			#object1Str = "\"\"" if object1 == ""
+			#object2Str = object2
+			#object2Str = "nil" if object2 == nil #or object2 = ""
+			#object2Str = "\"\"" if object2 == ""
+			evalStr = "#{object1.to_s} #{self.testString} #{object2.to_s}"
+			self.notice( "Performing operation: #{evalStr}" )
+			#print "Performing operation: #{evalStr}\n"
+			#exit
+			#$defout.flush
+			#return eval( evalStr )
+		end
+    def ==( otherObject )
+			return ( self.class == otherObject.class and self.testValue == otherObject.testValue )
+		end
+		def printOn( stream )
+			stream << "<A #{self.class} Operation: #{self.testString} Testvalue: '#{self.testValue}'>"
+		end
+		def to_s
+			printOn( StringIO.new ).string
+		end
+  end
+  
+  # Corresponds to >
+  class GreaterThanTest < ValueTest
+    def initialize
+			super
+			self.testString = ">"
+		end
+	  def GreaterThanTest.init( _testValue = nil )
+      test = GreaterThanTest.new
+      test.testValue = _testValue
+      test
+    end
+		def match2( value2, value1 )
+			super
+			#print "doing #{value1} > #{value2}\n"
+			return value1 > value2
+		end
+	end
+	
+	# Corresponds to >=
+  class GreaterThanOrEqualTest < ValueTest
+    def initialize
+			super
+			self.testString = ">="
+		end
+	  def GreaterThanOrEqualTest.init( _testValue = nil )
+      test = GreaterThanOrEqualTest.new
+      test.testValue = _testValue
+      test
+    end
+		def match2( value2, value1 )
+			super
+			return value1 >= value2
+		end
+	end
+	
+	# Corresponds to ==
+  class EqualityTest < ValueTest
+    def initialize
+			super
+			self.testString = "=="
+		end
+	  def EqualityTest.init( _testValue = nil )
+      test = EqualityTest.new
+      test.testValue = _testValue
+      test
+    end
+		def match2( value2, value1 )
+			super
+			return value1 == value2
+		end
+	end
+	
+
+	# Corresponds to equal?
+  class ObjectIDEqualityTest < ValueTest
+    def initialize
+			super
+			self.testString = "=="
+		end
+	  def ObjectIDEqualityTest.init( _testValue = nil )
+      test = ObjectIDEqualityTest.new
+      test.testValue = _testValue
+      test
+    end
+		def match2( value2, value1 )
+			super
+			return value1.equal?( value2 )
+		end
+	end
+	
+	# Corresponds to !equal?
+  class ObjectIDInequalityTest < ValueTest
+    def initialize
+			super
+			self.testString = "=="
+		end
+	  def ObjectIDInequalityTest.init( _testValue = nil )
+      test = ObjectIDInequalityTest.new
+      test.testValue = _testValue
+      test
+    end
+		def match2( value2, value1 )
+			super
+			return !value1.equal?( value2 )
+		end
+	end
+	
+  # Corresponds to !=
+  class InequalityTest < ValueTest
+    def initialize
+			super
+			self.testString = "!="
+		end
+	  def InequalityTest.init( _testValue = nil )
+      test = InequalityTest.new
+      test.testValue = _testValue
+      test
+    end
+		def match2( value2, value1 )
+			super
+			return value1 != value2
+		end
+	end
+	
+	# Corresponds to <=
+  class LessThanOrEqualTest < ValueTest
+    def initialize
+			super
+			self.testString = "<="
+		end
+	  def LessThanOrEqualTest.init( _testValue = nil )
+      test = LessThanOrEqualTest.new
+      test.testValue = _testValue
+      test
+    end
+		def match2( value2, value1 )
+			super
+			return value1 <= value2
+		end
+	end
+
+  # Corresponds to <
+  class LessThanTest < ValueTest
+    def initialize
+			super
+			self.testString = "<"
+		end
+	  def LessThanTest.init( _testValue = nil )
+      test = LessThanTest.new
+      test.testValue = _testValue
+      test
+    end
+		def match2( value2, value1 )
+			super
+			return value1 < value2
+		end
+	end
+	
+	# This class always returns a true match
+	class TrueTest < ValueTest
+    def initialize
+			super
+			self.testString = "true"
+		end
+	  def TrueTest.init( _testValue = nil )
+      test = TrueTest.new
+      test.testValue = _testValue
+      test
+    end
+		def match2( object1, object2 )
+			self.notice( "Performing operation: TRUE"	)
+			return true
+		end
+  end
+	
+	# This class always returns a false match
+	class FalseTest < ValueTest
+    def initialize
+			super
+			self.testString = "false"
+		end
+    def FalseTest.init( _testValue = nil )
+      test = FalseTest.new
+      test.testValue = _testValue
+      test
+    end
+		def match2( object1, object2 )
+			self.notice( "Performing operation: FALSE"	)
+			return false
+		end
+  end
+
+  class IncorporatorTest < ValueTest
+		def IncorporatorTest.match2( test1, test2 )
+			#print "INCORPORATING: #{test1.class.to_s} #{test2.class.to_s}\n"
+			if ( test1.class == EqualityTest and test2.class == EqualityTest )
+				return EqualityTest
+			elsif ( ( test1.class == EqualityTest and test2.class == InequalityTest ) \
+						or ( test1.class == InequalityTest and test2.class == EqualityTest ) )
+			return InequalityTest
+			elsif ( test1.class == InequalityTest and test2.class == InequalityTest )
+				return TrueTest
+			elsif ( test1.class == ObjectIDEqualityTest and test2.class == ObjectIDEqualityTest )
+				return ObjectIDEqualityTest
+			elsif ( test1.class == ObjectIDInequalityTest and test2.class == ObjectIDInequalityTest )
+				return TrueTest
+			elsif ( test1.class == ObjectIDEqualityTest and test2.class == ObjectIDInequalityTest ) \
+				    or ( test1.class == ObjectIDInequalityTest and test2.class == ObjectIDEqualityTest )
+				return ObjectIDInequalityTest
+			else
+				return FalseTest
+			end
+			nil
+		end
+	end
+		
+end

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

@@ -0,0 +1,87 @@
+module MK
+
+  require 'stringio'
+  require 'nist/khammurabi/ObjectOperation'
+  require 'nist/khammurabi/ValueTestSuite'
+  require 'nist/khammurabi/ObjectAddon'
+	require 'nist/khammurabi/ArrayAddon'
+
+  # Tests an object for equality with another object (both are mutable). Differs from ConstantObjectOperation
+  # because COO tests against a static object. Used by VariableTestNode
+  class VariableObjectOperation < ObjectOperation
+
+    attr :variableName, true # String .. name of the variable (like <X> in ops5)
+    attr :testObject, true # Object    not the best way to go about doing things, but the easiest 
+                           # for now.. fix later
+
+    def initialize
+      super
+      self.variableName = String.new
+      self
+    end
+
+    def VariableObjectOperation.init( valueTests, name, testMe, variableName )
+      voo = VariableObjectOperation.new
+			valueTests = [ valueTests ] if valueTests.class != Array
+      voo.valueTests = valueTests
+      voo.name = name
+      voo.testMe = testMe
+      voo.variableName = variableName
+			#print "setting variableName: #{variableName}\n"
+      voo
+    end
+
+    # Matches this with a VariableObjectOperation
+    def match( operation )
+			super
+    	# sanity check
+      self.error( "VariableObjectOperation#match error -- I don't know how to match anything but a VariableObjectOperation. This class is: #{operation.class}" ) if operation.class != VariableObjectOperation
+      if self.name != operation.name
+	  		self.warning( "Trying to match two different variable names: #{self.name} and #{operation.name}" )
+				return false
+      end
+			#self.debug = true
+
+			# Sanity checks
+			self.error( "I don't have a testObject set" ) if self.testObject.equal?( nil )
+			self.error( "My matching operation doesn't have a testObject set" ) if operation.testObject.equal?( nil )
+			
+			lValue = self.testObject.object.instance_eval( self.name ) # ( self.name[ 1, self.name.length() - 1 ] )
+      rValue = operation.testObject.object.instance_eval( operation.name ) # operation.name[ 1, operation.name.length() - 1 ] )
+			retval = true
+			incorporatedTest = nil
+      self.valueTests.each do |valueTest|
+				operation.valueTests.each do |otherValueTest|
+					incorporatedTest = IncorporatorTest.match2( valueTest, otherValueTest )
+					self.error( "Wasn't able to incorporate #{valueTest.class} and #{otherValueTest.class}" ) if incorporatedTest == nil
+					#print "Got an incorporatedTest of #{incorporatedTest.class} and going to match #{lValue} with #{rValue}"
+					#self.notice( "valueTest: #{valueTest.class} otherValueTest: #{otherValueTest} lValue's owner: #{self.testObject.token.owner.name} rValue's owner: #{operation.testObject.token.owner.name}" ) if self.testObject.token.owner != nil 
+					self.notice( "** valueTest's class: #{valueTest.class} otherValueTest's class: #{otherValueTest.class} Got an incorporatedTest of #{incorporatedTest} going to match #{lValue} with #{rValue}" )
+					retval = incorporatedTest.new.match2( lValue, rValue )
+					self.notice( "** retval is: #{retval}" )
+					#retval = TrueTest.new.match2( lValue, rValue )
+					break if retval == false
+				end
+			end
+			retval
+    end
+		
+    # Performs == on class and variableName
+    def ==( otherObject )
+      retval = super
+      return ( ( self.class == otherObject.class  and retval == true and self.variableName == otherObject.variableName and self.valueTests === otherObject.valueTests ) == true )
+    end
+
+    # Prints variableName to stream
+    def printOn( stream )
+      stream << "<VariableObjectOperation> variableName: #{self.variableName}   "
+      super
+      stream << "</VariableObjectOperation>"
+      stream
+    end
+
+    # Uses printOn to print to stdout
+    def to_s; printOn( StringIO.new ).string; end
+
+  end
+end