RubyGems - xiacc - Versions diffs - 0.1 - Mend

xiacc 0.1

Files changed (1037) hide show

@@ -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">
+<!--
+    pippin
+  -->
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+  <title>pippin</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/pippin-0.1/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/pippin-0.1/lib/nist/pippin/pippin.rb ADDED

@@ -0,0 +1,620 @@
+#!/usr/bin/env ruby
+require 'nist/pippin/roog'
+require 'rexml/streamlistener'
+require 'rexml/document'
+require 'nist/common/associative_array'
+require 'nist/common/treeDump'
+# This is a parser that instantiates the classes defined by roog,
+# based on an XML file.
+#
+# Pippin isn't an acronym: it's named after a cat. She died of
+# of lymphatic cancer, which apparently is common in older
+# cats. As much as I like this tool, I would rather have her
+# back again, hairballs and all.
+#
+# Author: A. Griesser
+# NOTE:
+# Not certain that Roog::Class.isSimple matches Semantics_Ruby@@transformers.keys
+module Pippin
+class Policy
+# If true, and if :parent_attributeName is not nil, unmarshaled "simple" objects which were
+# held as XML attributes are given an attribute holding the parent. This does not apply
+# to direct attributes.
+attr_accessor :setParentOf_simpleAttribute
+# If true, and if :parent_attributeName is not nil, unmarshaled "simple" objects which were
+# held as XML children (elements) are given an attribute holding the parent.
+# Simple is defined by Roog::Class.isSimple
+attr_accessor :setParentOf_simpleChild
+# If true, and if :parent_attributeName is not nil, unmarshaled non-simple objects which were
+# held as XML children (elements) are given an attribute holding the parent.
+# Simple is defined by Roog::Class.isSimple
+attr_accessor :setParentOf_complexChild
+# Name of attribute used to cache an object's unmarshaled parent object.
+# If nil, the parent is not stored. If not nil, must begin with @.
+# Observe that a getter is created only if parent_getter is not nil.
+# When the object is held by a collection, it's the collection holder
+# that gets stored, rather than the collection.
+# Note: Pippin only marshals attributes specified by Roog, so we don't
+# need to tell Pippin to ignore this attribute.
+attr_accessor :parent_attributeName
+# Name of a getter for parent_attributeName. If nil, does not
+# create getter. If not nil, must not begin with @.
+# The getter is not created if the attribute is not created.
+# Note that this getter is singleton method. A "best effort" is
+# made to create the getter. In some cases (Floats are an example)
+# Ruby refuses to create the getter. In that case a debug message is issued.
+# Possibly this should be a warning instead of a debug... but you have
+# already been warned here that getter creation can fail, and if you
+# have a lot of floats, the warngings can be a nuisance.
+attr_accessor :parent_getter
+# XML header that is used if no header is specified
+attr_accessor :default_header
+# Keys are domain attribute names (with '@'), values are xml attribute names.
+# These are not processed through Roog, but are instead transfered directly to/from the domain objects.
+attr_accessor :direct_attribute_map_marshalling
+# Keys are xml names, values are domain attribute names.
+attr_accessor :direct_attribute_map_unmarshalling
+def initialize
+	self.setParentOf_simpleAttribute=false
+	self.setParentOf_simpleChild=false
+	self.setParentOf_complexChild=false
+	self.parent_getter='_pippin_parent'
+	self.parent_attributeName='@_pippin_parent'
+	self.default_header='<?xml version="1.0" encoding="UTF-8"?>'
+	self.direct_attribute_map_marshalling= { '@_xmlns'=>'xmlns', '@_xmlns_xsi'=>'xmlns:xsi', '@_xsi_schemaLocation'=>'xsi:schemaLocation' }
+	self.direct_attribute_map_unmarshalling = direct_attribute_map_marshalling.invert
+end
+# kidIsAttribute should be true if the kid comes from an XML attribute.
+# kidIsSimple should match Roog::Class.isSimple
+def setParent?(kidIsAttribute, kidIsSimple)
+	return false if parent_attributeName.nil?
+	return setParentOf_simpleAttribute if kidIsAttribute
+	return setParentOf_simpleChild if kidIsSimple
+	setParentOf_complexChild
+end
+def setParentOf_all=(boolean)
+	self.setParentOf_simpleAttribute=boolean
+	self.setParentOf_simpleChild=boolean
+	self.setParentOf_complexChild=boolean
+end
+@@default=self.new
+def self.default; @@default; end
+end # Policy
+# ===========================================================================================================
+	class Parser
+	include REXML::StreamListener
+	attr_accessor :processor, :stack, :policy
+	# processor must respond to:
+	#	started(newEntry, parentEntry)    called at the end of tag_start
+	#	ended(newEntry, parentEntry)       called at the end of tag_end
+	#	clear                                         called at the start of parse, to discard state from previous parse
+	def initialize(analyzer, processor=nil)
+		@processor=processor
+		@analyzer = analyzer
+		@stack = Array.new
+		@file = nil
+		@tagWithXPath = true
+		@rootStackEntry = nil
+		@policy=Policy.default.clone
+	end
+	# Public API
+	# FIXME - make this work with an IO
+	# Creates a graph of objects from an XML file.
+	# You must already have loaded code defining domain objects.
+	# Reads the specified file, and returns the root of the graph
+	# of domain objects. Domain object are expected to:
+	#	* have a no-argument constuctor
+	#	* have getters for all collections, and
+	#		setters for everything else.
+	def parse(fileName)
+		@stack.clear
+		@processor.clear if @processor!=nil
+		@file = File.new(fileName)
+		assert { "Failed to open file: #{fileName}" if @file==nil }
+		assert { 'Analyzer should not be nil' if @analyzer==nil }
+		REXML::Document.parse_stream(@file, self)
+		graph = @rootStackEntry.domainObj
+	ensure
+		@file.close if @file!=nil  # file is nil if an exeption occured before it opened.
+		graph
+	end
+	# StreamListener overrides
+	def tag_start(elementName, attrs)
+		parentEntry = tos
+		newEntry = StackEntry.new(elementName, attrs, policy)
+		push(newEntry)
+		populateNewEntry(parentEntry, newEntry)
+		# At this point newEntry has @roogClass, @roogAttribute,
+		# @elementName, and @attrs. We have not yet filled
+		# @texts or @cached, and @domainObj has not been constructed.
+		# That does not happen until makeAndPopulateDomainObj in tag_end
+		processor.started(newEntry, parentEntry) if processor!=nil
+	end
+	def tag_end(name)
+		newEntry = pop
+		expected = newEntry.elementName
+		assert { "Found </#{name}> but expected </#{expected}>" if name!=expected }
+		newEntry.makeAndPopulateDomainObj
+		parentEntry = tos
+		parentEntry.cache(newEntry) if parentEntry!=nil
+		# At this point newEntry is fully populated. Note however,
+		# that parentEntry is not.
+		processor.ended(newEntry, parentEntry) if processor!=nil
+	end
+	def text(text)
+		return if !text
+		if tos
+			tos.texts << text
+		else
+			# Ignore whitespace
+			negligible = text.strip.empty?
+			print "\nUnexpected text node without tos: #{text.to_s} " if !negligible
+		end
+	end
+	protected # internal methods
+	# Utilities
+	def push(newEntry)
+		if @rootStackEntry==nil
+			@rootStackEntry = newEntry
+			end
+		@stack.push newEntry
+	end
+	def pop
+		return @stack.pop
+	end
+	# Stands for "top of stack".
+	# Returns nil if the stack is empty
+	def tos
+		return @stack.last
+	end
+	# Returns stack element immediately inder the tos.
+	# This is what you would get if you did :tos
+	# after a :pop.
+	# Returns nil if the stack has less than two elements.
+	def under
+		return @stack[@stack.size - 1]
+	end
+	# Makes as much info as possible, except for the actual domainObj
+	def populateNewEntry(parentEntry, newEntry)
+		if parentEntry==nil
+			xmlClassName = @analyzer.schemaTypeForGlobalElementName(newEntry.elementName)
+			newEntry.roogClass = @analyzer.classNamed(xmlClassName)
+			return
+			end
+		xmlName = newEntry.elementName
+		attribute = parentEntry.roogClass.attributeForXMLName(xmlName)
+		newEntry.roogAttribute = attribute
+		newEntry.roogClass = attribute.concreteClassForElementName(xmlName)
+	end
+	end # Parser
+# ===========================================================================================================
+	class StackEntry
+	# :cached contains the StackEntries for child elements.
+		attr_accessor :domainObj, :roogClass, :roogAttribute, :elementName, :attrs, :texts, :cached, :policy
+		def initialize(elementName, attrs, policy)
+			@elementName=elementName
+			@attrs=attrs
+			@policy=policy
+			@texts=Array.new
+			@cached=Array.new
+		end
+		def text
+			texts.join(' ')
+		end
+		def cache(childInstance)
+			cached << childInstance
+		end
+		def has_attributes?
+			! attrs.empty?
+		end
+		def openingTag(close=true)
+			answer = "<"+elementName
+			if has_attributes?
+				attr.each { |attrName, value|
+				answer=answer+" #{attrName}=#{value}"
+				}
+			end
+			if close
+				answer = answer+"/>"
+			else
+				answer = answer+">"
+				end
+			return answer
+		end
+		def makeAndPopulateDomainObj
+			assert { "roogClass must not be nil for element #{openingTag}" if roogClass==nil }
+			self.domainObj = roogClass.instantiateWith(text, self)
+			# Give the domainObj a hint about it's xml element if the schema is ambiguous.
+			if !roogAttribute.nil? && roogAttribute.ambiguous_element_for_class?(roogClass)
+				# Perhaps we should verify that domainObj is not a singleton like nil, true, false, zero
+				domainObj.set_ivar!(roog_policy.hint_attribute_name, elementName)
+				print "\nNotice: set #{roog_policy.hint_attribute_name} to '#{elementName}' in instance of #{domainObj.class.name}" if roog_policy.schema_warnings
+				end
+			return if roogClass.isSimple
+			populateAttributes
+			# Populate domainObj attributes that correspond to xml children.
+			cached.each { |kid|
+				setKid(kid)
+				}
+		end
+		# Populate xml attributes (including direct attributes)
+		def populateAttributes
+			attrs.each { |xmlName, value|
+				# direct attributes are handled here: they are unknown to Roog,
+				# since they are not explicitly declared in the schema. They
+				# include things like namespaces and schema locations.
+				handled = populateDirectAttribute(xmlName, value)
+				if ! handled
+				    # simple attributes (xml attributes, rather than children) are handled here
+				    convertedValue = roogClass.setAttribute(domainObj, xmlName, value, true, self)
+				    setParent(convertedValue, domainObj, true, true)
+				end
+				}
+		end
+		def populateDirectAttribute(xmlName, value)
+			domainAttrName = policy.direct_attribute_map_unmarshalling[xmlName]
+			return false if domainAttrName.nil?
+			domainObj.set_ivar!(domainAttrName, value)
+			true
+		end
+		# Set the kidEntry.domainObj into the receiver's domainObj
+		def setKid(kidEntry)
+			attributeName = kidEntry.elementName
+			kidObj=kidEntry.domainObj
+			convertedValue = roogClass.setAttribute(domainObj, attributeName, kidObj, false, kidEntry)
+			setParent(convertedValue, domainObj, false, kidEntry.roogClass.isSimple)
+		end
+		def setParent(kidObj, parentObj, kidIsXMLAttribute, kidIsSimple)
+			return if kidObj.nil? || ! policy.setParent?(kidIsXMLAttribute, kidIsSimple)
+			kidObj.set_ivar!(policy.parent_attributeName, domainObj)
+			return if policy.parent_getter.nil?
+			begin
+				kidObj.define_getter(policy.parent_getter)
+			rescue
+				debug "Unable to create #{policy.parent_getter} method for instance of #{kidObj.class.name}."
+			end
+		end
+	end # StackEntry
+# ===========================================================================================================
+# Similar to StackEntry: should consolidate.
+class WriteStackEntry
+@@notYetPrinted=false
+# roogAttribute describes domainObj in some (unknown) parent domain object.
+attr_accessor :domainObj, :roogAttribute, :roogClass, :analyzer, :policy
+def initialize(domainObj, roogAttribute, analyzer, policy, roogClass=nil)
+	@analyzer=analyzer   # Perhaps try to eliminate
+	@domainObj=domainObj
+	@roogAttribute=roogAttribute
+	@policy=policy
+	@roogClass= roogClass!=nil ? roogClass : roogAttribute.concreteClassForDomainObject(domainObj, analyzer)
+	if @@notYetPrinted && domainObj.class.name=='ButterflyType'
+		@@notYetPrinted=false
+		domainObj.treeDump(3)
+		@roogClass.treeDump(3)
+		roogAttribute.treeDump(3)
+		end
+end
+def elementName; roogAttribute.element_name_for_class(roogClass, domainObj); end
+def write_element(writer)
+	writer.startTag_open(elementName)
+	write_directAttributes(writer)
+	return write_simple(writer) if roogClass.isSimple
+	write_complex(writer)
+end
+def write_simple(writer)
+	translated = roogClass.toString(domainObj)
+	noContent = translated.empty?
+	writer.startTag_close(noContent)
+	return if noContent
+	writer.cdata(translated)
+	writer.endTag(elementName, false)
+end
+def write_complex(writer)
+	attributeMode=true
+	xmlAttributes, children = roogClass.allAttributes.partition {|attr| !attr.is_xml_child? }
+	xmlAttributes.each {|attr| write_attribute(attr, attr.getValue(domainObj), writer) }
+	# Closing the start tag needs to depend on actual child values, not number of roogAttribues.
+	# Need to keep order.
+	childHash = AssociativeArray.new
+	children.each {|attr|
+		childVal = attr.getValue(domainObj)
+		# FIXME should validate childVal
+		#       should validate childVal position in parent.
+		childHash[attr]=childVal if childVal!=nil && !(childVal.kind_of?(Array) && childVal.empty?)
+		}
+	finished = childHash.empty?
+	writer.startTag_close(finished)
+	return if finished
+	childHash.each {|attr, childVal| write_child(attr, childVal, writer)}
+	writer.endTag(elementName)
+end
+def write_directAttributes(writer)
+	potential = policy.direct_attribute_map_marshalling.keys
+	available = domainObj.instance_variables
+	intersection = potential & available
+	intersection.sort.each {|domainAttribName|
+		xmlName = policy.direct_attribute_map_marshalling[domainAttribName]
+		value = domainObj.get_ivar!(domainAttribName)
+		writer.attribute(xmlName, value) if value
+		}
+end
+def write_attribute(attr, childValue, writer)
+	return if childValue.nil? && !attr.required?
+	attribute_problem(attr, 'is required, must not be nil') if childValue.nil?
+	# Note that attrClass is not @roogClass
+	attrClass = attr.concreteClassForDomainObject(childValue, analyzer)
+	translated = attrClass.toString(childValue)
+	writer.attribute(attr.xmlName, translated)
+end
+def write_child(childAttr, childValue, writer)
+	if childAttr.isCollection
+		# Note that the kids could be of different types.
+		# The childAttr is shared by all the values in the collection.
+		values = childValue.select {|val| val!=nil }
+		size = values.size
+		return if size<1 && !childAttr.required?
+		attribute_problem(childAttr, "only has #{size} values, but #{childAttr.minOccurs} required" ) if size<childAttr.minOccurs
+		attribute_problem(childAttr, "has #{size} values, but only #{childAttr.maxOccurs} allowed" ) if childAttr.maxOccurs!=:unbounded && size>childAttr.maxOccurs
+		values.each {|kid| writer.process(kid, childAttr) }
+	else
+		return if childValue.nil? && !childAttr.required?
+		attribute_problem(childAttr, 'must not be nil') if childValue.nil?
+		writer.process(childValue, childAttr)
+		end
+end
+def attribute_problem(attribute, description)
+	raise "Attribute #{attribute.localName} in #{domainObj.class.name} " + description
+end
+end # WriteStackEntry
+# ===========================================================================================================
+class Writer
+# These should be attributes of a policy object.
+@@indent="\t"
+@@start_indent="\n"
+# Including the equality lets you add spaces if you wish
+@@attribute_prefix='="'
+@@attribute_suffix='"'
+attr_accessor :io, :stack, :analyzer, :close, :policy
+# If we pass it a String instead of an IO, presumes we want to open a file.
+def initialize(io=StringIO.new, analyzer=nil)
+	@close=io.kind_of? String
+	@io= close ? File.open(io, 'w') : io
+	@analyzer= analyzer.nil? ? Roog::Analyzer.instance : analyzer
+	@stack=Array.new
+	@policy=Policy.default.clone
+end
+def self.indent; @@indent; end
+def self.indent=(string); @@indent=string; end
+def indent; Writer.indent; end
+def self.start_indent; @@start_indent; end
+def self.start_indent=(string); @@start_indent=string; end
+def start_indent; Writer.start_indent; end
+def self.attribute_prefix; @@attribute_prefix; end
+def self.attribute_prefix=(string); @@attribute_prefix=string; end
+def attribute_prefix; Writer.attribute_prefix; end
+def self.attribute_suffix; @@attribute_suffix; end
+def self.attribute_suffix=(string); @@attribute_suffix=string; end
+def attribute_suffix; Writer.attribute_suffix; end
+def indention
+	start_indent+(indent*(stack.size-1))
+end
+def write(domainObj, rootElementName=nil, header=nil)
+	header=policy.default_header if header.nil?
+	root_attribute, rootClass = deduce_root_attribute_and_class(domainObj, rootElementName)
+	io << header
+	process( domainObj, root_attribute)
+	io << "\n"
+	ensure
+		io.close if close
+		io.string if io.kind_of?(StringIO)
+end
+def self.write(domainObj, rootElementName=nil, io=StringIO.new, header=nil, analyzer=nil)
+	instance = self.new(io, analyzer)
+	instance.write(domainObj, rootElementName, header)
+end
+# The root element can be thought of as a child of the document.
+# The document has a choice of one of many chrdren (the possible root elements).
+# Returns attribute, concrete-Roog::Class suitable for domainObj
+def deduce_root_attribute_and_class(domainObj, rootElementName=nil)
+	documentRootClass = analyzer.documentClass
+	# We don't need :allAttributes, the document does not have a parent
+	attributes = documentRootClass.attributes.values
+	roots = Array.new
+	attributes.each {|attr|
+		concrete = attr.concreteClassForDomainObject(domainObj, analyzer, false)
+		roots << [attr, concrete] if concrete
+		}
+	raise "Unable to find root element for domain object of type #{domainObj.class_name}" if roots.empty?
+	names=roots.collect {|a| a[0].xmlName }
+	namesStr = names.join(', ')
+	if roots.size==1
+		name = names[0]
+		bad = rootElementName!=nil && name!=rootElementName
+		raise "You specified root element (#{rootElementName}) but the only possible root element is (#{name})" if bad
+		return roots[0]
+		end
+	if roots.size>1 and  rootElementName==nil
+		raise "Multipe root elements possible (#{namesStr}), you need to specify one."
+		end
+	idx = names.index(rootElementName)
+	raise "You specified a root element (#{rootElementName}) not among the possibilities (#{namesStr})" if idx==nil
+	roots[idx]
+end
+# The stack could be eliminated: it keeps track of indentation depth,
+# and it can be useful for debugging. The reason it can be eliminated
+# is that the WriteStackElements are also present on the subroutine stack.
+# The depth can be tracked easily with a counter. Crawling up the
+# subroutine stack to find WriteStackEntries for debugging is a bit harder.
+def process(domainObj, roogAtrribute, roogClass=nil)
+	assert { "Sanity check failure: domainObj should not be nil for attribute #{roogAtrribute.localName}" if domainObj==nil }
+	stackEntry = WriteStackEntry.new(domainObj, roogAtrribute, analyzer, policy, roogClass)
+	stack.push(stackEntry)
+	stackEntry.write_element(self)
+	stack.pop
+end
+def startTag_open(elementName)
+	io << indention
+	io << '<'
+	io << elementName
+end
+def startTag_close(finished=true)
+	ending = finished ? '/>' : '>'
+	io << ending
+end
+def endTag(elementName, indented=true)
+	io << indention if indented
+	io << '</'
+	io << elementName
+	io << '>'
+end
+def attribute(name, value)
+	io << ' '
+	io << name
+	io << attribute_prefix
+	io << value.to_s
+	io << attribute_suffix
+end
+def cdata(string)
+	io << string
+end
+end # Writer
+end # module Pippin
+# ===========================================================================================================
+# ===========================================================================================================
+# ===========================================================================================================
+def parse(schemaPath='schema', instancePath='instance', processor=nil)
+	print( "\n\n*** Did you load the domain objects? ***\n\n")
+	Roog::Analyzer.analyze( schemaPath )
+	Roog::Semantics_Ruby.specialize
+	print( "\n\n*** Finished Analyzing ***\n\n")
+	parser = Pippin::Parser.new( Roog::Analyzer.detach, processor )
+	domainObject = parser.parse( instancePath )
+	print( "\n\n*** Finished Parsing ***\n\n")
+	domainObject
+end
+class Object
+def writeXML(io=StringIO.new, analyzer=nil, rootElementName=nil, header=nil)
+	Pippin::Writer.write(self, rootElementName, io, header, analyzer)
+end
+end #Object
+class Roog::Analyzer
+def write(domainObj, rootElementName=nil, io=StringIO.new, header=nil)
+	Pippin::Writer.write(domainObj, rootElementName, io, analyzer)
+end
+# Uses the default analyzer
+def self.write(domainObj, rootElementName=nil, io=StringIO.new, header=nil)
+	self.instance.write(domainObj, rootElementName, io, header)
+end
+end
+$AllowDirectInvocation = false
+if __FILE__ == $0 && $AllowDirectInvocation
+	require 'Getopt/Declare'
+	commandLineSpec = %q(
+		<schemaPath:if>		path to schema file [required]
+		<instancePath:if>	path to instance file [required]
+		<domainPath:if>		path to domain file [required]
+		)
+	args = Getopt::Declare.new(commandLineSpec)
+	require args["<domainPath>"]
+	domainObject = parse(args["<schemaPath>"], args["<instancePath>"])
+	domainObject.treeDump
+	print( "\n\n*** Done ***\n\n")
+end # directlyInvoked