xiacc 0.1

data/pippin-0.1/lib/nist/pippin/roog.rb

@@ -0,0 +1,2498 @@
+#!/usr/bin/env ruby
+
+require 'nist/common/schema2'
+require 'nist/common/sequentialHash'
+require 'nist/common/rubyToolsDay'
+require 'nist/common/framelet'
+
+require 'stringio'
+require 'nist/common/treeDump'
+
+=begin rdoc
+Ruby Object Ontology Generator
+
+A story by Phillip K. Dick tells us that Roogs are sinister beings
+cleverly disguised a trash collectors (only dogs realize this,
+which is why they howl "ROOG!" whenever garbage is picked up).
+
+Remarkably enough, Roog is also the name for this Module, which
+generates a file of Ruby classes with attributes specified
+by an XML schema. By writing a few subclasses (Generator_Ruby
+and Namer), you could make it generate code for Java, Python
+or some other language.
+
+The output classes are pure domain objects: they contain only
+attributes, no behavior. All the output classes are written
+to one file: if the output is not specified on the command line,
+autoDomain.rb is used. The expectation is that behaviors are
+defined in a different file, which is loaded after the structure
+definitions. Roog does not know or care about this behavior file,
+but your application needs the behaviors (if it does not, consider
+using framelets instead of objects).
+
+How the meta model is built from a schema:
+	* Analyzer.analyze calls loadFile to generatge the XSD::Schema,
+	  which is a crude queryable representation of the schema
+	* Stadard simple classes (corresponding to xsd simpleTypes)
+	  are added to the Analyzer
+	* Create Roog::Class instances, first for simpleTypes defined
+	  in the schema, and then the complexTypes.
+	      * Roog::Class.new takes the REXML simpleType or complexType
+	        (definition) as one of its arguments.
+	      * SchemaDefined.initialize calls:
+	           * setup(definition), which validates data and 
+		     fills in attibutes
+		   * dispatchElement(definition). This in turn:
+		        * pushes the defintion on the Analyzer stack
+			* calls dispatchName with the name of the element
+			  This in turn sends/performs specify_<elementName>.
+			  The multiple specify_<elementName_N) methods in a
+			  given class allow for variable successors.
+			  Each such method may be defined differently in
+			  different classes, allowing for differen contexts.
+			  These methods may in turn call any of these:
+			      * notSupported('featureName')
+			      * tos('attributeName') gets an attribute value from tos
+			      * dispatchChildren, which recursively calls dispatchElement
+			      * dispatchGroupChildren
+			* pops the (now finished) defintion
+	* Link up the model components so that (for example) Roog::Class
+	  instances know the super Roog::Class, etc (see Analyzer.analyze).
+	
+The send/performs of the specify_<elementName> superficially make debugging 
+a little less obvious.  Once you understand the structure, however, it
+becomes clear.  The Analyzer.stack can also help. In fact, if you set 
+roog_policy.save_context to true, each Roog::SchemaDefined will keep
+its definition, and also a copy of the stack used to reach the definition.
+Of course you can also use show_stack from rubyToolsDay.
+
+*****************************************************************
+     Need to rewrite presumptions below from 2 perspcetives:
+          Unmarshalling XML to objects
+          Marshalling objects to XML
+*****************************************************************
+
+Presumptions (probably inescapable):
+	* There is a one-to-one mapping between classes and the
+	  union of simpleTypes and complexTypes
+	* There is a one-to-one mapping between subclassing and
+	  the union of xsd:extends and simpleType definitions
+	* There is a one-to-one mapping between interfaces and
+	  the union of choice groups and substitutionGroups.
+	* There is a one-to-one mapping between instance attributes
+	  the union of xml attributes, xsd:choice groups, and
+	  child elements in (the union of xsd:sequence and xsd:all).
+	* The name of domain object attribues defaults to the name of
+	  the xml attribute or xml element. In the case of xsd:choice
+	  groups, a meaningful attribute name can not be derived from
+	  the schema. **** It is a common mistake to think that
+         element names must map 1:1 on to class names. Although this is
+         possible, the element name could instead be an attribute name.
+         This issue is complicated by substitution and choice groups. Roog
+         uses the interface name as the
+         attribute name, but this must be mapped on to multiple concrete
+         elements: see @elementNameToClass
+	* It does not matter which XML container (xsd:sequence, xsd:all)
+	  is used to hold child elements: all of the child elements turn into
+	  instance attributes (except for xsd:choice)
+	* Some things can not be deduced very well or even at all from the schema:
+		* Which element is root!!! (Unless elements are defined on-the-fly)
+		* Class (static) attributes.
+		* Accessability (private/public/etc) of attributes
+		* Package path of classes (need external hints, possibly based on namespaces)
+		* Dependencies among package paths (or can we deduce these?)
+		* Methods other than accessors and collection management
+		* Types of collections
+		* Names of Interfaces representing xsd:choice groups
+		* Names of attributes holding Interfaces representing xsd:choice groups
+	* Ordering of child elements of the same type is important if the collection
+	  type is ordered. Ordering between child elements of different types is not important.
+	* XML namespaces correspond to Java package paths or Ruby module paths
+	  For this reason namespaces are handled when writing code.
+	* xsd:anyType corresponds to globalSuper
+	* xsd:any elements correspond to attributes named "any", of type 
+	  (depending on multiplicity) globalSuper or Array of globalSuper
+
+
+ Presumptions (easier to remove)
+	* A lot of attributes are currently ignored (with error message)
+	* Some structures are currently ignored (with error message)
+	* It's ok to generate names that can not be deduced from the schema
+	* We don't go out of our way to gracefully handle features of schemas that don't map well to objects.
+
+ Author: A. Griesser
+ 
+ 
+ 
+ 
+Valid schemas can be ambiguous. Example from IPC2581:
+	====== Simplified IPC2581 Schema ================
+	<xsd:complexType name = "SetType">
+		<xsd:choice minOccurs = "0" maxOccurs = "unbounded">
+			<xsd:element ref = "Pad"/>
+			<xsd:element ref = "Fiducial"/>
+		</xsd:choice>
+	</xsd:complexType>
+	<xsd:element name = "Fiducial" abstract = "true"/>
+	<xsd:element name = "GlobalFiducial" type = "PadType" substitutionGroup = "Fiducial"/>
+	<xsd:element name = "Pad" type = "PadType"/>
+	======== The Problem =================
+	When you marshall objects to XML, do you create a Pad element or a Fiducial element?
+	It's hard to tell because both are of type PadType.
+	Your marshalling framework needs some kind of hint that isn't part of the schema.
+	This info is stored in an added attribute specified by hint_attribute_name
+
+
+ Roog was slapped together, so that I could build the OffspringViewer under a 
+ tight deadline. Roog needs to be thought out better, and refactored. Stuff to do:
+ 	Separate Roog into Schema-parsing and Schema-analysis files.
+		The schema-analysis file would add behaviors.
+	Reconsider the policy attributes
+		Some look like they belong in Pippin
+		Some are accessed from pippin.
+		Perhaps Pippin should extend Roog's Policy.
+		The methods that Roog implements for Pippin's sake should
+		   become extensions to the Roog classes, located in the Pippin file.
+	Verify: an element whose type specifies a simpleType carries it's data in the CDATA 
+		between the opening and closing tags.
+	Verify dateTime representation
+	Name conversions are lousy:
+		toModuleName, toAttributeName, toModulePath are all crude approximations
+		Need to check for names which are reserved words
+	The names of attributes (and methods) of these classes are not consistent enough
+		for example, xmlSuperName vs. superEntityName, and xmlSuperName vs. xml_implementorNames
+		We need to distinguish several orthagonal axes:
+			namespace: xml document / domain
+			scope:  local name / path / fq
+			when available: after analysis / after resolving fwd refs
+			required analyzer mode:  singleton/detached
+				Could resolve by always using detached, and explitly passing the analyzer.
+				Detachment is good since muliple schemas will often be needed.
+			efficiency:   computed / cached
+			failureAllowed:  can / can't  return nil
+			keySematics:  elementName, type, etc
+	Could code generation use detached analyzer? (Semantics_ruby can)
+	Regression tests
+       Better control over when things can be nil
+	Assertions
+	Move recursive gathering in Roog::Interface up to Entity so it can use subclasses.
+	Input hints
+	Output hints
+		Base class (table, so you can customize)
+	xsd:string should not "include autoGenName_choiceInterface_4".... or should it???
+	Be more consistent about implicitly returned values
+=end
+
+# Perhaps these should be moved elsewhere: they are not very Roog specific
+XMLNamespaceSep = ":"
+UnixPathSep = "/"
+JavaPathSep = "."
+RubyPathSep = "::"
+
+class String
+
+# Horribly simpleminded
+def toAttributeName()
+	badChars = '- ' #
+	return downcaseFirst.tr(badChars, '_')
+end
+
+# Horribly simpleminded
+def toModuleName()
+	badChars = '- ' #
+	return capitalizeFirst.tr(badChars, '_')
+end
+
+# Horribly simpleminded
+# Also need to convert path separators
+def toModulePath()
+	return toModuleName
+end
+
+# Returns another string, split at the last namespaceSep,
+# with the namespace and separator removed
+def stripNamespace(namespaceSep=XMLNamespaceSep)
+	nsOffset = rindex(namespaceSep)
+	if nil==nsOffset
+		return self
+	else
+		remainderStart = nsOffset + namespaceSep.length
+		remainderLength = length - remainderStart
+		if nameLength>0
+			return self[remainderStart, remainderLength]
+		end
+		end
+end
+
+
+# Returns:
+#	If there is no namespaceSep:  nil
+#	If there is:  anArray[0]=namespace (may be zero length), anArray[1]=remainder (may be zero length)
+def splitNamespace(namespaceSep=XMLNamespaceSep)
+	nsOffset = rindex(namespaceSep)
+	if nil==nsOffset
+		return nil
+	else
+		remainderStart = nsOffset + namespaceSep.length
+		remainderLength = self.length - remainderStart
+		return [ self[0, nsOffset], self[remainderStart, remainderLength] ]
+		end
+end
+
+end # String
+
+
+
+
+module Roog
+
+
+class Policy
+# FIXME: Temporarily a singleton.  The singleton is convenient because it does not
+# need to be passed around. It's bad because you can't have different instances
+# of Roog classes that rely on different Policies.
+include Singleton
+
+# If true, Roog::Class.instantiateWith returns Framelets instead of domain objects.
+# Note that you must use bypass_initialize=true if USE_FRAMELETS=true
+attr_accessor :use_framelets
+
+# If bypass_initialize is true, when you unmarshal a domain object,
+#    its :initialize method is not called.  Attributes which are
+#    collections are set to Arrays by the unmarshalling code.
+#    Disadvantage:  slower performance
+#    Advantage:     can unmarshall objects that have :initialize methods that require arguments.
+# If bypass_initialize is false, the class's "new" method is called,
+#    and :initialize gets invoked.
+# Note that bypass_initialize does not apply to simple objects that get
+# built from strings, and to attribute values that get converted.
+attr_accessor :bypass_initialize   # previously BYPASS_INITIALIZE
+
+# If save_context = true, each SchemaDefined will save it's REXML
+# :definition and :context (stack). This is useful mainly for debugging.
+attr_accessor :save_context # previously SAVE_CONTEXT
+
+
+# Currently used to format all floats (using sprintf), if not nil
+attr_accessor :default_float_format # previously DEFAULT_FLOAT_FORMAT
+# If true, print warnings related to schema issues
+attr_accessor :schema_warnings # previously SCHEMA_WARNINGS
+# Name of attribute used to cache schema ambiguity resolution info
+attr_accessor :hint_attribute_name # previously HINT_ATTRIBUTE_NAME
+# The path used for Entities that do not have a path. May be nil.
+# Should not be nil if your schema contains elements that map
+# onto a class with a name that conflicts with an existing ruby class.
+# Used to initializze aNamer.defaultPathString
+attr_accessor :defaultPathString
+# The module that contains all generated Ruby classes.
+# This can be nil. If it is not, even the Xsd classes will be included
+# (which probably isn't what you want).
+# Used as a default for Semantics_Ruby.globalModule
+attr_accessor :globalModule
+# Name of module to be mixed into all ruby classes. 
+# Does not get mixed into modules that act as packages.
+# Not certain about modules that act as interfaces.
+# Used as a default for Generator_Ruby.globalMixin
+attr_accessor :globalMixin
+# Name of a class that all generated classes should inherit from
+# Used as a default for Generator_Ruby.globalSuper
+attr_accessor :globalSuper
+attr_accessor :debug
+
+def initialize
+	self.use_framelets=false
+	self.bypass_initialize = true
+	self.save_context = false
+	self.default_float_format=nil
+	self.schema_warnings=false
+	self.hint_attribute_name='@_pippin_element_name'
+	self.defaultPathString=nil
+	self.globalModule=nil
+	self.globalMixin=nil
+	self.globalSuper=nil
+	self.debug=false
+end
+
+end # Policy
+
+end # Roog
+
+def roog_policy; Roog::Policy.instance; end
+
+module Roog
+
+module RenameTracker
+
+attr_accessor :oldToNewNames, :newToOldNames
+
+def initialize_RenameTracker
+	@oldToNewNames = Hash.new
+	@newToOldNames = Hash.new
+end
+
+def associateNames(oldName, newName)
+	# print "\n=== "+oldName.to_s+" -> "+newName.to_s
+	@oldToNewNames[oldName]=newName
+	@newToOldNames[newName]=oldName
+end
+
+end # RenameTracker
+
+
+# ===========================================================================================================
+# Represents a part of a model constructed from the schema
+#
+class ModelComponent
+
+attr_accessor :localName
+
+	def initialize(localName)
+		@localName = localName
+	end
+
+	def isClass?() return false end
+	def isPath?() return false end
+	def isInterface?() return false end
+	def isAttribute?() return false end
+	
+	def to_s
+		"<#{self.class.name} localName=#{localName}>"
+	end
+
+end
+
+# ===========================================================================================================
+class Path < ModelComponent
+
+attr_reader :parentPath, :childPaths, :classMap, :interfaceMap
+
+
+	# Links the parent and child paths.
+	# localName is the name of this instance, within the parentPath.
+	# parentPath is another instance (not a path name).
+	# Does not register the path Analyzer.instance.pathMap
+	def initialize(localName, parentPath)
+		super(localName)
+		@parentPath = parentPath
+		@childPaths = Array.new
+		@classMap = Hash.new
+		@interfaceMap = Hash.new
+		if parentPath!=nil
+			parentPath.childPaths << self
+			end
+	end
+
+
+	def isPath?() return true end
+
+	# entity is either a Roog::Class or Roog::Interface
+	def addEntity( entity)
+		if entity.isClass?
+			classMap[entity.localName]=entity
+		else
+			interfaceMap[entity.localName]=entity
+			end
+	end
+
+
+	def interfaces
+		return @interfaceMap.values
+	end
+
+	def classes
+		return @classMap.values
+	end
+	
+	# We are only interested in one type of prerequisite, 
+	# so the typeSymbol is ignored (it's expected to be :pathDependency)
+	def prerequisites(typeSymbol)
+		parts = localName.splitNamespace(RubyPathSep)
+		return [] if !parts
+		[ Analyzer.pathNamed(parts[0], true) ]
+	end
+
+end
+
+
+
+# ===========================================================================================================
+# Common behavior for Attribute, Class, and Interface
+class SchemaDefined < ModelComponent
+
+attr_reader :definition, :context, :xmlName
+
+# === Probably need to override ===
+
+# Define instance attributes and their initial values
+# Used for instance variables added by subclasses.
+# This is called inside initialize, and elminates
+# the need to redefine initialize.
+def setup(definition)
+end
+
+
+# Finish the definion
+def postProcess()
+end
+
+
+# ==== Should not override (convenience abbreviations)
+
+# looks up a new name to replace oldName.
+# If oldName is nil, return nil without a warning.
+# If oldName is not nil, but can not be mapped, prints a warning
+# and returns oldName.
+# Unexpected warnings may indicate that generateStandardSimpleClasses
+# is missing a name.
+def remap(map, type, oldName)
+	if oldName==nil
+		return nil
+		end
+	newName = map[oldName]
+	if newName==nil
+		error self.class.name+".remap() can't find new name for "+type+" "+oldName.to_s
+		return oldName
+	else
+		return newName
+		end
+end
+
+
+def tos(attributeName=nil)
+	return Analyzer.tos(attributeName)
+end
+
+
+# ==== Should not override
+
+
+#  "definition" is the REXML::Element at the root of the definition
+def initialize(definition, xmlName)
+	@xmlName=xmlName
+	if roog_policy.save_context
+		@definition=definition
+		@context=Analyzer.stackClone
+		end
+	setup(definition)
+	if @xmlName==nil
+		defStr = StringIO.new
+		definition.treeDump(3, defStr)
+		fatal( self.class.name + " without xmlName. definition: #{defStr.string}" )
+		return
+		end
+	# definition is nil for standard simple classes
+	# created by generateStandardSimpleClasses
+	if definition!=nil
+		dispatchElement(definition)
+		end
+	postProcess
+end
+
+
+# element must not be nil
+def dispatchElement(element)
+	elementName = element.name
+	if elementName==nil
+		error "Unexpected inability to find REXML:Element.name"
+		return
+		end
+	Analyzer.push(element)
+	dispatchName(elementName)
+	Analyzer.pop
+end
+
+# If element is nil, the tos is used
+def dispatchChildren(element=nil)
+	if element==nil
+		element = tos
+		end
+	element.elements.each { |subElement|
+		dispatchElement(subElement)
+		}
+end
+
+# Dereferences the group if necessary
+def dispatchGroupChildren(group=nil)
+	if group==nil
+		group = tos
+		end
+	dispatchChildren(group)
+	deRefed = Analyzer.schema.deRefGroup(group)
+	if deRefed!=nil
+		dispatchChildren(deRefed)
+		if group.has_elements?
+			warn "group has both ref and child elements"
+			end
+		end
+end
+
+def dispatchName(elementName)
+	command = deriveMethodName("specify_", elementName, nil)
+	commandSymbol = command.intern
+	if respond_to? commandSymbol
+		self.send(commandSymbol)
+	else
+		fatal self.class.name + " is unable to dispatchName "+ command
+	end
+end
+
+# This refers to methods dispatched by send(aSymbol) during schema processing.
+# Concatenate the three components. Only the first whitespace delimited word
+# of string is used, and that is striped of any leading namespace.
+def deriveMethodName(prefix, string, suffix)
+	result = ""
+	if prefix !=nil
+		result=prefix
+		end
+	result = result + string.firstWord.stripNamespace
+	if suffix != nil
+		result=result+suffix
+		end
+	return result
+end
+
+
+
+def notSupported(attributeName)
+	if nil!=tos("attributeName")
+		warn "Not yet supported: " + tos.name + attributeName
+		end
+end
+
+def to_s
+"<#{self.class.name} localName=#{localName} xmlName=#{xmlName}>"
+end
+
+end
+
+
+# ===========================================================================================================
+# Represents (what will become) an attribute in the object model
+class Attribute < SchemaDefined
+
+# category is either "xsd:attribute" or "xsd:element"
+attr_reader :minOccurs, :maxOccurs, :xmlTypeName, :default, :domainType, :elementNameToClass, :classToElementName, :category
+attr_writer :domainType
+
+def initialize(definition, xmlName, category)
+	@category = category
+	super(definition, xmlName)
+end
+
+def is_xml_child?
+	'xsd:attribute'!=category  # may be xsd:element, xsd:choice, possibly others
+end
+
+def required?
+	minOccurs>0
+end
+
+def setup(definition)
+	super
+	@minOccurs=0
+	@maxOccurs=1
+	@xmlTypeName=nil  # May refer to an Interface, rather than a concrete class
+			  # An attribute can have only one type: if there seem to be more,
+			  # use an Interface (perhaps a tagging one with no behaviors)
+	@default=nil
+	@domainType=nil
+	@classToElementName=Hash.new  # Lets you look up all the child elements that are unmarshalled
+	                              # to a specific class (whose name is a key in this Hash).
+				      # This is similar to an inverse of elementNameToClass. It's not
+				      # exactly an inverse, because multiple child elements can be mapped
+				      # onto the same class. The values are arrays.
+				      # CAUTION: this and elementNameToClass must be maintained together!
+	@elementNameToClass=Hash.new  # Lets you look up a concrete class. Similar to elementName2TypeName,
+	                              # but this is a higher level cache, queried by unmarshaller.
+end
+
+def ambiguous_element_for_class?(roogClass)
+	elements = classToElementName[roogClass]
+	assert {"Sanity check failure: no elements in attribute=#{xmlName} for class=#{roogClass.xmlName}" if elements.nil? || elements.empty? }
+	elements.size > 1
+end
+
+# Currently there is no way to undo this operation.
+def associate_elementName_to_class(elementName, roogClass)
+	assert {"Sanity check failure: should not be redefining elementName=#{elementName} => roogClass=#{roogClass.xmlName} for attribute=#{xmlName}" if elementNameToClass.include? elementName }
+	elementNameToClass[elementName]=roogClass
+	classToElementName[roogClass]||= Array.new
+	classToElementName[roogClass] << elementName
+end
+
+def element_name_for_class(roogClass, object)
+	# simple cheap original thing: return elementNameToClass.key_for_value(roogClass)
+	answer = classToElementName[roogClass]
+	raise "Attribute #{localName} is unable to look up element name for class #{roogClass.localName}" if answer.nil? || answer.empty?
+	return answer[0] if answer.size==1
+	hint = object.get_ivar!(roog_policy.hint_attribute_name)
+	if hint.nil?
+	print "\nWarning: multiple elements names (#{answer.join(', ')}) for class #{roogClass.localName} in attribute #{localName}, without #{roog_policy.hint_attribute_name}"  if roog_policy.schema_warnings
+		return answer[0]
+		end
+	return hint if answer.include? hint
+	print "\nWarning: multiple elements names (#{answer.join(', ')}) for class #{roogClass.localName} in attribute #{localName}, unresolved by #{roog_policy.hint_attribute_name}=#{hint.to_s}" if roog_policy.schema_warnings
+	answer[0]
+end
+	
+def isAttribute?() return true end
+
+def initialize?
+	return isCollection
+end
+
+def domainTypeName
+	return domainType.localName
+end
+
+def initialize_in(domainObj)
+	return if !isCollection
+	domainObj.set_ivar(localName, Array.new)
+end
+
+# The domainObj must have a public setter and getter
+# Should be renamed to set_or_add_value
+def setValue(domainObj, value)
+	if isCollection
+		collection = domainObj.get_ivar(localName)
+		collection << value
+	else
+		raise "Attribute #{localName} is required: can't set to nil." if value.nil? && required?
+		domainObj.set_ivar(localName, value)
+		end
+end
+
+# The domainObj must have a public getter.
+def getValue(domainObj)
+	domainObj.get_ivar(localName)
+end
+
+def concreteClassForElementName(elementName)
+	elementNameToClass[elementName]
+end
+
+# Finds the lowest level concrete Roog::Class corresponding to a given domainObj.
+# This is more complicated than it sounds, due to interfaces, modules, and superclasses.
+# roogClass is deduced from the domainObj and roogAttribute.domainType
+# (which might be abstract, or an interface)
+# Returns nil if unable to find a concrete class.
+# NOTE:  analyzer is passed in because this is called after the anaylyzer
+#        has been detached.
+def concreteClassForDomainObject(domainObj, analyzer, errorIfMissing=true)
+	sought = domainObj.class
+	return domainType if ( domainType.isClass? && !domainType.isAbstract && domainType.instantiates_domain_object(domainObj) )
+	concrete = domainType.all_concrete_children(analyzer, false)
+	# Think we don't need to worry about more than one, because they are concrete.
+	answer = concrete.detect { |klass| klass.instantiates_domain_object(domainObj) }
+	assert { "Unable to find a concrete Roog::Class for domain object <#{domainObj.to_s}> of class #{domainObj.class_name} in attribute #{localName}" if answer==nil } if errorIfMissing
+	answer
+end
+
+# === Performed by dispatch() ===
+
+
+def specify_attribute()
+	notSupported "fixed"
+	notSupported "form"
+	notSupported "ref"
+	use  = tos("use")
+	@xmlTypeName = tos("type")
+	@default = tos("default")
+	case use
+		when "optional", nil
+			@minOccurs=0
+			@maxOccurs=1
+		when "prohibited"
+			# "prohibited" is used when a complex type is restricted
+			error "Not yet supported: xsd:attribute.use = 'prohibited'."
+		when "required"
+			@minOccurs=1
+			@maxOccurs=1
+		end
+end
+
+def specify_element()
+	notSupported "id"
+	notSupported "abstract"
+	notSupported "block"
+	notSupported "final"
+	notSupported "fixed"
+	notSupported "form"
+	notSupported "nillable" # Does this mean optional?
+	ref = tos("ref")
+	if ref
+		deRefed = Analyzer.schema.deRefThing(tos)
+		fatal("Schema was unable to deRefThing #{tos.to_s}") if !deRefed
+		copyFromTemplate( deRefed )
+	end
+	# declaration overrides referenced template.
+	# need to verify this.
+	error("Unexpected nil tos") if !tos
+	copyFromTemplate( tos )
+end 
+
+def specify_choice()
+	setMinOccurs(tos("minOccurs"))
+	setMaxOccurs(tos("maxOccurs"))
+	@xmlTypeName = Analyzer.choiceInterfaceName
+	Analyzer.xmlRegisterEntity( Roog::Interface.new(tos, @xmlTypeName) )
+end
+
+# === Construction helpers ===
+
+def copyFromTemplate(template)
+	attrib = template.attributes
+	setMinOccurs(attrib["minOccurs"])
+	setMaxOccurs(attrib["maxOccurs"])
+	setDefault(attrib["default"])
+	setType(attrib["substitutionGroup"])
+	# type overrides substitutionGroup attribute
+	# See Walmsley page 362, next-to-last paragraph
+	setType(attrib["type"])
+	# head of substitution group overrides type
+	_name = attrib["name"]
+	if (Analyzer.schema.existsSubstGroup(_name))
+		setType(_name)
+		end
+end
+
+# Silently does nothing if string is nil
+def setType(string)
+	return if !string
+	@xmlTypeName=string
+end
+
+# Silently does nothing if string is nil
+def setDefault(string)
+	return if !string
+	@default=string
+end
+
+# Silently does nothing if string is nil
+def setMinOccurs(string)
+	return if !string
+	int = string.to_i
+	if int<0
+		error "Cardinality can't be negative!"
+	elsif int!=0
+		@minOccurs=int
+	elsif "0"==string # to_i returns 0 if string does not start with integer
+		@minOccurs=0
+	else
+		error "Invalid value for minOccurs (#{string})"
+		end
+end
+
+
+# Silently does nothing if string is nil
+def setMaxOccurs(string)
+	return if !string
+	int = string.to_i
+	if int<0
+		error "Cardinality can't be negative!"
+	elsif int!=0
+		@maxOccurs=int
+	elsif "0"==string # to_i returns 0 if string does not start with integer
+		error "maxOccurs should not be zero"
+	elsif "unbounded"==string
+		@maxOccurs=:unbounded
+	else
+		error "Invalid value for maxOccurs (#{string})"
+		end
+end
+
+# === Output ===
+
+def isCollection()
+	if @maxOccurs==:unbounded
+		return true
+	elsif @maxOccurs.kind_of?(Numeric)
+		return @maxOccurs>1
+	else
+		error "Unrecognized maxOccurs in Roog::Class.isCollection"
+		return false
+		end
+end
+
+# If isCollection, then this refers to the contents
+def isOptional()
+	#if @minOccurs < 1
+	#	return true
+	#	end
+	#return false
+	@minOccurs < 1
+end
+
+
+def multiplicity()
+	if isCollection
+		return @minOccurs.to_s + "... "+@maxOccurs.to_s
+	elsif isOptional
+		return "optional"
+	else
+		return "required"
+		end
+end
+
+def description()
+	if isCollection
+		return "Collection (#{multiplicity}) of "+domainTypeName
+	else
+		return multiplicity+" "+domainTypeName
+		end
+end
+
+end
+
+
+# ===========================================================================================================
+# Represents (what will become) a class or interface in the object model
+#
+class Entity < SchemaDefined
+
+# We could derive localName and pathString from fqName
+# but it's nice to keep this code independent of the language to be generated
+# (which affects the path separator)
+# FIXME? subEntities was added to enable a class to know it's subclasses.
+#        This might duplicate some semantics related to extenders of Interfaces.
+#        If so, it's harmless, just ugly.
+attr_accessor :pathString, :fqName, :xmlSuperName, :superEntity, :subEntities
+
+# Define instance attributes and their initial values
+def setup(definition)
+	super
+	@pathString=nil
+	@fqName=nil
+	@xmlSuperName=nil
+	@superEntity=nil
+	@subEntities=Array.new
+end
+
+def superEntityFqName
+	return nil if superEntity==nil
+	return superEntity.fqName
+end
+
+def add_subEntity(entity)
+	subEntities << entity
+end
+
+def all_subEntities(answer=Array.new)
+	answer.concat(subEntities)
+	subEntities.each {|sub| sub.all_subEntities(answer) }
+	answer
+end
+
+# See note on concreteClassForDomainObject
+def all_concrete_children(analyzer, includeSelf=true)
+	start = (includeSelf && !isAbstract) ? [self] : []
+	all_subEntities(start).select { |s| !s.isAbstract }
+end
+
+# names is an Array, the output of Namer.newEntityNames
+# This has become a misnomer now that we keep the xmlName
+def rename(names)
+	@pathString = names[0]
+	@localName = names[1]
+	@fqName = names[2]
+end
+
+# Always returns an Array, even if empty.
+def prerequisites(typeSymbol)
+	return Array.new
+end
+
+def samePath(anotherEntity)
+	if (anotherEntity.respond_to?(:pathString))
+		return pathString == anotherEntity.pathString
+		end
+	return false
+end
+
+# Returns nil if the entity can ot have implementors
+def xml_allImplementorNames
+	return nil
+end
+
+end
+
+# ===========================================================================================================
+# Represents (what will become) a class in the object model
+
+class Class < Entity
+
+include RenameTracker
+
+attr_reader :attributes, :isAbstract, :enumerations, :isSimple, :xml_implementedInterfaceNames, :implementedInterfaces, :xmlAttributeLookup, :transformer
+attr_writer :transformer, :isAbstract  # Analyzer sets class corresponding to Document to abstract.
+
+
+# Difference between @attributes and @xmlAttributeLookup...
+#	@attributes has a key for the first declaring element. Only one key per Roog::Attribute
+#	@xmlAttributeLookup has a key for every possible subelement.
+#		It has the same number of Roog::Attributes, but it can have more
+#		keys per Roog::Attribute. For example, if an attribute holds a subsititution
+#		group, the element names of concrete members of that group are keys (recursively)
+def setup(definition)
+	super
+	initialize_RenameTracker
+	@attributes = SequentialHash.new   # See above note
+	@xmlAttributeLookup = Hash.new     # See above note
+	@enumerations=Array.new
+	@isAbstract = false
+	@isSimple = (nil==definition)
+	# These populated after the initial pass
+	@xml_implementedInterfaceNames = Array.new
+	@implementedInterfaces = Array.new
+	# @transformer # present only if isSimple (in which case it must be present)
+end
+
+# Deprecated  FIXME, Remove
+def instantiates_domain_class(klass)
+	# Changed during fix for no-namespace E120. Previously:
+	#     return (!isAbstract && localName==klass.name) if !isSimple
+	return (!isAbstract && fqName==klass.name) if !isSimple
+	return true if roog_policy.use_framelets && klass==String && transformer.fromStringSym.nil?
+	domainClasses = transformer.domainClasses
+	return domainClasses.include?( klass) if domainClasses
+	fqName == klass.name
+end
+
+def instantiates_domain_object(obj)
+	className = obj.class_name
+	# Changed during fix for no-namespace E120. Previously:
+	#     return (!isAbstract && localName==className) if !isSimple
+	return (!isAbstract && fqName==className) if !isSimple
+	klass = obj.class
+	return true if roog_policy.use_framelets && klass==String && transformer.fromStringSym.nil?
+	domainClasses = transformer.domainClasses
+	return domainClasses.include?( klass) if domainClasses
+	fqName == klass.name
+end
+
+def description
+	answer = String.new
+	if isAbstract
+		answer << 'Abstract '
+	else
+		answer << 'Conrete '
+		end
+	if isSimple
+		answer << 'Simple '
+	else
+		answer << 'Complex '
+		end
+	answer << transformer.to_s  if  transformer!=nil
+	answer 
+end
+
+# The arguments are used only for classes corresponding to xsd simpleTypes.
+# attributeData is any extra info that should be considered by the transformer.
+# Currently a Pippin::StackEntry is passed for attributData, but it isn't used.
+def instantiateWith(aString, attributeData=nil)
+	# assert {"Roog::Class.transformer should not be nil: did you run Semantics.specialize?" if transformer==nil}
+	return transformer.fromString(aString, self, attributeData) if isSimple	
+	answer = roog_policy.use_framelets ? Framelet.new(fqName) : instantiate_class_named(fqName, roog_policy.bypass_initialize)
+	return answer if !roog_policy.bypass_initialize
+	allAttributes.each {|attr| attr.initialize_in(answer) }
+	answer
+end
+
+def toString(simple)
+	assert {"Roog::Class#toString is for simple objects: #{localName} is not simple." if !isSimple }
+	assert {"Roog::Class.transformer should not be nil: did you run Semantics.specialize?" if transformer==nil}
+	transformer.toString(simple, self)
+end
+
+def float_format
+# FIXME save constraints such as  xsd:totalDigits and xsd:fractionDigits from schema and use them here
+	roog_policy.default_float_format
+end
+
+def superEntityFqName
+	answer = super
+	return answer if ( answer!=nil || transformer==nil)
+	transformer.parentFqName
+end
+
+def implementedFqInterfaceNames
+	return @implementedInterfaces.collect { |interface| interface.fqName }
+end
+
+# If there is no argument, tells you if this implements any interface at all.
+def implementsInterface(interfaceName=nil)
+	if interfaceName==nil
+		return !@xml_implementedInterfaceNames.empty?
+	else
+		return @xml_implementedInterfaceNames.include?(interfaceName)
+		end
+end
+
+def isClass?() return true end
+
+#convenience method to allow for indirect querying to find out if this Class
+#contains an Attribute corresponding to domainAttributeName
+def hasDomainAttribute?(domainAttributeName)
+	return attributes.has_key?( domainAttributeName)
+end
+
+
+def prerequisites(typeSymbol)
+	answer = Array.new
+	case typeSymbol
+	when :samePathAndEntityType
+		sc = Analyzer.classNamed(@xmlSuperName)
+		if samePath(sc)
+			answer.add!(sc)
+			end
+	when :all
+		answer.add!(Analyzer.classNamed(@xmlSuperName))
+		@xml_implementedInterfaceNames.each { |ifName|
+			answer.add!(Analyzer.interfaceNamed(ifName))
+			}
+	end
+	return answer.sort {|a,b| a.localName <=> b.localName }
+end
+
+def initializedAttributes
+	return @attributes.values.select { |attr| attr.initialize? }
+end
+
+# oneArgBlock must take an Attribute as its argument, and return an Attribute.
+# An Array of new Attributes is returned. Correlates xmlName and localName
+def collectAttribues! ( &oneArgBlock )
+	return @attributes.values.collect! {|attrib|
+		oldName=attrib.xmlName
+		newAttrib=oneArgBlock.call( attrib )
+		newName=attrib.localName
+		associateNames(oldName, newName)
+		}
+end
+
+# Get an attribute (without recursing up the hierarchy)
+def localAttributeForXMLName(xmlName, errorIfMissing=true)
+	attribute = xmlAttributeLookup[xmlName]
+	assert {"Must have attribute key #{xmlName} in parent #{@xmlName} (attribute keys are #{attributeNames})." if errorIfMissing && attribute==nil}
+	attribute
+end
+
+# Get an attribute, recursing up the hierarchy if necessary
+def attributeForXMLName(xmlName, errorIfMissing=true)
+	attribute = localAttributeForXMLName(xmlName, false)
+	attribute = @superEntity.attributeForXMLName(xmlName, false) if attribute==nil && @superEntity!=nil
+	assert {"Unable to recursively find attribute key #{xmlName} in parent #{@xmlName}." if errorIfMissing && attribute==nil}
+	attribute
+end
+
+# Get an attribute (without recursing up the hierarchy)
+def localAttributeForDomainName(domainName, errorIfMissing=true)
+	attribute = attributes[domainName]
+	assert {"Must have attribute #{domainName} in #{@localName} (attributes are #{attributeDomainNames})." if errorIfMissing && attribute==nil}
+	attribute
+end
+
+# Get an attribute, recursing up the hierarchy if necessary
+def attributeForDomainName(domainName, errorIfMissing=true)
+	attribute = localAttributeForDomainName(domainName, false)
+	attribute = @superEntity.attributeForDomainName(domainName, false) if attribute==nil && @superEntity!=nil
+	assert {"Unable to recursively find attribute #{domainName} in #{@localName}." if errorIfMissing && attribute==nil}
+	attribute
+end
+
+def attributeNames
+	@xmlAttributeLookup.keys.join(", ")
+end
+
+def attributeDomainNames
+	@attributes.keys.join(", ")
+end
+
+# attributeData is a Pippin StackEntry
+# returns the value that was actually set (which may be different from the input
+# due to conversion of string to date, etc.)
+def setAttribute(domainObj, xmlName, value, convert, attributeData)
+	assert { "DomainObj can't be nil if you want to set attribute with xmlName #{xmlName.to_s} using roogClass with xmlName #{@xmlName}" if domainObj==nil }
+	attribute = attributeForXMLName(xmlName, false) # searches up the hierarchy
+	if attribute==nil
+		print "\n >> Domain class #{localName.to_s} can't set unknown attribute with xmlName #{xmlName.to_s} with a value of class #{value.class.name}"
+		print "\n    Attributes: "+attributeNames
+		return
+		end
+	if convert
+		cls = attribute.concreteClassForElementName(xmlName)
+		value = cls.instantiateWith(value, attributeData) 
+		end
+	# print "\n -- Domain class #{localName.to_s} will set attribute #{attribute.localName.to_s} with a value of class #{value.class.name}"
+	attribute.setValue(domainObj, value)
+	value
+end
+
+# Attributes in this class
+def allLocalAttributes
+	attributes.values
+end
+
+# Returns an array of Roog::Classes this object inherits from.
+# The parents are in order, with the root at index zero..
+def hierarchy(includeSelf=true)
+	answer = includeSelf ? [self] : []
+	current = self
+	while !current.superEntity.nil?
+		current = current.superEntity
+		answer.unshift(current)
+		end
+	answer
+end
+
+# Attributes in this and parent classes
+def allAttributes(collection=Array.new)
+	answer = Array.new
+	hierarchy.each {|rClass| answer.concat(rClass.allLocalAttributes) }
+	answer
+end
+
+# === Performed by dispatch() ===
+
+def specify_simpleType()
+	notSupported "id"
+	notSupported "final"
+	@isSimple=true
+	dispatchChildren
+end
+
+# We currently ignore the restriction semantics:
+# the restriction is used only to define a new Class.
+def specify_restriction()
+	notSupported "id"
+	return warn("Not yet supported: xsd:restriction on complexType") if ! @isSimple
+	@xmlSuperName = tos("base")
+	dispatchChildren
+end
+
+
+def specify_pattern; constraints_not_supported; end
+def specify_minInclusive; constraints_not_supported; end
+def specify_maxInclusive; constraints_not_supported; end
+def specify_minExclusive; constraints_not_supported; end
+def specify_maxExclusive; constraints_not_supported; end
+def specify_totalDigits; constraints_not_supported; end
+def specify_fractionDigits; constraints_not_supported; end
+
+def specify_enumeration()
+	enumerations << tos("value")
+end
+
+def specify_complexType()
+	notSupported "id"
+	notSupported "mixed"
+	notSupported "block"
+	notSupported "final"
+	@isAbstract = ( true == tos("abstract") )
+	dispatchChildren
+end
+
+def specify_simpleContent()
+	warn "Not yet supported: xsd:simpleContent"
+end
+
+def specify_complexContent()
+	dispatchChildren
+end
+
+def specify_all()
+	# xsd:all differs mostly from xsd:sequence in that
+	# xsd:all has some extra constraints on cardinality, but those
+	# are enforced by a validating parser.
+	# The order of children is significant only for XML, so we
+	# can ignore it.
+	specify_sequence()
+end
+
+def specify_sequence()
+	# minOccurs and maxOccurs should be used to change the contained
+	# elements into collections. It's awkward that the cardinality
+	# would be contained in two places (here, and at the element level).
+	notSupported "minOccurs"
+	notSupported "maxOccurs"
+	dispatchChildren
+end
+
+def specify_choice()
+	# A choice specifies an un-named interface, which all of the contained items implement.
+	# makeAttribute will indirectly make a Roog::Interface
+	makeAttribute("xsd:choice", Analyzer.choiceAttributeName)
+end
+
+def specify_group()
+	warn "Not yet supported: xsd:group"
+end
+
+def specify_attributeGroup()
+	warn "Not yet supported: xsd:attributeGroup"
+end
+
+def specify_anyAttribute()
+	warn "Not yet supported: xsd:anyAttribute"
+end
+
+
+def specify_attribute()
+	makeAttribute("xsd:attribute")
+end
+
+def specify_element()
+	makeAttribute("xsd:element")
+end
+
+def specify_extension()
+	@xmlSuperName = tos("base")
+	dispatchChildren
+end
+
+# ===== Construction helpers
+
+# At the Class level, creating an attribute from an xsd:element
+# is the same as creating one from an xsd:attribute.  Of course
+# different behaviors are dispatched at the Attribute level.
+# type can be "xsd:attribute", "xsd:element", or xsd:choice
+def makeAttribute(type, xmlName=tos("name"))
+	xmlName = tos("ref") if xmlName.nil?
+	if xmlName.nil?
+		warn "Attribute (from "+type+") is missing its xmlName."
+	elsif @attributes.has_key?(xmlName)
+		warn "Attribute (#{xmlName}) is already present"
+	else
+		@attributes[xmlName]=Roog::Attribute.new(tos, xmlName, type)
+		end
+end
+
+# This is one half of a pair: you should instead call Interface.addImplementor
+def _addImplementedInterface(interface)
+	@implementedInterfaces << interface
+	@xml_implementedInterfaceNames << interface.xmlName
+end
+
+
+def constraints_not_supported
+	warn "Not yet supported: constraints such as xsd:pattern, xsd:minInclusive, xsd:maxInclusive, xsd:minExclusive, xsd:maxExclusive, xsd:totalDigits, xsd:fractionDigits."
+end 
+
+end
+
+# ===========================================================================================================
+# Represents (what will become) an Interface in the object model
+# Ruby code will implement the interface as a mixed-in Module with
+# no behavior (sort of like a Java tagging interface). You can than
+# test for implementation using aThing.kind_of?(anInterface).
+#
+# If isChoice is true, the Interface was created as a result of
+# an xsd:choice group. If isChoice is false, the Interface was created
+# to represent a substitution group.
+class Interface < Entity
+
+attr_reader :implementors, :alternativeElements, :isChoice, :xml_extenderNames, :elementName2TypeName
+
+def setup(definition)
+	super
+	@xml_extenderNames = Array.new
+	@implementors = Array.new
+	@alternativeElements = Array.new
+	@elementName2TypeName = Hash.new         # This is about elements mapping onto interface implementors
+	                                         # This is built during analysis, earlier than elementNameToClass
+						 # This maps only direct implementors, not implementors of extending interfaces.
+	@isChoice = ("choice"==definition.name.firstWord.stripNamespace)
+end
+
+def xml_implementorNames
+	implementorNameMap.values.uniq
+end
+
+# Recursively includes all concrete implementors
+def implementorNameMap(analyzer=Analyzer.instance, answer=Hash.new)
+	answer.concat(elementName2TypeName)
+	xml_extenderNames.each {|xName| 
+		extender=analyzer.interfaceNamed(xName)
+		extender.implementorNameMap(analyzer, answer) if extender!=nil
+		warn("Not able to look up extender #{xName} of #{xmlName}") if extender==nil
+		}
+	answer
+end
+
+# See note on concreteClassForDomainObject
+def all_concrete_children(analyzer, includeSelf=true)
+	# Might be wrong: don't remember difference between implementorNameMap.values and xml_allImplementorNames
+	# Can't use :collect, some are nil
+	answer = Array.new
+	implementorNameMap(analyzer).values.each {|name| 
+		klass = analyzer.classNamed(name) 
+		answer << klass if klass!=nil
+		error("Not able to look up implementor #{name} (#{name.class.name}) of #{xmlName} among known classes: #{analyzer.class_names}") if klass==nil
+		} 
+	answer
+end
+
+# does not include the recipient
+def extendersRecursively(answer=nil)
+	answer=Array.new if answer==nil
+	@xml_extenderNames.each { |extName|
+		subInterface = Analyzer.interfaceNamed(extName)
+		answer << subInterface
+		extendersRecursively(answer)
+		}
+	answer
+end
+
+# Concatenate the collections obtained when the receiver and all
+# extendersRecursively perform aSymbol
+def recursivelyConcat(aSymbol)
+	answer=self.send(aSymbol)
+	extendersRecursively.each { |subInterface|
+		answer.concat(subInterface.send(aSymbol))
+		}
+	answer
+end
+
+def xml_allImplementorNames()
+	recursivelyConcat(:xml_implementorNames)
+end
+
+
+def allElementNames()
+	recursivelyConcat(:elementNames)
+end
+
+def elementNames
+	elementName2TypeName.keys
+end
+
+
+def postProcess
+	super
+	@alternativeElements.uniq!
+end
+
+
+def isInterface?() return true end
+
+
+def prerequisites(typeSymbol)
+	answer = Array.new
+	case typeSymbol
+	when :samePathAndEntityType
+		sc = Analyzer.interfaceNamed(@xmlSuperName)
+		if samePath(sc)
+			answer.add!(sc)
+			end
+	when :all
+		answer.add!(Analyzer.interfaceNamed(@xmlSuperName))
+	end
+	return answer.sort {|a,b| a.localName <=> b.localName }
+end
+
+def addAlt(element)
+	@alternativeElements << element
+	type = Analyzer.schema.findTypeName(element)
+	elementName = Analyzer.schema.findAttributeValue(element, "name")
+	if type==nil
+		# You reach this point only for elements
+		# specifying a substitution group
+		# Example elements at this point:
+		#    <element minOccurs='0' ref='Attribute'/>    (Reference to substitution group head)
+		#    <element name='Feature' abstract='true'/>   (Subsitution group head)
+		assert { "elementName must not be nil for element #{element.openingTag}" if elementName==nil }
+		return if elementName==xmlName
+		@xml_extenderNames << elementName
+		# We don't need to add to elementName2TypeName because if it wasn't abstract, we wouldn't end up here.
+	else
+		# Actually, this could be a substitution group (not in Offspring, where substitution groups are all abstract), 
+		# in which case we need the above code.
+		@elementName2TypeName[elementName]=type
+		end
+end
+
+def addImplementor(implementor)
+	@implementors << implementor
+	implementor._addImplementedInterface(self)
+end
+
+def x()
+end
+
+# === Performed by dispatch() ===
+
+# These deliberately ignore minOccurs and maxOccurs, which are not
+# necessary to define an interface
+def specify_choice() dispatchChildren end
+def specify_sequence() dispatchChildren end
+def specify_group() dispatchGroupChildren end
+def specify_any()
+	notSupported "namespace"
+	notSupported "processContents"
+	dispatchChildren
+end
+
+def specify_element()
+	addAlt(tos)
+	if ! @isChoice
+		@xmlSuperName = tos("substitutionGroup")
+		end
+end
+
+end
+
+
+# ===========================================================================================================
+# This simple namer does not use lookup tables.
+# Uses capitalizeFirst xml namespace as path.
+# This might be ok for java code generation if you
+# change PathSep (haven't thought about it enough)
+#
+class Namer
+
+attr_reader   :nameCounter
+attr_accessor :defaultPathString
+
+PathSep = RubyPathSep
+
+def initialize
+	@defaultPathString = roog_policy.defaultPathString
+	@nameCounter = 0
+end
+
+
+# === May want to override ======
+
+# Generate a new name of specified type
+# This is called during parsing, when we need to create a
+# new Interface or attribute, and the name can not be
+# deduced from the schema.
+def generateName(type="")
+	@nameCounter = 1 + @nameCounter
+	answer = "autoGenName_"
+	if ! type.empty?
+		answer=answer+type+"_"
+		end
+	answer = answer + @nameCounter.to_s
+	info("Generated " + answer)
+	return answer
+end
+
+# Returns an Array of (related) names for entity:
+#	answer[0] = new path
+#	answer[1] = new local name
+#	answer[2] = new fully qualified name
+# Does not change entity in any way.
+# This is called indirectly by Analyzer.renameAndBuildPaths,
+# after the schema has been completely parsed.
+# This version derives the package/module path from the XML namespace
+# This version also capitalizes all entity names.
+def newEntityNames(entity)
+	oldName = entity.xmlName
+	answer = oldName.splitNamespace(XMLNamespaceSep)
+	if answer!=nil
+		answer[0] = answer[0].toModulePath
+		answer[1] = answer[1].toModuleName
+		answer[2] = answer[0]+PathSep+answer[1]
+		return answer
+		end
+	# if we reach this point, there is no namespace
+	newLocalName=oldName.toModuleName
+	newPath=defaultPathString
+	newFQName= newPath ? newPath+PathSep+newLocalName : newLocalName
+	[newPath, newLocalName, newFQName]
+end
+
+# should this allow for namespaces?
+def newAttributeName(attribute)
+	return attribute.xmlName.toAttributeName
+end
+
+def splitNamespace(aString)
+	if aString==nil
+		return nil
+		end
+	return aString.splitNamespace(PathSep)
+end
+
+end
+
+# ===========================================================================================================
+#
+# Analyzer builds an internal representation of the schema's object model
+# (in terms of Roog::Class, Roog::Interface, and Roog::Attribute)
+#
+# This internal model can be used to generate source code for domain
+# objects, or to guide XML marshalling.
+#
+# Strictly speaking, the internal model is unnecessary. I like having
+# the internal model, because there may later be a need to transform or
+# query it.
+#
+# Likewise most info in the stack could be derived from REXML::Element's
+# chain of parent().  The stack, however, reflects the actual execution:
+# when an element needs to be dispatched a second time, it is put on
+# the stack again.
+#
+class Analyzer
+
+include RenameTracker
+
+attr_reader :classMap_xml, :interfaceMap_xml, :classMap_domain, :interfaceMap_domain, :pathMap, :stack, :schema, :namer
+
+def initialize()
+	@classMap_xml = Hash.new
+	@interfaceMap_xml = Hash.new
+	@classMap_domain = Hash.new
+	@interfaceMap_domain = Hash.new
+	@rootPath = Path.new(nil, nil) # The only path without a parent
+	@pathMap = Hash.new
+		@pathMap[nil]=@rootPath
+	@stack = Array.new
+	# If you don't like the default namer just call
+	#	Analyzer.instance.namer = MyNamer.new
+	# before you call
+	#	Analyzer.analyze(fileName)
+	@namer = Namer.new
+	@schema = nil
+	initialize_RenameTracker
+end
+
+@@instance = Analyzer.new
+
+def rootPath
+	answer = @rootPath
+	raise "Missing rootPath" if !answer
+	answer
+end
+
+# Returns the current instance (makes a new current instance)
+def Analyzer.detach
+	answer = @@instance
+	@@instance = Analyzer.new
+	return answer
+end
+
+def Analyzer.clear; Analyzer.detach; end
+
+# The document class represents the document itself: it
+# contains a Roog::Attribute for every possible document
+# root element. This class does not correspond to a
+# domain object, and does not get instatiated.
+def Analyzer.xml_name_of_document_class
+	'__DOCUMENT__'
+end
+
+
+# ========= Class side pseudo-singleton services
+
+def Analyzer.instance
+	return @@instance
+end
+
+def Analyzer.analyze(fileName, fromScratch=true, context=REXML::Document::DEFAULT_CONTEXT)
+	Analyzer.clear if fromScratch
+	@@instance.analyze(fileName, context)
+end
+
+def Analyzer.classNamed(xmlName)
+	@@instance.classNamed(xmlName)
+end
+
+def Analyzer.interfaceNamed(xmlName)
+	@@instance.interfaceNamed(xmlName)
+end
+
+def Analyzer.push(rexmlElement)
+	@@instance.push(rexmlElement)
+end
+
+def Analyzer.pop()
+	@@instance.pop()
+end
+
+
+def Analyzer.tos(attributeName=nil)
+	@@instance.tos(attributeName)
+end
+
+def Analyzer.schema()
+	@@instance.schema
+end
+
+def Analyzer.choiceAttributeName()
+	@@instance.namer.generateName("choiceAttribute")
+end
+
+def Analyzer.choiceInterfaceName()
+	@@instance.namer.generateName("choiceInterface")
+end
+
+def Analyzer.substitutionInterfaceName()
+	@@instance.namer.generateName("substitutionInterface")
+end
+
+def Analyzer.stackClone()
+	@@instance.stackClone
+end
+
+def Analyzer.xmlRegisterEntity(entity)
+	@@instance.xmlRegisterEntity(entity)
+end
+
+# newFqName is the fully qualified name after the renaming process.
+def Analyzer.pathNamed(newFqName, fail_if_missing=false)
+	@@instance.pathNamed(newFqName, fail_if_missing)
+end
+
+def Analyzer.path_names
+	@@instance.path_names
+end
+
+# ============= Instance behaviors
+
+def class_names
+	classMap_xml.keys.sort.join(', ')
+end
+
+def path_names
+	keys = pathMap.keys.compact
+	keys = keys.collect {|k| "'"+k+"'"}
+	keys.sort.join(', ')
+end
+
+def documentClass
+	classNamed(Analyzer.xml_name_of_document_class)
+end
+
+def classNamed(xmlName)
+	classMap_xml[xmlName]
+end
+
+def domainClassNamed(domainObjName)
+	classMap_domain[domainObjName]
+end
+
+def interfaceNamed(xmlName)
+	interfaceMap_xml[xmlName]
+end
+
+# newFqName is the fully qualified name after the renaming process.
+def pathNamed(newFqName, fail_if_missing=false)
+	answer = pathMap[newFqName]
+	raise "Unable to find path: '#{newFqName}' among: #{path_names}" if fail_if_missing && !answer
+	answer
+end
+
+# Given the name of a globally defined element,
+# find the name of the type declared by the schema.
+# This resolves refs if necessary.
+def schemaTypeForGlobalElementName(elementName)
+	globalElement = schema.globalElements[elementName]
+	if globalElement == nil
+		return nil
+		end
+	return schema.findTypeName(globalElement)
+end
+
+
+def xmlRegisterEntity(entity)
+	xmlName=entity.xmlName
+	if xmlName==nil
+		error "Entity is missing its xmlName."
+		return
+		end
+	registry = xmlRegistryFor(entity)
+	if registry==nil
+		error "There is no xml registry for instances of "+entity.class.name
+		return
+		end
+	if registry.has_key?(xmlName)
+		error "Entity (#{name}) is already present"
+	else
+		registry[xmlName]=entity
+		end
+end
+
+def xmlRegistryFor(entity)
+	if entity.isClass?
+		return @classMap_xml
+	elsif entity.isInterface?
+		return @interfaceMap_xml
+	else
+		rturn nil
+		end
+end
+
+# Don't like redundancy with xmlRegisterEntity. Need to refactor.
+def domainRegisterEntity(entity)
+	fqName=entity.fqName
+	if fqName==nil
+		error "Entity is missing its fqName."
+		return
+		end
+	registry = domainRegistryFor(entity)
+	if registry==nil
+		error "There is no domain registry for instances of "+entity.class.name
+		return
+		end
+	if registry.has_key?(fqName)
+		error "Entity (#{fqName}) is already present"
+	else
+		registry[fqName]=entity
+		end
+end
+
+def domainRegistryFor(entity)
+	if entity.isPath?
+		return @pathMap
+	elsif entity.isClass?
+		return @classMap_domain
+	elsif entity.isInterface?
+		return @interfaceMap_domain
+	else
+		rturn nil
+		end
+end
+
+
+
+
+def push(rexmlElement)
+	@stack.push(rexmlElement)
+end
+
+def pop()
+	return @stack.pop()
+end
+
+def stackClone()
+	return @stack.clone()
+end
+
+def printStack()
+	@stack.reverse_each { |rexmlElement|
+		print "\n\t"+rexmlElement.openingTag
+		}
+end
+
+# Returns either:
+#    * The top of the stack, if the attributeName is nil. This does NOT pop the stack.
+#    * An attribute from the element on the top of the stack, if attributeName is not nil
+# Note that the top of the stack is actually the last element in the
+# Array, because that's where "push" puts it.
+def tos(attributeName=nil)
+	_tos = @stack.last
+	if attributeName==nil
+		return _tos
+		end
+	return _tos.attributes[attributeName]
+end
+
+# Do not invoke on a detached Analyzer.
+def analyze(fileName, context=REXML::Document::DEFAULT_CONTEXT)
+	# Parse the Schema & prepare for subsequent queries
+	loadFile(fileName, context)
+	# Create components of object model from the schema
+	generateStandardSimpleClasses # Create Roog::Class instance for each standard schema simple type.
+	analyzeSubstitutionGroups     # Create Roog::Interface instance for each substitution group.
+	analyzeSimpleClasses          # Create Roog::Class instance for each schema-defined simple type.
+	analyzeComplexClasses         # Create Roog::Class instance for each complex type. Also creates Roog::Interface for choice groups.
+	analyzeDocumentRoot           # Create a Roog:Class instance corresponding to the document
+	# Resolve forward references: assemble (link up) model components, now that they have been created
+	linkSupers                    # Cache superEntity in entities with a xmlSuperName
+	linkAttributeTypes            # Cache domainType in Attribute
+	linkImplementors              # Cache Class.implementedInterfaces and Interface.implementors, populating Class.xml_implementedInterfaceNames
+	linkElementTypes              # Cache Attribute associated with each child element type
+	# Generate model pieces that need to be deduced (packages/paths), 
+	# and transform names according to the naming convetions of the language used.
+	# Builds Paths. During this, @namer generates Entity localName, pathString, and fqName
+	#   Uses these new names to build :classMap_domain, :interfaceMap_domain, :oldToNewNames, :newToOldNames
+        #   Also generates Attribute localName
+	packageAndSpecialize           
+end
+
+# Parse the Schema & prepare for subsequent queries
+def loadFile(fileName, context=REXML::Document::DEFAULT_CONTEXT)
+	print("\nLoading schema: " + fileName )
+	@schema = XSD::Schema.new( fileName, context)
+	print("\nDone loading schema." )
+end
+
+# Create Roog::Class instance for each standard schema simple type
+def generateStandardSimpleClasses
+	classNames = XSD::Schema.rootSimpleTypes
+	classNames.each { |className|
+		@classMap_xml[className] = Roog::Class.new( nil, className )
+		}
+end
+
+# Create Roog::Class instance for each schema-defined simple type
+def analyzeSimpleClasses()
+	@schema.globalSimpleTypes.each { |className, definition|
+		@classMap_xml[className]=Roog::Class.new( definition, className )
+		}
+end
+
+# Create Roog::Class instance for each complex type.
+#    Also creates Roog::Interface for choice groups
+def analyzeComplexClasses()
+	@schema.globalComplexTypes.each { |className, definition|
+		@classMap_xml[className]=Roog::Class.new( definition, className )
+		}
+end
+
+# Create Roog::Interface instance for each substitution group
+def analyzeSubstitutionGroups()
+	@schema.elementsInSubstitutionGroups.each { |headName, arrayOfAlts|
+		headDefn = @schema.globalElements[headName]
+		interface = Roog::Interface.new( headDefn, headName )
+		@interfaceMap_xml[headName]= interface
+		arrayOfAlts.each { |alt| interface.addAlt(alt) }
+		}
+end
+
+# Create a Roog:Class instance corresponding to the document
+# This document class can be created by the normal process (with definition==nil)
+#	dispatchElement is not called.
+#	Normally, dispatchElement would push the definition on the stack and call specify_complexType
+#	which then calls dispatchChildren which in turn calls dispatchElement(subElement) for all subElements.
+# This document class has:
+#	@localName                         Analyzer.xml_name_of_document_class.toModuleName  (set during normal renaming process)
+#	@definition                        nil
+#	@context                           Expected to be empty
+#	@xmlName                           Analyzer.xml_name_of_document_class.toModuleName
+#	@fqName                            Analyzer.xml_name_of_document_class.toModuleName  (set during normal renaming process)
+#	@pathString                        namer.defaultPathString  (set during normal renaming process, allowed to be nil)
+#	@xmlSuperName                      nil
+#	@superEntity                       nil
+#	@xml_implementedInterfaceNames     empty
+#	@implementedInterfaces             empty
+#	@transformer                       nil
+#	@attributes                        contains Roog::Attributes corrsponding to root elements
+#	@xmlAttributeLookup                (like attributes)
+#	@isAbstract                        false
+#	@isSimple                          true  (not really correct: results from definition==nil. We could change, but some code may expect definition to be present if false.)
+def analyzeDocumentRoot
+	rootClsName = Analyzer.xml_name_of_document_class
+	rootCls = Roog::Class.new( nil, rootClsName )
+	rootCls.isAbstract=true
+	@classMap_xml[rootClsName]=rootCls
+	@schema.globalElements.each { |eleName, eleDefinition|
+		rootCls.dispatchElement(eleDefinition)
+		}
+end
+
+# Cache Class.implementedInterfaces and Interface.implementors, populating Class.xml_implementedInterfaceNames
+def linkImplementors()
+	@interfaceMap_xml.each { |xmlName, interface|
+		interface.xml_implementorNames.each { |implName|
+			if implName==nil
+				error "Interface "+xmlName+" has a nil implName"
+			else
+				implementor=@classMap_xml[implName]
+				if implementor==nil
+					error "Interface "+xmlName+" can't find implementor "+implName
+				else
+					
+					interface.addImplementor(implementor)
+					end
+				end
+			}
+		}
+end
+
+# Cache superEntity in entities with a xmlSuperName
+def linkSupers(map=nil)
+	if map==nil
+		linkSupers @classMap_xml
+		linkSupers @interfaceMap_xml
+		return
+		end
+	map.each { |xmlName, entity|
+		xmlSuperName = entity.xmlSuperName
+		if xmlSuperName!=nil
+			spr = map[xmlSuperName]
+			entity.superEntity=spr
+			error "Can't find superEntity #{xmlSuperName} of  #{xmlName}" if spr==nil
+			spr.add_subEntity(entity) if spr!=nil
+			end
+		}
+end
+
+# Cache domainType in Attribute
+def linkAttributeTypes
+	@classMap_xml.each_value { |cls|
+		cls.allLocalAttributes.each {|attribute|
+			xmlTypeName=attribute.xmlTypeName
+			type = xmlEntityLookup(xmlTypeName)
+			attribute.domainType = type
+			}
+		}
+end
+
+# Cache Attribute associated with each child element type, and conrete class for element type
+def linkElementTypes
+	@classMap_xml.each_value { |cls|
+		cls.allLocalAttributes.each {|attribute|
+			entity=xmlEntityLookup(attribute.xmlTypeName)
+			if entity.isClass?
+				# Is it always right to use attribute's xmlName?
+				# elementName might be a role name.
+				# Should we worry about subclassing? (not for Offspring)
+				elementName=attribute.xmlName
+				cls.xmlAttributeLookup[elementName]=attribute
+				attribute.associate_elementName_to_class(elementName, entity)
+			else
+				# The entity is an interface. It represents
+				# a subsitution group or a choice group. Ethier way
+				# we need to add the attribute under each
+				# element name. 
+				# This may not correctly handle roles.
+				entity.implementorNameMap(self).each { |elementName, xmlTypeName|
+					cls.xmlAttributeLookup[elementName]=attribute
+					implClass=xmlEntityLookup(xmlTypeName)
+					attribute.associate_elementName_to_class(elementName, implClass)
+					}
+				end
+			}
+		}
+end
+
+
+
+def xmlEntityLookup(xmlTypeName)
+	answer=classMap_xml[xmlTypeName]
+	return answer if answer
+	answer=interfaceMap_xml[xmlTypeName]
+	if answer==nil
+	joinStr = "', '"
+	fatal "Can't find Entity from xmlName: #{xmlTypeName}, classes are: '#{classMap_xml.keys.join(joinStr)}' interfaces are: '#{interfaceMap_xml.keys.join(joinStr)}'"
+		end
+	return answer
+end
+
+def allClasses
+	@classMap_xml.values
+end
+
+def allInterfaces
+	@interfaceMap_xml.values
+end
+
+def allEntities
+	allClasses + allInterfaces
+end
+
+# Includes the root package with nil localName
+def allPackages
+	@pathMap.values
+end
+
+def allPackages_exceptRoot
+	allPackages.select {|p| p.localName }
+end
+
+# Generate model pieces that need to be deduced (packages/paths), 
+# and transform names according to the naming convetions of the language used.
+# Builds Paths. During this, @namer generates Entity localName, pathString, and fqName
+#   Uses these new names to build :classMap_domain, :interfaceMap_domain, :oldToNewNames, :newToOldNames
+#   Also generates Attribute localName
+def packageAndSpecialize
+	allEntities.each { |entity| renameAndAssignToPath(entity) }
+end
+
+# entity is a Roog::Class or Roog::Interface.
+def renameAndAssignToPath( entity)
+	oldName = entity.xmlName
+	names = namer.newEntityNames(entity)
+	entity.rename(names)
+	associateNames(oldName, entity.localName)
+	domainRegisterEntity( entity )
+	assignToPath( entity, entity.pathString)
+	if entity.isClass?
+		entity.collectAttribues! { |attrib|
+			attrib.localName = namer.newAttributeName( attrib)
+			attrib
+			}
+		end
+end
+
+
+def assignToPath( entity, pathString)
+	# print "\nPath: #{pathString} Entity: #{entity} "
+	path = findOrBuildPath(pathString)
+	path.addEntity(entity)
+end
+
+# This is called only for the path part of a qualified
+# name (or, recursively, a fraction of that path): it
+# is not called with an entity name at the end.
+def findOrBuildPath(pathString)
+	path = pathMap[pathString]
+	if path!=nil
+		return path
+		end
+	decomposition = namer.splitNamespace(pathString)
+	if decomposition==nil
+		# must be a child of the rootPath
+		path = Path.new(pathString, @rootPath)
+		pathMap[pathString]=path
+		return path
+		end
+	parent = findOrBuildPath( decompositon[0] )
+	path = Path.new(decomposition[1], parent)
+	pathMap[pathString]=path
+	return path
+end
+
+# End of class
+end
+
+
+
+
+# ===========================================================================================================
+#
+# Generates Ruby source code
+#
+class Generator_Ruby
+
+attr_accessor :globalMixin, :globalSuper, :doNameSort, :doTopoSort
+
+Indention = "\t"
+
+def initialize(globalMixin=roog_policy.globalMixin, globalSuper=roog_policy.globalSuper)
+	compileable=true
+	# doNameSort was intended to make toposorting independent of the order of the schema file.
+	#    This feature is not yet fully functional, see comment on doTopoSort.
+	@doNameSort=true
+	# doTopoSort is required to actually compile the resulting code:
+	#    it ensures that references that can not be forwarded are declared first.
+	#    topo sorting currently results in unnecessarily changed order of classes
+	#    when the schema changes, almost certainly because DAG < RGL::DirectedAdjacencyGraph
+	#    is iterating over a Hash or a Set.  Because of this, I sometimes turn off topo sorting
+	#    and use the uncompilable file with (doNameSort=true) to view the changes in the schema,
+	#    as they are reflected in the Ruby source code.
+	@doTopoSort=true
+	@io = nil
+	@globalMixin=globalMixin
+	@globalSuper=globalSuper
+	@divider="# ==================================================================="
+end
+
+# Creates and uses a transient instance.
+def Generator_Ruby.writeTo( io_or_filepathString, globalMixin=roog_policy.globalMixin, globalSuper=roog_policy.globalSuper )
+	Generator_Ruby.new(globalMixin, globalSuper).writeTo( io_or_filepathString )
+end
+
+# Argument can be:
+#	a String specifying a file path, in which case this will gracefully close the IO
+#	a File (or other IO), in which case the caller needs to gracefully close the IO
+def writeTo( io_or_filepathString )
+	if io_or_filepathString.kind_of?(String)
+		# The "w" mode is write only, truncating any existing file, or creating a new one.
+		File.open( io_or_filepathString, "w") {|aFile|
+			writeTo(aFile)
+			}
+	elsif io_or_filepathString.kind_of?(IO)
+		@io = io_or_filepathString
+		_writeHeader
+		_writeContents
+		_writeFooter
+	else
+		"Generator_Ruby.writeTo does not understand arguments of type "+io_or_filepathString.class.name
+		end
+end
+
+# protected
+
+def divide(indent, type, num)
+	@io << "\n\n\n"
+	@io << "\n"+indent+@divider
+	@io << "\n"+indent+"#         " + type + " (" + num.to_s+")"
+	@io << "\n"+indent+@divider
+	@io << "\n"
+end
+
+def _writeHeader
+	@io << "\n\n\n"
+	@io << "\n"+@divider
+	@io << "\n# Do not modify! This file generated from schema by Ruby Object Ontology Generator"
+	@io << "\n"+@divider
+	@io << "\n"
+end
+
+def _writeFooter
+end
+
+# Replaces  _writePath(Analyzer.instance.rootPath, indent)
+def _writeContents(indent='')
+	_writePackages(indent)
+	_writeInterfaces(indent)
+	_writeSimpleTypes(indent)
+	_writeComplexTypes(indent)
+end
+
+def sort(aCollection)
+	aCollection.sort! {|x,y| x.localName <=> y.localName } if doNameSort
+	aCollection = DAG.topoSortDependents(:all, aCollection) if doTopoSort
+	aCollection
+end
+
+def _writePackages(indent='')
+	items = Analyzer.instance.allPackages_exceptRoot
+	divide(indent, "Packages", items.size)
+	items = sort(items)
+	items.each { |pkg| _writePackage(pkg, indent) }
+end
+
+def _writeInterfaces(indent='')
+	items = Analyzer.instance.allInterfaces
+	divide(indent, "Interfaces", items.size)
+	items = sort(items)
+	items.each { |interface| _writeInterface(interface, indent) }
+end
+
+def _writeSimpleTypes(indent='')
+	items = Analyzer.instance.allClasses.select {|item| item.isSimple }
+	divide(indent, "SimpleTypes", items.size)
+	items = sort(items)
+	items.each { |klass| _writeClass(klass, indent) }
+end
+
+def _writeComplexTypes(indent='')
+	items = Analyzer.instance.allClasses.reject {|item| item.isSimple }
+	divide(indent, "ComplexTypes", items.size)
+	items = sort(items)
+	items.each { |klass| _writeClass(klass, indent) }
+end
+
+def _writePackage(package, indent='')
+	return if !package
+	@io << "\n\n#{indent}module #{package.localName}; end";
+end
+
+# DEPRECATED in favor of _writeContents
+# See also a change to _writeClass and _writeInterface
+# XML lets you mix up packages in a way that prohibits straightforward 
+# hierarchical code.  For example, a choice group (that translates to a 
+# Ruby Module acting as an Interface) can contain elements from other
+# namespaces (including simple Xsd types). This means that modules
+# A and B may each need to refer to something defined in the other module.
+# As another example, a class in A may inherit from a class in B,
+# while some other class in B inherits from some other class in A.
+def _writePath(path, indent="")
+	if path.localName!=nil
+		@io << "\n\n#{indent}module #{path.localName}"
+		_writePathContents(path, indent+Indention)
+		@io << "\n#{indent}end"
+		return
+		end
+	_writePathContents(path, indent)
+end
+
+def _writePathContents(path, indent)
+	# Write interfaces
+	interfaces = path.interfaces
+	divide(indent, "Interfaces", interfaces.size)
+	interfaces.sort! {|x,y| x.localName <=> y.localName } if doNameSort
+	interfaces = DAG.topoSortDependents(:samePathAndEntityType, interfaces) if doTopoSort
+	interfaces.each { |interface| _writeInterface(interface, indent) }
+	# Write sub-packages
+	divide(indent, "Packages", path.childPaths.size)
+	subPaths = path.childPaths.clone
+	subPaths.sort! {|x,y| x.localName <=> y.localName } if doNameSort
+	subPaths = DAG.topoSortDependents(:pathDependency, subPaths) if doTopoSort
+	subPaths.each { |kid| _writePath(kid, indent) if kid }
+	# Write classes
+	classes = path.classes
+	divide(indent, "Classes", classes.size)
+	classes.sort! {|x,y| x.localName <=> y.localName } if doNameSort
+	classes = DAG.topoSortDependents(:samePathAndEntityType, classes) if doTopoSort
+	classes.each { |cls| _writeClass(cls, indent) }
+end
+
+
+def _writeInterface(interface, indent)
+	if interface == nil
+		return
+		end
+	# AFG changed from interface.localName to interface.fqName when _writePath was deprecated
+	@io << "\n\n#{indent}module #{interface.fqName}"
+	if interface.superEntityFqName!=nil
+		@io << "\n#{indent}#{Indention}include " + interface.superEntityFqName
+	elsif globalMixin!=nil
+		@io << "\n#{indent}#{Indention}include " + globalMixin
+		end
+	@io << "\n#{indent}end"
+end
+
+def _writeClass(cls, indent)
+	return if cls == nil
+	return if !cls.isClass?
+	return if Analyzer.xml_name_of_document_class==cls.localName
+	# AFG changed from cls.localName to cls.fqName when _writePath was deprecated
+	@io << "\n\n#{indent}class #{cls.fqName}"
+	superName=cls.superEntityFqName
+	superName=globalSuper if superName==nil
+	if superName!=nil
+		@io << " < " + superName
+		end
+	if cls.implementsInterface
+		@io << "\n#{indent}#{Indention}include "
+		implementedFqInterfaceNames=cls.implementedFqInterfaceNames
+		lastIdx=implementedFqInterfaceNames.size-1
+		implementedFqInterfaceNames.each_index {|idx|
+			@io << implementedFqInterfaceNames[idx]
+			if idx<lastIdx
+				@io << ", "
+				end
+			}
+	elsif globalMixin!=nil
+		@io << "\n#{indent}#{Indention}include #{globalMixin}"
+		end
+	@io << "\n#{indent}#{Indention}# " << cls.description
+	attrs = cls.attributes.values.clone
+	attrs.sort! {|x,y| x.localName <=> y.localName } if doNameSort
+	attrs.each { |attrib| _writeAttribute(attrib, indent) }
+	initializedAttributes = cls.initializedAttributes.clone
+	initializedAttributes.sort! {|x,y| x.localName <=> y.localName } if doNameSort
+	if !initializedAttributes.empty?
+		attrIndent = indent+Indention+Indention
+		@io << "\n#{indent}#{Indention}def initialize"
+		@io << "\n#{indent}#{Indention}#{Indention}super"
+		initializedAttributes.each { |attrib|
+			_writeAttributeInitialization(attrib, attrIndent)
+			}
+		@io << "\n#{indent}#{Indention}end"
+		end
+	@io << "\n#{indent}end"
+end
+
+def _writeAttribute(attribute, indent)
+	@io << "\n#{indent}#{Indention}attr_accessor :#{attribute.localName} # "+attribute.description
+end
+
+# So far don't deduce where Hashes are needed
+def _writeAttributeInitialization(attribute, indent)
+	@io << "\n"+indent+"@"+attribute.localName+" = Array.new"
+end
+
+end # Class Generator_Ruby
+
+# ===========================================================================================================
+# Used to marshal or unmarshal one datum. Applicable only to simple data.
+# fromStringSym and toStringSym are symbols denoting messages sent to the
+# Transformer_Ruby (rather than the thing being converted, or the Roog::Class,
+# or Roog::Attribute).
+#
+# If fromStringSym is nil, the domain object must have a :new method which
+# takes one string argument. If toStringSym is nil, the domain object must
+# have a :to_s method which produces the marshaling result.
+#
+# parentClass specifies the superclass of the xsd class with which the Transformer_Ruby
+# is associated. If parentClass is nil, the xsd class will inherit from Object.
+# Note that fromStringSym need not create a domain object of the class specified by
+# the Roog::Class.
+#
+# domainClasses must must include all the possible classes resulting from fromStringSym.
+#
+# For example, in Ruby there is no Boolean class (only TrueClass and FalseClass,
+# which both inherit directly from Object), so there is nothing for xsd:boolean
+# to inherit from. We could just let it inherit from Object, and let it wrap
+# a Ruby Boolean. Yuk: we would have to use an accessor every time we want the
+# darn Boolean. So instead, the method invoked by fromStringSym returns either 
+# the singleton TrueClass or FalseClass instance.
+#
+# It is less clear what should be done about Integers. The schema may specify some
+# constraints that we would like to maintain after we have unmarshaled the data
+# Booleans are easier because they are too fundamental to have much in the way 
+# of constraints. Furthermore, there wasn't much of a choice, since there was no
+# superclass, but in the case of integers, we could use Integer. If we let
+# :fromStringSym just create a Bignum or Fixednum the constraints in the schema
+# would dissapear. We could perhaps add the constraints to a Bignum, but 
+# they can not be added to Fixednums (which do not support singleton methods),
+# and the propagation of constraints would be problematical. The complicated 
+# solution is to create an xsd class (call it XSDInt) which inherits from Integer, wraps a
+# Bignum or Fixednum, and which carries constraints. This involves implementing
+# almost all of the numeric behaviors, and insuring that operations with numeric
+# results always return an XSDInt. The propagation of constraints might get
+# tricky when a numeric results from two XSDInts. For now, the easiest thing to
+# do is apply the constraints only at boundaries (when marshaling/unmarshaling, and
+# at the GUI), and let :fromStringSym create a Fixednum or Bignum. Same thing for 
+# xsd:double and xsd:decimal.
+#
+#
+# I liked the idea of using procs instead of symbols, but it made
+# the dictionary construction too complicated.
+class Transformer_Ruby
+
+attr_reader :parentClass, :fromStringSym, :toStringSym, :domainClasses
+
+def initialize( parentClass, fromStringSym=nil, domainClasses=nil, toStringSym=nil )
+	assert { "domainClasses must be provideed if fromStringSym!=nil"} if fromStringSym!=nil && domainClasses==nil
+	@parentClass=parentClass
+	@fromStringSym=fromStringSym
+	@toStringSym=toStringSym
+	@domainClasses=domainClasses
+end
+
+def to_s
+	self.class.name                   << '  ' \
+	<< (parentClass   || 'nil').to_s  << '  ' \
+	<< (fromStringSym || 'nil').to_s  << '  ' \
+	<< (toStringSym   || 'nil').to_s 
+end
+
+def parentFqName
+	return nil if parentClass==nil
+	answer = parentClass.name
+	return answer if answer.index('::')
+	'::'+answer
+end
+
+def fromString(str, roogClass, attributeData)
+	return self.send(fromStringSym, str, roogClass, attributeData) if fromStringSym!=nil
+	return str if roog_policy.use_framelets
+	instantiate_class_named(roogClass.fqName, false, str) 
+end
+
+def toString(obj, roogClass)
+	return obj.to_s if toStringSym==nil
+	self.send(toStringSym, obj, roogClass)
+end
+
+def str2boolean(str, roogClass, attributeData)
+	#print "\n ~~~~ str2boolean(#{str})"
+	return nil if str.empty?
+	str.downcase=="true"
+end
+
+def str2int(str, roogClass, attributeData)
+	#print "\n ~~~~ str2int(#{str})"
+	return nil if str.empty?
+	str.to_i
+end
+
+def str2float(str, roogClass, attributeData)
+	#print "\n ~~~~ str2float(#{str})"
+	return nil if str.empty?
+	str.to_f
+end
+
+def float2str(obj, roogClass)
+	return nil if !obj.kind_of?(Float)
+	format = roogClass.float_format
+	# Don't really know if sprintf format strings are expressive enough.
+	return sprintf( format, obj ) if !format.nil?
+	# Oops, not true:  Ensure it has a decimal place. to_s results in '0' for 0.0
+	answer = obj.to_f
+	answer
+	#return answer if answer.include? ?.
+	#answer + '.0'
+end
+
+def str2time(str, roogClass, attributeData)
+	#print "\n ~~~~ str2time(#{str})"
+	#attributeData.treeDump
+	return nil if str.empty?
+	return Time.from_string(str)
+	rescue
+		print "\n ~~~~ str2time unable to convert #{str}, using Time.now"
+		Time.now
+end
+
+def time2str(obj, roogClass)
+# to_s results in times of the form "Fri Feb 13 13:24:00 UTC 2004"
+#                        instead of "2004-02-13T13:24:00"
+	return nil if !obj.kind_of?(Time)
+	obj.strftime("%Y-%m-%dT%H:%M:%S")
+end
+
+end # Transformer_Ruby
+
+# ===========================================================================================================
+# Answers language dependent questions unrelated to
+# source code generation
+class Semantics_Ruby
+
+attr_accessor :globalModule, :transformers
+
+def initialize(globalModule=roog_policy.globalModule)
+@globalModule=globalModule
+# This must have a key for every simpleType in XSD::Schema.rootSimpleTypes
+# It can optionally have an entry for simple types not in XSD..
+@transformers = {
+	"xsd:anyURI"              => Transformer_Ruby.new( String ),
+	"xsd:base64Binary"        => Transformer_Ruby.new( String ), 
+	"xsd:boolean"             => Transformer_Ruby.new( nil, :str2boolean, [TrueClass, FalseClass] ), 
+	"xsd:dateTime"            => Transformer_Ruby.new( nil, :str2time,  [Time], :time2str ), 
+	"xsd:decimal"             => Transformer_Ruby.new( nil, :str2float, [Float] ), 
+	"xsd:double"              => Transformer_Ruby.new( nil, :str2float, [Float]),
+	"xsd:hexBinary"           => Transformer_Ruby.new( String ), 
+	"xsd:integer"             => Transformer_Ruby.new( nil, :str2int, [Fixnum, Bignum] ), 
+	"xsd:nonNegativeInteger"  => Transformer_Ruby.new( nil, :str2int, [Fixnum, Bignum] ), 
+	"xsd:positiveInteger"     => Transformer_Ruby.new( nil, :str2int, [Fixnum, Bignum] ), 
+	"xsd:string"              => Transformer_Ruby.new( String )
+	}
+end
+
+def initializeTransformer(roogClass)
+	return nil if !roogClass.isSimple
+	tx = roogClass.transformer
+	return tx if tx!=nil
+	tx = transformers[roogClass.xmlName]
+	roogClass.transformer = tx
+	return tx if tx!=nil
+	parent = roogClass.superEntity
+	return nil if parent==nil
+	tx = initializeTransformer(parent)
+	roogClass.transformer = tx
+	tx
+end
+
+def add_global_module(roogClass)
+	return if roogClass.isSimple
+end
+
+def specialize(analyzer=Roog::Analyzer.instance)
+	rp = analyzer.rootPath
+	rp.localName=globalModule if !rp.localName || rp.localName.empty?
+	analyzer.allClasses.each { |cls| 
+		initializeTransformer(cls)
+		}
+end
+
+def self.specialize(analyzer=Roog::Analyzer.instance)
+	self.new.specialize(analyzer)
+end
+
+end # Semantics_Ruby
+
+end # Module Roog
+
+
+
+
+# ===========================================================================================================
+# ===========================================================================================================
+# ===========================================================================================================
+
+if __FILE__ == $0 #directlyInvoked?
+	require "Getopt/Declare"
+	commandLineSpec = %q(
+		<schemaPath:if>		path to schema file [required]
+		<domainPath:of>		path to output domain source code file [required]
+		<globalMixin>		optional name of module to be mixed into everything
+		<globalSuper>		optional name of superclass of all objects not ineriting from simple classes
+		)
+	args = Getopt::Declare.new(commandLineSpec)
+	Roog::Analyzer.analyze( args["<schemaPath>"] )
+	Roog::Semantics_Ruby.specialize
+	Roog::Generator_Ruby.writeTo( args["<domainPath>"], args["<globalMixin>"], args["<globalSuper>"] )
+	print( "\n\n*** Done ***\n\n")
+end
+
+
+
+