rgen 0.2.0 → 0.3.0

data/CHANGELOG

@@ -7,3 +7,12 @@
 * Added model transformation language (Transformer)
 * Now RGen is distributed as a gem
 * More complete documentation
+
+=0.3.0 (October 9th, 2006)
+
+* Improved XML Instantiator (Namespaces, Resolver, Customization)
+* Added many_to_one builder method
+* Added attribute reflection to MMBase (one_attributes, many_attributes)
+* Added +copy+ method to Transformer
+* Added simple model dumper module
+* Fixed mmgen/mmgen.rb

data/lib/ea/xmi_class_instantiator.rb

@@ -1,18 +1,15 @@
-require 'rgen/xml_instantiator/xml_instantiator'
+require 'rgen/xml_instantiator'
 require 'rgen/environment'
 require 'uml/uml_classmodel'
 require 'ea/xmi_metamodel'
 
 # This module can be used to instantiate an UMLClassModel from an XMI description.
-# It should be mixed into the using class.
 # 
 # Here is an example:
 # 
-# 	include XMIClassInstantiator
-# 	
 # 	envUML = RGen::Environment.new
 # 	File.open(MODEL_DIR+"/testmodel.xml") { |f|
-# 		instantiateUMLClassModel(envUML, f.read)
+# 		XMIClassInstantiator.new.instantiateUMLClassModel(envUML, f.read)
 # 	}
 #
 # 	# now use the newly created UML model
@@ -22,24 +19,28 @@ require 'ea/xmi_metamodel'
 #
 # This module relies on XmiToClassmodel to do the actual transformation.
 # 
-module XMIClassInstantiator
+class XMIClassInstantiator < RGen::XMLInstantiator
 	
 	include UMLClassModel
+	
+	map_tag_ns "omg.org/UML1.3", XMIMetaModel::UML
+	
+	resolve_by_id :typeClass, :src => :type, :id => :xmi_id
+	resolve_by_id :subtypeClass, :src => :subtype, :id => :xmi_id
+	resolve_by_id :supertypeClass, :src => :supertype, :id => :xmi_id
 
+	def initialize
+		@envXMI = RGen::Environment.new 
+		super(@envXMI, XMIMetaModel, true)
+	end
+	
 	# This method does the actual work.
 	def instantiateUMLClassModel(envOut, str)
-		inst = RGen::XMLInstantiator.new(XMIMetaModel, true) do |i|
-			i.resolveById("xmi_id","type")
-			i.resolveById("xmi_id","subtype")
-			i.resolveById("xmi_id","supertype")
-		end
-		
-		envXMI = RGen::Environment.new
-		inst.instantiate(envXMI, str)
-		
+		instantiate(str)
+
 		require 'ea/xmi_to_classmodel'
 		
-		XmiToClassmodel.new(envXMI,envOut).transform
+		XmiToClassmodel.new(@envXMI,envOut).transform
 	end
 
 end

data/lib/ea/xmi_helper.rb

@@ -16,7 +16,7 @@ end
 
 class TaggedValueHelper < MapHelper
 	def initialize(element)	
-		super('tag','value',element.UML_ModelElement_taggedValue.UML_TaggedValue)
+		super('tag','value',element.modelElement_taggedValue.taggedValue)
 	end
 end
 

data/lib/ea/xmi_metamodel.rb

@@ -1,19 +1,34 @@
+module XMIMetaModel
 
-	module XMIMetaModel
+	module UML
+	
 		include RGen::MetamodelBuilder
-		class UML_Classifier_feature < MMBase
+		class Classifier_feature < MMBase
+			has_many 'operation'
+		end
+		class ClassifierRole < MMBase
+		end
+		class Clazz < ClassifierRole
+			has_many 'modelElement_stereotype'
 		end
-		class UML_Class < MMBase
+		class Operation < MMBase
+			has_one 'parent'
 		end
-		class UML_Operation < MMBase
+		class Generalization < MMBase
 		end
-		class UML_Generalization < MMBase
+		class ModelElement_stereotype < MMBase
+			has_one 'parent'
 		end
-		class UML_ModelElement_stereotype < MMBase
+		class AssociationEnd < MMBase
 		end
-		UML_Classifier_feature.one_to_many 'UML_Operation', UML_Operation, '_p_UML_Classifier_feature'		
-		UML_Class.one_to_many 'UML_ModelElement_stereotype', UML_ModelElement_stereotype, '_p_UML_Class'		
-#		UML_Class.one_to_many 'UML_Generalization_supertype', UML_Generalization, 'supertype_UML_Class'
-#		UML_Class.one_to_many 'UML_Generalization_subtype', UML_Generalization, 'subtype_UML_Class'
+		class AssociationEndRole < MMBase
+		end
+		ClassifierRole.one_to_many 'associationEnds', AssociationEnd, 'typeClass'
+		ClassifierRole.one_to_many 'associationEndRoles', AssociationEndRole, 'typeClass'
+		Clazz.one_to_many 'generalizationsAsSubtype', Generalization, 'subtypeClass'
+		Clazz.one_to_many 'generalizationsAsSupertype', Generalization, 'supertypeClass'
+	
 	end
+
+end
 	

data/lib/ea/xmi_object_instantiator.rb

@@ -1,10 +1,9 @@
-require 'rgen/xml_instantiator/xml_instantiator'
+require 'rgen/xml_instantiator'
 require 'rgen/environment'
 require 'uml/uml_objectmodel'
 require 'ea/xmi_metamodel'
 
 # This module can be used to instantiate an UMLObjectModel from an XMI description.
-# It should be mixed into the using class.
 # 
 # Here is an example:
 # 
@@ -12,7 +11,7 @@ require 'ea/xmi_metamodel'
 # 	
 # 	envUML = RGen::Environment.new
 # 	File.open(MODEL_DIR+"/testmodel.xml") { |f|
-# 		instantiateUMLObjectModel(envUML, f.read)
+# 		XMIClassInstantiator.new.instantiateUMLObjectModel(envUML, f.read)
 # 	}
 #
 # 	# now use the newly created UML model
@@ -22,21 +21,26 @@ require 'ea/xmi_metamodel'
 #
 # This module relies on XmiToObjectmodel to do the actual transformation.
 # 
-module XMIObjectInstantiator
+class XMIObjectInstantiator < RGen::XMLInstantiator
 	
 	include UMLObjectModel
 
-	def instantiateUMLObjectModel(envOut, str)
-		inst = RGen::XMLInstantiator.new(XMIMetaModel, true) do |i|
-			i.resolveById("xmi_id","type")
-		end
-		
-		envXMI = RGen::Environment.new
-		inst.instantiate(envXMI, str)
+	map_tag_ns "omg.org/UML1.3", XMIMetaModel::UML
+	
+	resolve_by_id :typeClass, :src => :type, :id => :xmi_id
 
+	def initialize
+		@envXMI = RGen::Environment.new 
+		super(@envXMI, XMIMetaModel, true)
+	end
+
+	# This method does the actual work.
+	def instantiateUMLObjectModel(envOut, str)
+		instantiate(str)
+				
 		require 'ea/xmi_to_objectmodel'
 		
-		XmiToObjectmodel.new(envXMI,envOut).transform
+		XmiToObjectmodel.new(@envXMI,envOut).transform
 	end
 
 end

data/lib/ea/xmi_to_classmodel.rb

@@ -17,45 +17,45 @@ class XmiToClassmodel < RGen::Transformer
 	# Do the actual transformation.
 	# Input and output environment have to be provided to the transformer constructor.
 	def transform
-		trans(:class => XMIMetaModel::UML_Class)
+		trans(:class => XMIMetaModel::UML::Clazz)
 	end
 	
-	transform XMIMetaModel::UML_Package, :to => UMLPackage do
+	transform XMIMetaModel::UML::Package, :to => UMLPackage do
 		{ :name => name, 
-			:superpackage => trans(_p_UML_Namespace_ownedElement._p_UML_Package) }
+			:superpackage => trans(parent.parent.is_a?(XMIMetaModel::UML::Package) ? parent.parent : nil) }
 	end
 	
-	transform XMIMetaModel::UML_Attribute, :to => UMLAttribute do
+	transform XMIMetaModel::UML::Attribute, :to => UMLAttribute do
 		tv = TaggedValueHelper.new(@current_object)
 		{	:name => name, :type => tv['type'] }
 	end
 	
-	transform XMIMetaModel::UML_Operation, :to => UMLOperation do
+	transform XMIMetaModel::UML::Operation, :to => UMLOperation do
 		{ :name => name }
 	end
 	
-	transform XMIMetaModel::UML_TaggedValue, :to => UMLTaggedValue do
+	transform XMIMetaModel::UML::TaggedValue, :to => UMLTaggedValue do
 		{ :tag => tag, :value => value }
 	end
 	
-	transform XMIMetaModel::UML_Class, :to => UMLClass do
+	transform XMIMetaModel::UML::Clazz, :to => UMLClass do
 		{ :name => name,
-			:package => trans(_p_UML_Namespace_ownedElement._p_UML_Package),
-			:attributes => trans(getUML_Classifier_feature.UML_Attribute),
-			:operations => trans(getUML_Classifier_feature.UML_Operation),
-			:taggedvalues => trans(getUML_ModelElement_taggedValue.UML_TaggedValue),
-			:stereotypes => getUML_ModelElement_stereotype.UML_Stereotype.name,
-			:subclasses =>  trans(getUML_Generalization_supertype.subtype_UML_Class),
-			:assocEnds => trans(getUML_AssociationEnd_type)}
+			:package => trans(parent.parent.is_a?(XMIMetaModel::UML::Package) ? parent.parent : nil),
+			:attributes => trans(classifier_feature.attribute),
+			:operations => trans(classifier_feature.operation),
+			:taggedvalues => trans(modelElement_taggedValue.taggedValue),
+			:stereotypes => modelElement_stereotype.stereotype.name,
+			:subclasses =>  trans(generalizationsAsSupertype.subtypeClass),
+			:assocEnds => trans(associationEnds)}
 	end
 	
-	transform XMIMetaModel::UML_Association, :to => :scAssociationClass do
+	transform XMIMetaModel::UML::Association, :to => :scAssociationClass do
 		{ :endA => trans(scAssocEnds[0]),
 			:endB => trans(scAssocEnds[1]) }
 	end	
 	
 	method :scAssocEnds do
-		getUML_Association_connection.UML_AssociationEnd
+		association_connection.associationEnd
 	end
 	
 	method :scAssociationClass do
@@ -64,11 +64,11 @@ class XmiToClassmodel < RGen::Transformer
 		 UMLAggregation : UMLAssociation )
 	end
 	
-	transform XMIMetaModel::UML_AssociationEnd, :to => UMLAssociationEnd do
+	transform XMIMetaModel::UML::AssociationEnd, :to => UMLAssociationEnd do
 		# since we don't want to figure out if we are end A or end B,
 		# we let the association transformer do the work
-		trans(_p_UML_Association_connection._p_UML_Association)
-		{ :clazz => trans(type_UML_Class),
+		trans(parent.parent)
+		{ :clazz => trans(typeClass),
 			:role => name,
 			:multiplicity => multiplicity,
 			:composite => (aggregation == 'composite'),

data/lib/ea/xmi_to_objectmodel.rb

@@ -17,22 +17,25 @@ class XmiToObjectmodel < RGen::Transformer
 	# Do the actual transformation.
 	# Input and output environment have to be provided to the transformer constructor.
 	def transform
-		trans(:class => XMIMetaModel::UML_ClassifierRole)
+		trans(
+			@env_in.find(:class => XMIMetaModel::UML::ClassifierRole)-
+			@env_in.find(:class => XMIMetaModel::UML::Clazz)
+		)
 	end
 
-	transform XMIMetaModel::UML_Package, :to => UMLPackage do
+	transform XMIMetaModel::UML::Package, :to => UMLPackage do
 		{ :name => name,
-			:superpackage => trans(_p_UML_Namespace_ownedElement._p_UML_Package) }
+			:superpackage => trans(parent.parent.is_a?(XMIMetaModel::UML::Package) ? parent.parent : nil) }
 	end
 	
-	transform XMIMetaModel::UML_ClassifierRole, :to => UMLObject, :if => :isEASTypeObject do 
-	 	trans(getUML_AssociationEndRole_type._p_UML_Association_connection._p_UML_AssociationRole)
-	 	trans(getUML_AssociationEnd_type._p_UML_Association_connection._p_UML_Association)
+	transform XMIMetaModel::UML::ClassifierRole, :to => UMLObject, :if => :isEASTypeObject do 
+	 	trans(associationEndRoles.parent.parent)
+	 	trans(associationEnds.parent.parent)
 	 	taggedValues = TaggedValueHelper.new(@current_object)
 	 	{ :name => name,
 	 	  :classname => taggedValues['classname'],
 	 	  :attributeSettings => createAttributeSettings(taggedValues['runstate']),
-	 	  :package => trans(_p_UML_Namespace_ownedElement._p_UML_Collaboration._p_UML_Namespace_ownedElement._p_UML_Package) }
+	 	  :package => trans(parent.parent.parent.parent) }
 	end
 	
 	method :isEASTypeObject do
@@ -56,8 +59,8 @@ class XmiToObjectmodel < RGen::Transformer
 		result
 	end
 	
-	transform XMIMetaModel::UML_AssociationRole, :to => UMLAssociation, :if => :isEATypeAssociation do
-		ends = getUML_Association_connection.UML_AssociationEndRole
+	transform XMIMetaModel::UML::AssociationRole, :to => UMLAssociation, :if => :isEATypeAssociation do
+		ends = association_connection.associationEndRole
 		{ :endA => trans(ends[0]), :endB => trans(ends[1])}
 	end
 	
@@ -66,21 +69,21 @@ class XmiToObjectmodel < RGen::Transformer
 		taggedValues['ea_type'] == 'Association'
 	end
 
-	transform XMIMetaModel::UML_Association, :to => UMLAggregation do
-		ends = getUML_Association_connection.UML_AssociationEnd
+	transform XMIMetaModel::UML::Association, :to => UMLAggregation do
+		ends = association_connection.associationEnd
 		{ :endA => trans(ends[0]), :endB => trans(ends[1])}
 	end
 		
-	transform XMIMetaModel::UML_AssociationEndRole, :to => UMLAssociationEnd do
+	transform XMIMetaModel::UML::AssociationEndRole, :to => UMLAssociationEnd do
 		buildAssociationEnd
 	end
 	
-	transform XMIMetaModel::UML_AssociationEnd, :to => UMLAssociationEnd do
+	transform XMIMetaModel::UML::AssociationEnd, :to => UMLAssociationEnd do
 		buildAssociationEnd
 	end
 	
 	method :buildAssociationEnd do
-		{ :object => trans(type_UML_ClassifierRole),
+		{ :object => trans(typeClass),
 		  :role => name,
 		  :composite => (aggregation == 'composite'),
 		  :navigable => (isNavigable == 'true') }

data/lib/mmgen/mmgen.rb

@@ -1,21 +1,26 @@
-require 'ea/xmi_instantiator'
+$:.unshift File.join(File.dirname(__FILE__),"..")
+
+require 'ea/xmi_class_instantiator'
 require 'mmgen/metamodel_generator'
 
-include XMIClassInstantiator
 include MMGen::MetamodelGenerator
 
-unless ARGV.length == 1
-	puts "Usage: mmgen.rb <xmi_class_model_file>"
+unless ARGV.length >= 2
+	puts "Usage: mmgen.rb <xmi_class_model_file> <root package> (<module>)*"
 	exit
 else
 	file_name = ARGV.shift
-	out_file = file_name.gsub(/\.\w+$/,'')
+	root_package_name = ARGV.shift
+	modules = ARGV
+	out_file = file_name.gsub(/\.\w+$/,'.rb')
 	puts out_file
 end
 
 envUML = RGen::Environment.new
 File.open(file_name) { |f|
-	instantiateUMLClassModel(envUML, f.read)
+	XMIClassInstantiator.new.instantiateUMLClassModel(envUML, f.read)
 }
 
-generateMetamodel(envUML, out_file)
+rootPackage = envUML.find(:class => UMLClassModel::UMLPackage).select{|p| p.name == root_package_name}.first
+
+generateMetamodel(rootPackage, out_file, modules)

data/lib/rgen/instantiator.rb

@@ -0,0 +1,62 @@
+module RGen
+
+class Instantiator
+
+	ResolverDescription = Struct.new(:from, :attribute, :block) # :nodoc:
+
+	class << self
+		attr_accessor :resolver_descs
+	end
+
+	def initialize(env, mod)
+		@env = env
+	end
+
+	# Specifies that +attribute+ should be resolved. If +:class+ is specified, 
+	# resolve +attribute+ only for objects of type class.
+	# The block must return the value to which the attribute should be assigned.
+	# The object for which the attribute is to be resolved will be accessible
+	# in the current context within the block.
+	# 
+	def self.resolve(attribute, desc=nil, &block)
+		from = (desc.is_a?(Hash) && desc[:class])
+		self.resolver_descs ||= []
+		self.resolver_descs << ResolverDescription.new(from, attribute, block)
+	end
+	
+	# Resolves +attribute+ to a model element which has attribute +:id+ set to the
+	# value currently in attribute +:src+
+	# 
+	def self.resolve_by_id(attribute, desc)
+		id_attr = (desc.is_a?(Hash) && desc[:id])
+		src_attr = (desc.is_a?(Hash) && desc[:src])
+		raise StandardError.new("No id attribute given.") unless id_attr
+		resolve(attribute) do
+			@env.find(id_attr => @current_object.send(src_attr)).first
+		end
+	end
+	
+	private
+	
+	def method_missing(m, *args) #:nodoc:
+		if @current_object
+			@current_object.send(m)
+		else
+			super
+		end
+	end
+	
+	def resolve
+		self.class.resolver_descs ||= []
+		self.class.resolver_descs.each { |desc|
+			@env.find(:class => desc.from).each { |e|
+				old_object, @current_object = @current_object, e
+				e.send("#{desc.attribute}=", instance_eval(&desc.block)) if e.respond_to?("#{desc.attribute}=")
+				@current_object = old_object
+			}
+		}
+	end			
+	
+end
+
+end

data/lib/rgen/metamodel_builder/builder_extensions.rb

@@ -74,6 +74,12 @@ module BuilderExtensions
 		target_class.has_one_internal(target_role,self,own_role,:many)
 	end
 	
+	# This is the inverse of one_to_many provided for convenience.
+	def many_to_one(own_role, target_class, target_role)
+		has_one_internal(own_role,target_class,target_role,:many)
+		target_class.has_many_internal(target_role,self,own_role,:one)
+	end
+	
 	# Add a bidirectional many-to-many association between two classes.
 	# The class this method is called on is refered to as _own_class_ in 
 	# the following.
@@ -124,12 +130,31 @@ module BuilderExtensions
 		target_class.has_one_internal(target_role,self,own_role,:one)
 	end
 	
+	# Returns the names of the classes attributes pointing to a single object.
+	# The result includes this kind of attributes of the superclass.
+	def one_attributes
+		@one_attributes ||= []
+		result = @one_attributes.dup
+		result += superclass.one_attributes if superclass.respond_to?(:one_attributes)
+		result
+	end
+	
+	# Returns the names of the classes attributes pointing to many other objects
+	# The result includes this kind of attributes of the superclass.
+	def many_attributes
+		@many_attributes ||= []
+		result = @many_attributes.dup
+		result += superclass.many_attributes if superclass.respond_to?(:many_attributes)
+		result
+	end
+	
 	protected
 	
 	def has_one_internal(name, cls=nil, role=nil, kind=nil)
+		@one_attributes ||= []
+		return if @one_attributes.include?(name)
+		@one_attributes << name
 		BuildHelper.build self, binding, <<-CODE
-			@@one_assocs ||= []
-			@@one_assocs << name
 			def #{name}=(val)
 				return if val == @#{name}
 				<% if cls %>
@@ -149,9 +174,10 @@ module BuilderExtensions
 	end
 	
 	def has_many_internal(name, cls=nil, role=nil, kind = nil)
+		@many_attributes ||= []
+		return if @many_attributes.include?(name)
+		@many_attributes << name
 		BuildHelper.build self, binding, <<-CODE
-			@@many_assocs ||= []
-			@@many_assocs << name
 			def add<%= firstToUpper(name) %>(val)
 				@#{name} = [] unless @#{name}
 				return if val.nil? or @#{name}.include?(val) 

data/lib/rgen/model_dumper.rb

@@ -0,0 +1,24 @@
+module RGen
+
+module ModelDumper
+
+	def dump(obj=nil)
+		obj ||= self
+		if obj.is_a?(Array)
+			obj.collect {|o| dump(o)}.join("\n\n")
+		elsif obj.class.respond_to?(:one_attributes) && obj.class.respond_to?(:many_attributes)
+			([obj.to_s] +
+			obj.class.one_attributes.collect { |a| 
+				"   #{a} => #{obj.getGeneric(a)}"
+			} +
+			obj.class.many_attributes.collect { |a|
+				"   #{a} => [ #{obj.getGeneric(a).join(', ')} ]"
+			}).join("\n")
+		else
+			obj.to_s
+		end
+	end
+
+end
+
+end

data/lib/rgen/name_helper.rb

@@ -4,7 +4,7 @@
 module RGen
 
 module NameHelper
-	def normalizeName(name)
+	def normalize(name)
 		name.gsub(/[\.:]/,'_')
 	end
 	def className(object)
@@ -13,6 +13,9 @@ module NameHelper
 	def firstToUpper(str)
 		str[0..0].upcase + ( str[1..-1] || "" )
 	end
+	def firstToLower(str)
+		str[0..0].downcase + ( str[1..-1] || "" )
+	end
 end
 
 end

data/lib/rgen/transformer.rb

@@ -196,6 +196,22 @@ class Transformer
 		end
 	end
 
+	# This class method specifies that all objects of class +from+ are to be copied
+	# into an object of class +to+. If +to+ is omitted, +from+ is used as target class.
+	# During copy, all attributes according to 
+	# MetamodelBuilder::BuilderExtensions.one_attributes and 
+	# MetamodelBuilder::BuilderExtensions.many_attributes of the target object
+	# are set to their transformed counterparts of the source object.
+	# 
+	def self.copy(from, to=nil)
+		transform(from, :to => to || from) do
+			Hash[*(@current_object.class.one_attributes + 
+			@current_object.class.many_attributes).inject([]) {|l,a|
+				l + [a.to_sym, trans(@current_object.send(a))]
+			}]
+		end
+	end
+	
 	# Define a transformer method for the current transformer class.
 	# In contrast to regular Ruby methods, a method defined this way executes in the
 	# context of the object currently being transformed.
@@ -228,10 +244,12 @@ class Transformer
 	# * a hash used as input to Environment#find with the result being transformed
 	# 
 	def trans(obj)
+		obj = @env_in.find(obj) if obj.is_a?(Hash)
 		return nil if obj.nil?
+		return obj if obj.is_a?(TrueClass) or obj.is_a?(FalseClass) or obj.is_a?(Numeric) or obj.is_a?(Symbol)
 		return @transformer_results[obj] if @transformer_results[obj]
-		obj = @env_in.find(obj) if obj.is_a?(Hash)
-		return obj.collect{|o| trans(o)}.compact if obj.is_a? Enumerable
+		return @transformer_results[obj] = obj.dup if obj.is_a?(String)
+		return obj.collect{|o| trans(o)}.compact if obj.is_a? Array
 		raise StandardError.new("No transformer for class #{obj.class.name}") unless self.class._transformer_blocks[obj.class]
 		block_desc = _evaluateCondition(obj)
 		return nil unless block_desc