RubyGems - khammurabi - Versions diffs - 0.2 - Mend

khammurabi 0.2

Files changed (597) hide show

data/khammurabi-0.2/docs/index.html ADDED

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!DOCTYPE html
+     PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN"
+     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">
+<!--
+    khammurabi
+  -->
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+  <title>khammurabi</title>
+  <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
+</head>
+<frameset rows="20%, 80%">
+    <frameset cols="25%,35%,45%">
+        <frame src="fr_file_index.html"   title="Files" name="Files" />
+        <frame src="fr_class_index.html"  name="Classes" />
+        <frame src="fr_method_index.html" name="Methods" />
+    </frameset>
+    <frame src="files/ReadMe_txt.html" name="docwin" />
+</frameset>
+</html>

data/khammurabi-0.2/docs/rdoc-style.css ADDED

@@ -0,0 +1,208 @@
+body {
+    font-family: Verdana,Arial,Helvetica,sans-serif;
+    font-size:   90%;
+    margin: 0;
+    margin-left: 40px;
+    padding: 0;
+    background: white;
+}
+h1,h2,h3,h4 { margin: 0; color: #efefef; background: transparent; }
+h1 { font-size: 150%; }
+h2,h3,h4 { margin-top: 1em; }
+a { background: #eef; color: #039; text-decoration: none; }
+a:hover { background: #039; color: #eef; }
+/* Override the base stylesheet's Anchor inside a table cell */
+td > a {
+  background: transparent;
+  color: #039;
+  text-decoration: none;
+}
+/* and inside a section title */
+.section-title > a {
+  background: transparent;
+  color: #eee;
+  text-decoration: none;
+}
+/* === Structural elements =================================== */
+div#index {
+    margin: 0;
+    margin-left: -40px;
+    padding: 0;
+    font-size: 90%;
+}
+div#index a {
+    margin-left: 0.7em;
+}
+div#index .section-bar {
+   margin-left: 0px;
+   padding-left: 0.7em;
+   background: #ccc;
+   font-size: small;
+}
+div#classHeader, div#fileHeader {
+    width: auto;
+    color: white;
+    padding: 0.5em 1.5em 0.5em 1.5em;
+    margin: 0;
+    margin-left: -40px;
+    border-bottom: 3px solid #006;
+}
+div#classHeader a, div#fileHeader a {
+    background: inherit;
+    color: white;
+}
+div#classHeader td, div#fileHeader td {
+    background: inherit;
+    color: white;
+}
+div#fileHeader {
+    background: #057;
+}
+div#classHeader {
+    background: #048;
+}
+.class-name-in-header {
+  font-size:  180%;
+  font-weight: bold;
+}
+div#bodyContent {
+    padding: 0 1.5em 0 1.5em;
+}
+div#description {
+    padding: 0.5em 1.5em;
+    background: #efefef;
+    border: 1px dotted #999;
+}
+div#description h1,h2,h3,h4,h5,h6 {
+    color: #125;;
+    background: transparent;
+}
+div#validator-badges {
+    text-align: center;
+}
+div#validator-badges img { border: 0; }
+div#copyright {
+    color: #333;
+    background: #efefef;
+    font: 0.75em sans-serif;
+    margin-top: 5em;
+    margin-bottom: 0;
+    padding: 0.5em 2em;
+}
+/* === Classes =================================== */
+table.header-table {
+    color: white;
+    font-size: small;
+}
+.type-note {
+    font-size: small;
+    color: #DEDEDE;
+}
+.xxsection-bar {
+    background: #eee;
+    color: #333;
+    padding: 3px;
+}
+.section-bar {
+   color: #333;
+   border-bottom: 1px solid #999;
+    margin-left: -20px;
+}
+.section-title {
+    background: #79a;
+    color: #eee;
+    padding: 3px;
+    margin-top: 2em;
+    margin-left: -30px;
+    border: 1px solid #999;
+}
+.top-aligned-row {  vertical-align: top }
+.bottom-aligned-row { vertical-align: bottom }
+/* --- Context section classes ----------------------- */
+.context-row { }
+.context-item-name { font-family: monospace; font-weight: bold; color: black; }
+.context-item-value { font-size: small; color: #448; }
+.context-item-desc { color: #333; padding-left: 2em; }
+/* --- Method classes -------------------------- */
+.method-detail {
+    background: #efefef;
+    padding: 0;
+    margin-top: 0.5em;
+    margin-bottom: 1em;
+    border: 1px dotted #ccc;
+}
+.method-heading {
+  color: black;
+  background: #ccc;
+  border-bottom: 1px solid #666;
+  padding: 0.2em 0.5em 0 0.5em;
+}
+.method-signature { color: black; background: inherit; }
+.method-name { font-weight: bold; }
+.method-args { font-style: italic; }
+.method-description { padding: 0 0.5em 0 0.5em; }
+/* --- Source code sections -------------------- */
+a.source-toggle { font-size: 90%; }
+div.method-source-code {
+    background: #262626;
+    color: #ffdead;
+    margin: 1em;
+    padding: 0.5em;
+    border: 1px dashed #999;
+    overflow: hidden;
+}
+div.method-source-code pre { color: #ffdead; overflow: hidden; }
+/* --- Ruby keyword styles --------------------- */
+.standalone-code { background: #221111; color: #ffdead; overflow: hidden; }
+.ruby-constant  { color: #7fffd4; background: transparent; }
+.ruby-keyword { color: #00ffff; background: transparent; }
+.ruby-ivar    { color: #eedd82; background: transparent; }
+.ruby-operator  { color: #00ffee; background: transparent; }
+.ruby-identifier { color: #ffdead; background: transparent; }
+.ruby-node    { color: #ffa07a; background: transparent; }
+.ruby-comment { color: #b22222; font-weight: bold; background: transparent; }
+.ruby-regexp  { color: #ffa07a; background: transparent; }
+.ruby-value   { color: #7fffd4; background: transparent; }

data/khammurabi-0.2/lib/nist/khammurabi/ActionObjectDelete.rb ADDED

@@ -0,0 +1,35 @@
+module MK
+  require 'nist/khammurabi/ObjectProductionAction'
+  require 'nist/khammurabi/ObjectAddon'
+  # This class deletes an Object from the Engine. This is different from deleting it from
+	# the working memory -- the working memory usually contains elements that aren't matches yet
+	# by the Engine. Objects that are 'in' the Engine usually refer to objects that are waiting
+	# to be matched in a VariableTestNode.
+  # It can handle multiple objects to delete from the graph
+	class ActionObjectDelete < ObjectProductionAction
+    attr :deleteObjects, true # Object to input into the graph
+    def ActionObjectDelete.init( deleteObjects, engine )
+      deleteObjects = [ deleteObjects ] if deleteObjects.class != Array and deleteObjects.class != Set
+			aod = ActionObjectDelete.new
+      aod.deleteObjects = deleteObjects
+      aod.engine = engine
+      aod
+    end
+		def initialize
+			self.deleteObjects = Array.new
+			self
+		end
+    # Inserts each object in deleteObjects into the working memory
+    def execute
+      self.deleteObjects.each { |object| self.engine.deleteTokensWithObject( object ) }
+    end
+  end
+end

data/khammurabi-0.2/lib/nist/khammurabi/ActionObjectDeleteFromWorkingMemory.rb ADDED

@@ -0,0 +1,34 @@
+module MK
+  require 'nist/khammurabi/ObjectProductionAction'
+  require 'nist/khammurabi/ObjectAddon'
+  # This class deletes objects from working memory. These elements generally
+	# are those who aren't able to be matched by the engine. To delete objects that
+	# are actually in the graph, use ActionObjectDelete.
+  # It can handle multiple objects to delete from working memory
+	class ActionObjectDeleteFromWorkingMemory < ObjectProductionAction
+    attr :deleteObjects, true # Object to input into the graph
+    def ActionObjectDeleteFromWorkingMemory.init( deleteObjects, engine )
+      deleteObjects = [ deleteObjects ] if deleteObjects.class != Array
+			aod = ActionObjectDeleteFromWorkingMemory.new
+      aod.deleteObjects = deleteObjects
+      aod.engine = engine
+      aod
+    end
+		def initialize
+			self.deleteObjects = Array.new
+			self
+		end
+    # Inserts each object in deleteObjects into the working memory
+    def execute
+			self.deleteObjects.each { |object| self.engine.deleteTokensFromWorkingMemoryWithObject( object ) }
+    end
+  end
+end

data/khammurabi-0.2/lib/nist/khammurabi/ActionObjectInsert.rb ADDED

@@ -0,0 +1,29 @@
+module MK
+  require 'nist/khammurabi/ObjectProductionAction'
+  require 'nist/khammurabi/ObjectAddon'
+  # This class inserts an Object into the working memory when executed
+  # It comes at the end of the GraphNode tree, and it accessed through the
+  # leaf method in the Engine class
+  # It can handle multiple objects to insert back into the working memory
+	class ActionObjectInsert < ObjectProductionAction
+    attr :inputObjects, true # Object to input into the graph
+    def ActionObjectInsert.init( inputObjects, engine )
+      inputObjects = [ inputObjects ] if inputObjects.class != Array
+      actionObjectInsert = ActionObjectInsert.new
+      actionObjectInsert.inputObjects = inputObjects
+      actionObjectInsert.engine = engine
+      actionObjectInsert
+    end
+    # Inserts each object in inputObjects into the working memory
+    def execute
+      self.inputObjects.each { |inputObject| engine.addObject( inputObject ) }
+    end
+  end
+end

data/khammurabi-0.2/lib/nist/khammurabi/ActionObjectModifyWorkingMemory.rb ADDED

@@ -0,0 +1,53 @@
+module MK
+  require 'nist/khammurabi/ObjectProductionAction'
+  require 'nist/khammurabi/ObjectAddon'
+	require 'nist/khammurabi/Pair'
+	require 'nist/khammurabi/ArrayAddon'
+	# Objects of this class modify objects in the working memory elements by
+	# changing values of their variables given by the pairs variable
+	class ActionObjectModifyWorkingMemory < ObjectProductionAction
+    attr :templateObject, true # Object to input into the graph
+		attr :pairs, true          # Array( Pair( @variableName, newValue ) ) of variables to change
+    def ActionObjectModifyWorkingMemory.init( templateObject, pairs, engine )
+			pairs = [ pairs ] if pairs.class != Array
+			aom = ActionObjectModifyWorkingMemory.new
+			aom.templateObject = templateObject
+			aom.pairs = pairs
+			aom.engine = engine
+      aom
+    end
+		def initialize
+			self.templateObject = nil
+			self.pairs = Array.new
+			self
+		end
+    # Inserts each object in deleteObjects into the working memory
+    def execute
+			changedWMEs = Array.new
+			self.engine.workingMemoryElements.each do |wme|
+				ogws = wme.objectGraphWrappers
+				objectsToModify = Array.new
+				wme.objectGraphWrappers.each do |ogw|
+					if ogw.object == self.templateObject
+						objectsToModify.push( ogw.object )
+					end
+				end # wme.objectGraphWrappers.each do |ogw|
+				next if objectsToModify.size == 0
+				objectsToModify.each do |otm|
+					self.pairs.each do |pair|
+						otm.instance_eval( "#{pair.first} = #{pair.second}" )
+					end # self.pairs.each do |pair|
+				end # objectsToModify.each |otm|
+				self.engine.workingMemoryElementWasChanged( wme )
+			end # self.engine.workingMemoryElements.each do |wme|
+		end # def execute
+  end
+end

data/khammurabi-0.2/lib/nist/khammurabi/ActionOutput.rb ADDED

@@ -0,0 +1,45 @@
+module MK
+  require 'stringio'
+  require 'nist/khammurabi/ObjectProductionAction'
+  require 'nist/khammurabi/ObjectAddon.rb'
+  # This is a simple class that outputs its outputString to stdout when executed
+  class ActionOutput < ObjectProductionAction
+    attr :outputString, true  # string to output
+    attr :appendReturn, true  # append \n to end of output string?
+    def ActionOutput.init( outputString, engine )
+      actionOutput = ActionOutput.new
+      actionOutput.outputString = outputString
+      actionOutput.engine = engine
+      actionOutput.appendReturn = true
+      actionOutput
+    end
+    def initialize
+      super
+      self.outputString = String.new
+      self
+    end
+    # Prints outputString to stdout.
+    # Also prints "\n" if appendReturn is true
+    def execute
+      print "#{self.outputString}"
+      self.appendReturn == true and print "\n"
+    end
+    # Prints object data onto stream
+    def printOn( stream )
+      stream << "<ActionOutput> outputString: <#{self.outputString}> </ActionOutput>"
+      stream
+    end
+    # Calls printOn( stdout )
+    def to_s; self.printOn( StringIO.new ).string; end
+  end
+end

data/khammurabi-0.2/lib/nist/khammurabi/ArbitratorNode.rb ADDED

@@ -0,0 +1,68 @@
+module MK
+	require 'nist/khammurabi/GraphNode'
+	# Provides a framework for a node with multiple children, but which has conditions on when to
+	# pass tokens to those children (IE, RootNode has no conditions -- it just sends every token to every child)
+	class ArbitratorNode < GraphNode
+		attr :nodeIndex, true # Fixnum .. which node to use
+		attr :multiChildren, true
+		attr :level, true
+    def ArbitratorNode.init( engine )
+      mcan = ArbitratorNode.new
+      mcan.engine = engine
+      mcan
+    end
+    def initialize
+      super
+      self.maxChildren = -1
+      self.nodeIndex = 0
+      self.multiChildren = Array.new
+			self.level = -1
+			@registeringNormalChild = false # See below for description
+			@managingTokens = true
+      self
+    end
+    # Adds a child. Set registeringNormalChild to true to add the child normally,
+		# set it to false to add it to the multichildren (it should be true during execute (see
+		# MultiChildrenArbitratorNode for an example))
+    def addChild( child )
+      if @registeringNormalChild == true
+	  		super
+      else
+	  	#print "Adding a multiChild... its name: #{child.name}\n"
+				self.multiChildren.push( child )
+      end
+    end
+		def tokenFailed( token )
+			if @managingToken.equal?( token )
+				self.arbitrateLastNodeIndex
+			end
+		end
+    # Wraps index around when it gets too large (larger than the # of nodes)
+    def arbitrateNextNodeIndex
+      if self.nodeIndex < @multiChildren.size - 1
+	  		self.nodeIndex = self.nodeIndex + 1
+      else
+	  		self.nodeIndex = 0
+      end
+    end
+		def arbitrateLastNodeIndex
+      if self.nodeIndex > 0 # @multiChildren.size - 1
+	  		self.nodeIndex = self.nodeIndex - 1
+      else
+	  		self.nodeIndex = @multiChildren.size - 1
+      end
+    end
+		def representative; self.multiChildren.first; end
+	end
+end