khammurabi 0.2

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

@@ -0,0 +1,46 @@
+module MK
+
+  require 'stringio'
+
+  # When an object is passed into the Engine, this is one of the classes that wrap the object. This class helps keep
+  # track of the operations performed on the object (equality testing, instantiation, etc).
+  class ObjectGraphWrapper
+
+    attr :object, true # Object
+    attr :operationsPerformed, true # Hash { String => Array( ObjectOperation ) }
+    attr :token, true # Token  owner of wrapper
+    
+    def initialize
+      self.object = nil
+      self.operationsPerformed = Hash.new
+    end
+
+    def ObjectGraphWrapper.init( object, operationsPerformed = Hash.new )
+      objectGraphWrapper = ObjectGraphWrapper.new
+      objectGraphWrapper.object = object
+      objectGraphWrapper.operationsPerformed = operationsPerformed
+      objectGraphWrapper
+    end
+
+		def clone
+			# potentially VERY SLOW!
+			ogw = ObjectGraphWrapper.init( self.object.clone, self.operationsPerformed )
+			ogw.token = self.token
+			ogw
+		end
+		
+		# just does == on object
+		def ==( other ); self.object == other.object; end
+		
+    # Prints object data onto stream
+    def printOn( stream )
+      stream << "<ObjectGraphWrapper> object: <#{@object}>" # operationsPerformed: <#{@operationsPerformed}>"
+      stream
+    end
+
+    # Calls printOn( stdout )
+    def to_s; printOn( StringIO.new ).string; end
+
+  end
+
+end

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

@@ -0,0 +1,59 @@
+module MK
+
+  require 'stringio'
+  require 'nist/khammurabi/ObjectAddon'
+  require 'nist/khammurabi/ValueTestSuite'
+
+  # Abstract class specifying a framework for object testing
+  class ObjectOperation
+
+    attr :name, true # String, name of variable to test inside of object
+    attr :testMe, true # BOOL ... to test or not to test is the question here
+    attr :valueTests, true # MK::ValueTest
+
+    def initialize
+      self.valueTests = Array.new
+      self.testMe = true
+    end
+
+    def ObjectOperation.init( valueTests, name, testMe )
+      oo = ObjectOperation.new
+			valueTests = [ valueTests ] if valueTests.class != Array
+      oo.valueTests = valueTests
+      oo.name = name
+      oo.testMe = testMe
+      oo
+    end
+
+    # Performs == on object data
+    def ==( otherObject )
+			return ( self.name == otherObject.name and self.testMe == otherObject.testMe ) == true
+		end
+    
+    # Subclass responsibility
+    def match( object )
+			self.error( "ObjectOperation#match -- subclass responsibility\n" ) if self.class == ObjectOperation	
+		end
+		
+    # Aliases for match
+    def =~( object ); match( object ); end
+		def match?( object ); match( object ); end
+
+		#def debug=( _debug )
+		#	self.debug = _debug
+		#	print "hi\n"
+		#	self.valueTests.first.debug = _debug
+		#end
+				
+    # Prints object data onto stream
+    def printOn( stream )
+			stream << "<ObjectOperation.subclassed?:#{self.class}> <name: #{self.name} <valueTests first: #{self.valueTests.first}> <testMe: #{self.testMe}> </MKObjectOperation>"
+      stream
+    end
+
+    # Uses printOn to print to stdout
+    def to_s; printOn( StringIO.new ).string; end
+
+  end
+
+end

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

@@ -0,0 +1,45 @@
+module MK
+
+  require 'nist/khammurabi/Engine'
+  require 'nist/khammurabi/ObjectProductionAction'
+  
+  # The top-level object that gets used by Engine when the Engine is building
+  # the graph. Basically a container class for ObjectDescriptions and Actions
+  class ObjectProduction
+    
+    attr :engine, true # Engine
+    attr :objectDescriptions, true # Array{ ObjectDescription }
+    attr :actions, true # Array{ Action }
+
+    def ObjectProduction.init( objectDescriptions, engine, actions = Array.new )
+      objectDescriptions = [ objectDescriptions ] if objectDescriptions.class != Array
+      actions = [ actions ] if actions.class != Array
+      objectProduction = ObjectProduction.new
+      objectProduction.engine = engine
+      objectDescriptions.each { |od| objectProduction.addObjectDescription( od ) }
+      objectProduction.actions = actions
+      objectProduction
+    end
+
+    def initialize
+			self.engine = nil
+      self.objectDescriptions = Array.new
+      self.actions = Array.new
+			self
+    end
+    
+    # Adds action to actions
+    def addAction( action )
+      action.production = self
+      self.actions.push( action )
+    end
+
+    # Adds description to objectDescriptions
+    def addObjectDescription( description )
+      self.objectDescriptions.push( description )
+      description.objectProduction = self
+    end
+
+  end
+
+end

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

@@ -0,0 +1,31 @@
+module MK
+
+  require 'nist/khammurabi/Token'
+  require 'nist/khammurabi/ObjectProduction'
+  require 'nist/khammurabi/ObjectAddon'
+  require 'nist/khammurabi/ValueTestSuite'
+
+  # Abstract class specifying a framework for actions that are executed in the graph
+  class ObjectProductionAction
+
+    attr :production, true # ObjectProduction
+    attr :preTest, true  # Proc
+    attr :tokens, true # Array( Token )
+    attr :needInput, true # Boolean
+    attr :engine, true # Engine
+
+    def initialize
+      self.needInput = false
+      self.tokens = Array.new
+    end
+
+    def execute; self.error( "Subclass responsibility" ); end
+
+    def preExecute
+      self.preTest and !self.preTest.call and return false
+      return true
+    end
+
+  end
+
+end

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

@@ -0,0 +1,49 @@
+module MK
+
+	require 'nist/khammurabi/ObjectAddon'
+	
+	# A simple container class that has first and second elements (similar in concept to the C++ STL pair)
+	class Pair
+
+		attr :first, true # key
+		attr :second, true # value
+
+		def Pair.init( first, second )
+			pair = Pair.new
+			pair.first  = first
+			pair.second = second
+			pair
+		end
+
+		def Pair.[]( first, second )
+			Pair.init( first, second )
+		end
+
+		def initialize
+			first = second = nil
+		end
+
+		def swap
+			temp = first
+			self.first  = second
+			self.second = first
+		end
+
+		# Convenience method
+		def last; self.second; end
+
+		def ==( other )
+			( self.first == other.first and self.second == other.second )
+		end
+
+		def []( index )
+			realIndex = index % 2
+			retval = nil
+			realIndex == 0 and retval = first
+			realIndex == 1 and retval = second
+			retval
+		end
+		
+	end
+end
+

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

@@ -0,0 +1,44 @@
+module MK
+  
+  require 'nist/khammurabi/TestNode'
+  require 'nist/khammurabi/ObjectGraphWrapper'
+  require 'nist/khammurabi/VariableTestNodeExecutor'
+  require 'nist/khammurabi/ObjectAddon'
+
+  # A class which uses a VariableObjectOperation to test the Tokens
+  # that pass into it. Uses a VariableTestNodeExecutor to do the dirty work
+  class VariableTestNode < TestNode
+    
+    attr :variableName, true # String
+    attr :variableTestNodeExecutor, true # VariableTestNodeExecutor
+
+    #def VariableTestNode.init( name, objectOperationTest, variableName, variableTestNodeExecutor, engine, parent )
+		def VariableTestNode.init( name, objectOperationTest, variableTestNodeExecutor, engine, parent )	
+      variableTestNode = VariableTestNode.new
+      variableTestNode.name = name
+      variableTestNode.objectOperationTest = objectOperationTest
+      variableTestNode.variableTestNodeExecutor = variableTestNodeExecutor
+      variableTestNode.engine = engine
+      variableTestNode.setParent( parent )
+      variableTestNode
+    end
+
+    def initialize
+      super
+      self.tokens = Array.new
+      self.variableTestNodeExecutor = nil
+      self
+    end
+
+    # Calls variableTestNodeExecutor.execute
+    def execute
+      # sanity check
+      self.error( "VariableTestNode#execute error -- trying to execute without having a properly initialized @variableTestNodeExecutor\n" ) if self.variableTestNodeExecutor == nil
+      # VariableTestNodeExecutor manages the tokens for self
+      self.variableTestNodeExecutor.execute
+    end # execute
+
+  end # class
+end # module
+
+

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

@@ -0,0 +1,66 @@
+module MK
+  
+  require 'nist/khammurabi/ObjectAddon'
+
+  # A node in the ReteParseTree constructed in the XiaccEngine
+  # Note: The graph structure created by using ReteParseTreeNodes
+  #  is NOT the graph structure used by MK::Engine. This graph structure
+  #  is used solely for parsing special input (of the type: ( foo = 3
+  #  and bar = 4 ), etc ). So the graph structure created with this
+  #  class can be considered a temporary stop in the steps of making the final
+  #  rete graph (the final rete graph is comprised of ConstantTestNodes
+  #  along with others -- see Engine.rb for details )
+  # Classes used in building graphs with this: ReteParseTreeNode, ReteParseTreePrinter,
+  #  ReteParseTreeToObjectDescriptionConverter
+  # This graph structure is made in XiaccEngine. Look for keyword RPT
+  class ReteParseTreeNode
+    
+    attr :children, true # ReteParseTreeNode
+    attr :predicate, true # and/or/etc
+    attr :parent, true # ReteParseTreeNode
+    attr :allowedChildren, true # Array of allowed child types
+    attr :name, true # used for debugging
+
+    @@names = 0
+
+    def ReteParseTreeNode.init( children, predicate, parent )
+      rpte = ReteParseTreeNode.new
+      rpte.children = children
+      rpte.predicate = predicate
+      rpte.parent = parent
+      rpte
+    end
+
+    def initialize
+      self.children = Array.new
+      self.predicate = "and" # String.new
+      self.allowedChildren = [ ReteParseTreeNode, ObjectDescription, String ]
+      @maxChildren = 2
+      self.name = @@names 
+      @@names = @@names + 1
+      self
+    end
+
+    # Adds child to children. Checks for overflow
+    def addChild( child )
+      self.error( "trying to add too many children . my number of children: #{self.children.size}!" ) if self.children.size == @maxChildren
+      self.error( "don't understand the type that is being added as a child: #{child.class}" ) if !self.allowedChildren.include?( child.class )
+      self.children.push( child )
+    end
+
+    # Removes child from children
+    def removeChild( child )
+      self.children.delete( child )
+    end
+
+    # Prints name onto stream
+    def printOn( stream )
+      stream << "<ReteParseTreeNode name: #{self.name}>"
+      stream
+    end
+
+    # Uses printOn to print to stdout
+    def to_s; self.printOn( StringIO.new ).string; end
+
+  end
+end

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

@@ -0,0 +1,58 @@
+module MK
+
+	require 'stream'
+	
+  require 'nist/khammurabi/ReteParseTreeNode'
+  require 'nist/khammurabi/ArrayAddon'
+  require 'nist/khammurabi/ObjectAddon'
+
+  # Prints a Graph of ReteParseTreeNodes to a strean using DFS
+  class ReteParseTreePrinter
+    attr :rootNode, true # ReteParseTreeElement
+    
+    def ReteParseTreePrinter.init( rootNode )
+      rptp = ReteParseTreePrinter.new
+      rptp.rootNode = rootNode
+      rptp
+    end
+
+    def initialize
+      self.rootNode = nil
+    end
+
+    # Prints the graph onto stream using a depth-first-search approach
+    def printOn( stream ) 
+      stream << "<ReteParseTreePrinter> \n"
+      self.printOnHelper( stream, rootNode, 0 )
+      stream << "\n</ReteParseTreePrinter>"
+      stream
+    end
+
+    # Private method used by printOn. This method shouldn't be called manually.
+    def printOnHelper( stream, node, level )
+      return if node == nil
+			children = node.children
+			level.times { stream << "\t" }
+
+			extraInfo = ""
+			extraInfo = "valueTest id: #{node.objectOperationTest.valueTests.first.object_id} class: #{node.objectOperationTest.valueTests.first.class} testValue: #{node.objectOperationTest.valueTests.first.testValue} variable name: #{node.objectOperationTest.name}" if node.kind_of?( TestNode )
+			extraInfo = "#{extraInfo} variableName: #{node.variableName} level: #{node.level}" if node.class == VariableTestNode
+      stream << "Found NODE #{node.class.to_s}. name: #{node.name} #{extraInfo} It has #{children.size} children left class: #{node.children.first.class} right class: #{node.children.second.class}\n"
+			
+      ( level - 1 ).times { stream << "\t" }
+			children.size.times do |idx|
+				child = children[ idx ]
+				if child.kind_of?( MK::GraphNode )
+					stream << "\tTRAVERSING #{node.class.to_s} (with name #{node.name})'s #{idx} children\n"
+					self.printOnHelper( stream, child, level + 1 )
+				else
+					self.error( "0 Don't know how what to do with node of type: #{node.children.first.class}" )
+				end
+			end
+    end
+
+    # Uses printOn to print to stdout
+    def to_s; self.printOn( StringIO.new ).string; end
+
+  end
+end

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

@@ -0,0 +1,76 @@
+module MK
+
+  require 'nist/khammurabi/ReteParseTreeNode'
+  require 'nist/khammurabi/ObjectDescription'
+  require 'nist/khammurabi/ArrayAddon'
+  require 'nist/khammurabi/ObjectAddon'
+
+  # This class converts a ReteParseTreeNode graph into an array
+  # of ObjectDescription's
+  class ReteParseTreeToObjectDescriptionConverter
+    
+    attr :rootNode, true # ReteParseTreeNode
+    attr :objectDescriptions, true # Array ( ObjectDescription )
+    
+    def ReteParseTreeToObjectDescriptionConverter.init( rootNode )
+      rpt = ReteParseTreeToObjectDescriptionConverter.new
+      rpt.rootNode = rootNode
+      rpt
+    end
+    
+    def initialize
+      self.rootNode = nil
+    end
+
+    # Traverse through the tree and create objectDescription's out of the nodes in the tree
+    def parse; self.objectDescriptions = self.parseHelper( rootNode, 0 ); end
+
+    # Private helper method to parse. Not to be called manually
+    def parseHelper( node, level )
+      ######################################## Notes ################################################################
+      # Each OR creates a new ObjectDescription                                                                     #
+      # Output is of format Array( Array( ObjectDescription ) ). Each Array on the top level corresponds to one     #
+      #   ObjectProduction. Each Array on the second level corresponds to ObjectDescriptions which make up that     #
+      #   ObjectProduction. So if the output looks like [ [ od1, od2 ], [ od3 ] ] where od* are ObjectDescriptions  #
+      #   then the output corresponds to two ObjectProductions, the first one composed of od1 and od2, and the      #
+      #   second composed of od3                                                                                    #
+      # See keyword TOD in InsuranceTest for an example of using two ObjectDescriptions                             #
+      ###############################################################################################################
+      return [] if node == nil
+      leftReturnValues = []
+      rightReturnValues = []
+      retvals = []
+      if node.class == ReteParseTreeNode
+				leftReturnValues.concat( self.parseHelper( node.children.first, level + 1 ) )
+				rightReturnValues.concat( self.parseHelper( node.children.second, level + 1 ) )
+				if leftReturnValues.size == 0 and rightReturnValues.size > 0
+					retvals.concat( rightReturnValues )
+				elsif rightReturnValues.size == 0 and leftReturnValues.size > 0
+					retvals.concat( leftReturnValues )
+        end
+
+				leftReturnValues.each do |leftReturnValue|
+					rightReturnValues.each do |rightReturnValue|
+						if node.predicate == "and"
+							catted = leftReturnValue.concat( rightReturnValue ) 
+							retvals.push( catted )
+						elsif node.predicate == "or"
+							leftReturnValue.flatten! if leftReturnValue.class == Array or leftReturnValue.class == Set
+							rightReturnValue.flatten!if rightReturnValue.class == Array or rightReturnValue.class == Set
+							retvals.concat( [ leftReturnValue, rightReturnValue ] )
+						else
+							self.error( "Got a predicate I don't understand: #{node.predicate}" )
+						end # if node.predicate == "and"
+					end # rightReturnValues.each do
+				end # leftReturnValues.each do
+		  elsif node.class == MK::ObjectDescription # if node.class == MK::ReteParseTreeNode
+				#print "** pushing: #{node}\n\n"
+		  	retvals.push( node )
+		  else
+		  	self.error( "Trying to parse a node of type: #{node.class}  and I don't know what to do\n" )
+		  end # if node.class == ReteParseTreeNode
+		  retvals
+    end # def parseHelper
+
+  end
+end