khammurabi 0.2

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

@@ -0,0 +1,27 @@
+module MK
+
+	require 'nist/khammurabi/XiaccParseSpecification'
+	
+	class XiaccParseInput
+	
+		attr :specifications, true # XiaccParseSpeicifcation's
+		attr :actions, true # Action
+		
+		def XiaccParseInput.init( specifications, actions )
+			specifications = [ specifications ] if specifications.class != Array
+			actions = [ actions ] if actions.class != Array
+			
+			xpi = XiaccParseInput.new
+			xpi.specifications = specifications
+			xpi.actions = actions
+			xpi
+		end
+		
+		def initialize
+			self.specifications = Array.new
+			self.actions = Array.new
+			self
+		end
+		
+	end # class XiaccParseInput
+end # module MK

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

@@ -0,0 +1,25 @@
+module MK
+
+	class XiaccParseSpecification
+	
+		attr :klass, true # the class of the object
+		attr :parseString, true # the string for the xiacc engine to parse
+		
+		def XiaccParseSpecification( klass, parseString )
+			xps = XiaccParseSpecification.new
+			xps.klass = klass
+			xps.parseString = parseString
+			xps
+		end
+		
+		def initialize
+			self.klass = nil
+			self.parseString = ""
+			self
+		end
+		
+	end
+
+end
+
+		

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

@@ -0,0 +1,24 @@
+module MK
+
+  require 'nist/khammurabi/GraphNode'
+
+  # A GraphNode that has many children and one parent. It just marshalls tokens from parent to each child
+  class ZombieNode < GraphNode
+
+    def ZombieNode.init( name, engine )
+      rootNode = ZombieNode.new
+      rootNode.name = name
+      rootNode.engine = engine
+      rootNode
+    end
+
+    def initialize
+      super
+    end
+
+    # Passes tokens to each child
+    def execute
+    end
+    
+  end
+end

data/khammurabi-0.2/tests/test_action_object_delete.rb

@@ -0,0 +1,91 @@
+module MK
+
+  require 'test/unit'
+  require 'stringio'
+
+  require 'nist/khammurabi/Engine'
+  require 'nist/khammurabi/TestNode'
+  require 'nist/khammurabi/VariableTestNode'
+  require 'nist/khammurabi/InstantiatorNode'
+  require 'nist/khammurabi/ObjectProduction'
+  require 'nist/khammurabi/ArrayAddon'
+  require 'nist/khammurabi/GraphNode'
+  require 'nist/khammurabi/ValueTestSuite'
+	require 'nist/khammurabi/ReteParseTreePrinter'
+	require 'nist/khammurabi/RootNode'
+	require 'nist/khammurabi/ZombieNode'
+	require 'nist/khammurabi/ActionObjectDeleteFromWorkingMemory'
+	
+  class Tester_AOD
+    attr :val1, true
+    attr :val2, true
+    attr :val3, true
+
+    def initialize
+      @val1 = @val2 = @val3 = nil
+    end
+		def to_s 
+				"val1: #{self.val1} val2: #{self.val2} val3: #{self.val3}"
+		end
+		def ==( other )
+			( self.val1 == other.val1 and self.val2 == other.val2 and self.val3 == other.val3 )
+		end
+  end
+
+  class Tester2_AOD
+    attr :val0, true
+    attr :val1, true
+    attr :val2, true
+    attr :val3, true
+
+    def initialize
+      @val0 = @val1 = @val2 = @val3 = nil
+    end
+
+  end
+
+  class Test_Action_Object_Delete < Test::Unit::TestCase
+
+    attr_accessor :graphA
+
+    def objectA
+      t = Tester_AOD.new
+      t.val1 = 5
+      t.val2 = 10
+      #t.val3 = 15
+      t
+    end
+
+		# This test just assures that RootNode passes on arbitrary tokens
+    def test_delete
+			object1 = objectA
+			object2 = objectA
+			object2.val1 = 6
+			engine = Engine.new
+			prod = ObjectProduction.new
+			prod.actions.push( ActionObjectDeleteFromWorkingMemory.init( object2.clone, engine ) )
+			ctn = ConstantTestNode.init( "coo1", ConstantObjectOperation.init( MK::EqualityTest.init( 5 ), "@val1", true ), engine, nil )
+			ins = InstantiatorNode.init( prod, "ins", engine )
+			ctn.makeChildConnection( ins )
+			engine.root = ctn
+			
+			engine.addObject( object2 )
+			assert( engine.workingMemoryElements.size == 1, "Working memory elements should have size of 1 but is: #{engine.workingMemoryElements.size}" )
+			engine.addObject( object1 )
+
+			assert( engine.workingMemoryElements.size == 0, "Working memory shouldn't have any elements in it, but has #{engine.workingMemoryElements.size} of them" )
+    end      
+
+    def self.suite
+      suite = Test::Unit::TestSuite.new 
+      suite << self.new( 'test_delete' )
+      suite
+    end
+
+  end
+
+  require 'test/unit/ui/console/testrunner'
+
+  Test::Unit::UI::Console::TestRunner.run( Test_Action_Object_Delete )
+
+end

data/khammurabi-0.2/tests/test_action_object_insert.rb

@@ -0,0 +1,89 @@
+module MK
+
+  require 'test/unit'
+  require 'stringio'
+
+  require 'nist/khammurabi/Engine'
+  require 'nist/khammurabi/InstantiatorNode'
+  require 'nist/khammurabi/ObjectProduction'
+  require 'nist/khammurabi/ArrayAddon'
+  require 'nist/khammurabi/GraphNode'
+  require 'nist/khammurabi/ValueTestSuite'
+	require 'nist/khammurabi/ReteParseTreePrinter'
+	require 'nist/khammurabi/ActionObjectModifyWorkingMemory'
+	require 'nist/khammurabi/Pair'
+	require 'nist/khammurabi/MultiChildrenSelectorNode'
+	require 'nist/khammurabi/ActionObjectInsert'
+	require 'nist/khammurabi/Message'
+	
+  class Tester_AOI
+    attr :val1, true
+    attr :val2, true
+    attr :val3, true
+
+    def initialize
+      @val1 = @val2 = @val3 = nil
+    end
+		def to_s 
+				"val1: #{self.val1} val2: #{self.val2} val3: #{self.val3}"
+		end
+		def ==( other )
+			( self.val1 == other.val1 and self.val2 == other.val2 and self.val3 == other.val3 )
+		end
+  end
+
+  class Tester2_AOI
+    attr :val0, true
+    attr :val1, true
+    attr :val2, true
+    attr :val3, true
+
+    def initialize
+      @val0 = @val1 = @val2 = @val3 = nil
+    end
+
+  end
+
+  class Test_Action_Object_Insert < Test::Unit::TestCase
+
+    attr_accessor :graphA
+
+    def objectA
+      t = Tester_AOI.new
+      t.val1 = 5
+      t.val2 = 10
+      #t.val3 = 15
+      t
+    end
+
+    def test_insert
+			object1 = objectA
+
+			engine = MK::Engine.new
+
+			prod1 = ObjectProduction.new
+			prod1.actions.push( MK::ActionObjectInsert.init( MK::Message.init( "it worked" ), engine ) )
+
+			ctn1 = MK::ConstantTestNode.init( "coo1", MK::ConstantObjectOperation.init( MK::EqualityTest.init( 5 ), "@val1", true ), engine, nil )
+			ins1 = MK::InstantiatorNode.init( prod1, "ins", engine )
+			ctn1.makeChildConnection( ins1 )
+
+			engine.root = ctn1
+
+			engine.addObject( object1 )
+			assert( engine.messages.size == 1, "The engine has #{engine.messages.size} when it should have 1" )
+    end
+
+    def self.suite
+      suite = Test::Unit::TestSuite.new 
+      suite << self.new( 'test_insert' )
+      suite
+    end
+
+  end
+
+  require 'test/unit/ui/console/testrunner'
+
+  Test::Unit::UI::Console::TestRunner.run( Test_Action_Object_Insert )
+
+end

data/khammurabi-0.2/tests/test_action_object_modify.rb

@@ -0,0 +1,103 @@
+module MK
+
+  require 'test/unit'
+  require 'stringio'
+
+  require 'nist/khammurabi/Engine'
+  require 'nist/khammurabi/InstantiatorNode'
+  require 'nist/khammurabi/ObjectProduction'
+  require 'nist/khammurabi/ArrayAddon'
+  require 'nist/khammurabi/GraphNode'
+  require 'nist/khammurabi/ValueTestSuite'
+	require 'nist/khammurabi/ReteParseTreePrinter'
+	require 'nist/khammurabi/ActionObjectModifyWorkingMemory'
+	require 'nist/khammurabi/Pair'
+	require 'nist/khammurabi/MultiChildrenSelectorNode'
+	require 'nist/khammurabi/ActionObjectInsert'
+	require 'nist/khammurabi/Message'
+	
+  class Tester_AOM
+    attr :val1, true
+    attr :val2, true
+    attr :val3, true
+
+    def initialize
+      @val1 = @val2 = @val3 = nil
+    end
+		def to_s 
+				"val1: #{self.val1} val2: #{self.val2} val3: #{self.val3}"
+		end
+		def ==( other )
+			( self.val1 == other.val1 and self.val2 == other.val2 and self.val3 == other.val3 )
+		end
+  end
+
+  class Tester2_AOM
+    attr :val0, true
+    attr :val1, true
+    attr :val2, true
+    attr :val3, true
+
+    def initialize
+      @val0 = @val1 = @val2 = @val3 = nil
+    end
+
+  end
+
+  class Test_Action_Object_Modify < Test::Unit::TestCase
+
+    attr_accessor :graphA
+
+    def objectA
+      t = Tester_AOM.new
+      t.val1 = 5
+      t.val2 = 10
+      #t.val3 = 15
+      t
+    end
+
+		# This test cheats in the graph construction
+    def test_modify
+			object1 = objectA
+			object2 = objectA
+			object2.val1 = 6
+		
+			engine = MK::Engine.new
+
+			prod1 = MK::ObjectProduction.new
+			prod1.actions.push( MK::ActionObjectModifyWorkingMemory.init( object2.clone, MK::Pair.init( "@val1", 7 ), engine ) )
+			prod2 = ObjectProduction.new
+			prod2.actions.push( MK::ActionObjectInsert.init( MK::Message.init( "it worked" ), engine ) )
+
+			mcsn = MK::MultiChildrenSelectorNode.init( "mcsn", engine, false )
+			ctn1 = MK::ConstantTestNode.init( "coo1", MK::ConstantObjectOperation.init( MK::EqualityTest.init( 5 ), "@val1", true ), engine, nil )
+			ctn2 = MK::ConstantTestNode.init( "coo2", MK::ConstantObjectOperation.init( MK::EqualityTest.init( 7 ), "@val1", true ), engine, nil )
+			mcsn.makeChildConnection( ctn1 )
+			mcsn.makeChildConnection( ctn2 )
+			ins1 = MK::InstantiatorNode.init( prod1, "ins", engine )
+			ins2 = MK::InstantiatorNode.init( prod2, "ins", engine )
+			ctn1.makeChildConnection( ins1 )
+			ctn2.makeChildConnection( ins2 )
+
+			engine.root = mcsn
+			#[ mcsn, ctn1, ctn2, joiner, ins ].each { |o| o.debug = true }
+			
+			engine.addObject( object2 )
+			assert( engine.workingMemoryElements.size == 1, "Working memory elements should have size of 1 but is: #{engine.workingMemoryElements.size}" )
+			engine.addObject( object1 )
+			assert( engine.messages.size == 1, "The engine has #{engine.messages.size} when it should have 1" )
+    end      
+
+    def self.suite
+      suite = Test::Unit::TestSuite.new 
+      suite << self.new( 'test_modify' )
+      suite
+    end
+
+  end
+
+  require 'test/unit/ui/console/testrunner'
+
+  Test::Unit::UI::Console::TestRunner.run( Test_Action_Object_Modify )
+
+end

data/khammurabi-0.2/tests/test_array_addon.rb

@@ -0,0 +1,214 @@
+module MK
+
+  require 'test/unit'
+  require 'stringio'
+	require 'nist/khammurabi/ArrayAddon'
+	require 'nist/khammurabi/HashAddon'
+	
+	class Tester
+    attr :val1, true
+    attr :val2, true
+    attr :val3, true
+
+    def initialize
+      @val1 = @val2 = @val3 = nil
+    end
+		def setValues( a, b, c )
+			@val1 = a
+			@val2 = b
+			@val3 = c
+		end
+		def to_s 
+      "val1: #{self.val1} val2: #{self.val2} val3: #{self.val3}"
+		end
+  end
+
+  class Tester2
+    attr :val0, true
+    attr :val1, true
+    attr :val2, true
+    attr :val3, true
+
+    def initialize
+      @val0 = @val1 = @val2 = @val3 = nil
+    end
+		def setValues( a, b, c, d )
+			@val0 = a
+			@val1 = b
+			@val2 = c
+			@val3 = d
+		end
+  end
+
+	class Test_Array_Addon < Test::Unit::TestCase
+    
+		def objectA
+      t = Tester.new
+      t.val1 = 5
+      t.val2 = 10
+      #t.val3 = 15
+      t
+    end
+
+		def objectB
+      t = Tester2.new
+      t.val1 = 5
+      t.val2 = 10
+      t.val3 = 15
+      t
+    end
+
+		def objectC
+      t = Tester2.new
+      t.val1 = 50
+      t.val2 = 100
+      t.val3 = 150
+      t
+    end
+
+		def test_swap
+			arr = [ 1, 2, 3, 4 ]
+			otherArray = arr.swap( 1, 2 )
+			assert( !otherArray.equal?( arr ), "otherArray.equal?( arr )" )
+			assert( otherArray == [ 1, 3, 2, 4 ], "otherArray != [ 1, 3, 2, 4 ] but is #{otherArray.join( " " )}" )
+			otherArray = arr.swap( 1, 8 )
+			assert( otherArray == [ 1, 2, 3, 4 ], "otherArray != [ 1, 2, 3, 4 ] but is #{otherArray.join( " " )}" )
+		end
+		
+		def test_swap!
+			arr = [ 1, 2, 3, 4 ]
+			arr.swap!( 1, 2 )
+			assert( arr == [ 1, 3, 2, 4 ], "arr != [ 1, 3, 2, 4 ]" )
+			arr.swap!( 1, 8 )
+			assert( arr == [ 1, 3, 2, 4 ], "arr != [ 1, 3, 2, 4 ]" )
+		end
+		
+		def test_push_unique
+			arr = Array.new
+			f = 5
+			g = 5
+			h = 6
+			arr.pushUnique( f )
+			arr.pushUnique( g )
+			assert( arr.size == 1, "arr.size != 1 but is #{arr.size}" )
+			arr.pushUnique( h )
+			assert( arr.size == 2, "arr.size != 2 but is #{arr.size}" )
+		end
+		
+		def test_push_uniqueID
+			arr = Array.new
+			f = "hello"
+			g = "hi"
+			arr.pushUniqueID( f )
+			arr.pushUniqueID( f )
+			assert( arr.size == 1, "arr.size != 1 but is #{arr.size}" )
+			arr.pushUniqueID( g )
+			assert( arr.size == 2, "arr.size != 2 but is #{arr.size}" )
+		end
+		
+		# The permutations are gauranteed to have unique elements, so it suffices to check the size only
+		# With an object that takes long to copy, this could become unwieldly
+		def test_permutations
+			arr = [ 1, 2 ]
+			permutationsArray = arr.permutations
+			permutations = permutationsArray.first
+			record = permutationsArray.second
+			assert( permutations.size == 2, "Fail 2, it is: #{permutations.size}" )
+			assert( record[ 0 ][ 0 ] == 0, "(0) != 0 but is: #{record[ 0 ][ 0 ]}" )
+			assert( record[ 1 ][ 0 ] == 1, "(1) != 1 but is: #{record[ 1 ][ 0 ]}" )
+			assert( record[ 0 ][ 1 ] == 1, "(2) != 1 but is: #{record[ 0 ][ 1 ]}" )
+			assert( record[ 1 ][ 1 ] == 0, "(3) != 0 but is: #{record[ 1 ][ 1 ]}" )
+			
+			arr = [ 1, 2, 3, 4 ]
+			permutationsArray = arr.permutations
+			permutations = permutationsArray.first
+			records = permutationsArray.second
+			assert( permutations.size == 24, "permutations.size != 24, but should be (it is #{permutations.size})" )
+
+			arr = [ 1, 2, 3, 4, 5, 6 ]
+			permutationsArray = arr.permutations
+			permutations = permutationsArray.first
+			records = permutationsArray.second
+			assert( permutations.size == 720, "permutations.size != 720, but should be (it is #{permutations.size})" )
+		end
+
+		def test_permutations1
+			arr = [ 1, 2, 3 ]
+			permutationsArray = arr.permutations
+			permutations = permutationsArray.first
+			records = permutationsArray.second
+			assert( permutations.size == 6, "permutations.size != 6, but should be (it is #{permutations.size})" )
+
+			#print "permutations: "
+			#permutations.each do |permutation|
+			#	print "#{permutation.join( " " )}\n"
+			#end
+			#print "records: "
+			#records.each_index do |recordIndex|
+			#	record = records[ recordIndex ]
+			#	print "#{record.join( " => ", ", " )}\n"
+			#end
+		end
+
+		# Tests permutations using real objects
+		def test_permutations2
+			arr = [ objectA, objectB ]
+			permutationsArray = arr.permutations
+			permutations = permutationsArray.first
+			assert( permutations.size == 2, "permutations.size != 2, but should be (it is #{permutations.size})" )
+			
+			arr = [ objectA, objectB, objectC ]
+			permutationsArray = arr.permutations
+			permutations = permutationsArray.first
+			assert( permutations.size == 6, "permutations.size != 6, but should be (it is #{permutations.size})" )
+		end
+
+		def test_rejectID!
+			ree = "Hi"
+			ree2 = "Ho"
+			arr = [ ree, ree2 ]
+			arr.rejectID!( ree )
+			assert( arr.size == 1, "arr.size != 1" )
+		end
+
+		def test_rejectID
+			ree = "Hi"
+			ree2 = "Ho"
+			arr = [ ree, ree2 ]
+			newarr = arr.rejectID( ree )
+			assert( arr.size == 2, "arr.size != 2" )
+			assert( newarr.size == 1, "newarr.size != 1" )
+		end
+
+		def test_minimum
+			arr = [ 5, 4, 3, 2, 1 ]
+			assert( arr.minimum == 1, "It's not 1, but is #{arr.minimum})" )
+
+			arr = [ "Hello there", 3 ]
+			assert( arr.minimum == nil, "It's not nil, but is #{arr.minimum}" )
+
+			arr = [ 5, 4, 3, 2, 1, 10, -5, 234234234, 33, 1 ]
+			assert( arr.minimum == -5, "It's not -5, but is #{arr.minimum})" )		
+		end
+		
+    def self.suite
+      suite = Test::Unit::TestSuite.new 
+			suite << self.new( 'test_swap' )
+			suite << self.new( 'test_swap!' )
+			suite << self.new( 'test_push_unique' )
+			suite << self.new( 'test_push_uniqueID' )
+      #suite << self.new( 'test_permutations' )
+      suite << self.new( 'test_permutations1' )
+      #suite << self.new( 'test_permutations2' )
+			suite << self.new( 'test_rejectID!' )
+			suite << self.new( 'test_minimum' )
+      suite
+    end
+
+  end
+
+  require 'test/unit/ui/console/testrunner'
+
+  Test::Unit::UI::Console::TestRunner.run( Test_Array_Addon )
+
+end