rgen 0.2.0

data/CHANGELOG

@@ -0,0 +1,9 @@
+=0.1.0 (August 3rd, 2006)
+
+* First public release
+
+=0.2.0 (September 3rd, 2006)
+
+* Added model transformation language (Transformer)
+* Now RGen is distributed as a gem
+* More complete documentation

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2006 Martin Thiede
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,73 @@
+== RGen - Ruby Modelling and Generator Framework
+
+RGen is a framework supporting Model Driven Software Development (MDSD).
+This means that it helps you build Metamodels, instantiate Models, modify
+and transform Models and finally generate arbitrary textual content from it.
+
+RGen features include:
+* Programmatic definition of Metamodels
+* Instantiation of Metamodels, i.e. creation of Models (e.g. from XML)
+* Model Transformations
+* Powerful template based generator language
+* A growing set of included Metamodels, Transformations, Generators:
+* UML Class and Object Diagram Metamodel
+* Instantiation of UML Models from XMI
+* Metamodel Generator generating programmatic Metamodel definitions from UML Class Models
+
+
+= Download
+
+Get the latest release from Rubyforge:
+
+	http://rubyforge.org/frs/?group_id=1988
+
+
+= Installation
+
+Unpack the release package somewhere to your filesystem.
+Make sure the 'lib' folder is included in the search path (-I) when you run your own scripts.
+
+As of version 0.2.0 RGen is also available as a gem.
+
+
+= Getting started
+
+Change to the 'test' folder and run the test suite:
+
+	test> ruby rgen_test.rb
+
+
+= Documentation
+
+RGen is being documented using rdoc. 
+Point your browser to 'doc/index.html' to view the documentation.
+
+These are the main parts already documented:
+* RGen::MetamodelBuilder
+* RGen::Transformer
+* RGen::TemplateLanguage
+
+
+= Examples
+
+There are several examples of using RGen within the framework itself.
+
+Metamodel Definition:
+	lib/uml/uml_classmodel.rb
+	lib/uml/uml_objectmodel.rb
+
+Instantiation:
+	lib/ea/xmi_class_instantiator.rb
+	lib/ea/xmi_object_instantiator.rb
+	
+Transformations:
+	lib/ea/xmi_to_classmodel.rb
+	lib/ea/xmi_to_objectmodel.rb
+	
+Generators:
+	lib/mmgen/metamodel_generator.rb
+
+	
+= License
+
+RGen is released under the MIT license.

data/lib/ea/xmi_class_instantiator.rb

@@ -0,0 +1,45 @@
+require 'rgen/xml_instantiator/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)
+# 	}
+#
+# 	# now use the newly created UML model
+# 	envUML.find(:class => UMLClassModel::UMLClass).each { |c|
+# 		puts c.name
+# 	}
+#
+# This module relies on XmiToClassmodel to do the actual transformation.
+# 
+module XMIClassInstantiator
+	
+	include UMLClassModel
+
+	# 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)
+		
+		require 'ea/xmi_to_classmodel'
+		
+		XmiToClassmodel.new(envXMI,envOut).transform
+	end
+
+end

data/lib/ea/xmi_helper.rb

@@ -0,0 +1,26 @@
+require 'rgen/metamodel_builder'
+
+module RGen
+
+module XMIHelper
+
+class MapHelper
+	def initialize(keyMethod,valueMethod,elements)
+		@keyMethod, @valueMethod, @elements = keyMethod, valueMethod, elements
+	end
+	def [](key)
+		return @elements.select{|e| e.send(@keyMethod) == key}.first.send(@valueMethod) rescue NoMethodError
+		nil
+	end
+end
+
+class TaggedValueHelper < MapHelper
+	def initialize(element)	
+		super('tag','value',element.UML_ModelElement_taggedValue.UML_TaggedValue)
+	end
+end
+
+
+end
+
+end

data/lib/ea/xmi_metamodel.rb

@@ -0,0 +1,19 @@
+
+	module XMIMetaModel
+		include RGen::MetamodelBuilder
+		class UML_Classifier_feature < MMBase
+		end
+		class UML_Class < MMBase
+		end
+		class UML_Operation < MMBase
+		end
+		class UML_Generalization < MMBase
+		end
+		class UML_ModelElement_stereotype < 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'
+	end
+	

data/lib/ea/xmi_object_instantiator.rb

@@ -0,0 +1,42 @@
+require 'rgen/xml_instantiator/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:
+# 
+# 	include XMIObjectInstantiator
+# 	
+# 	envUML = RGen::Environment.new
+# 	File.open(MODEL_DIR+"/testmodel.xml") { |f|
+# 		instantiateUMLObjectModel(envUML, f.read)
+# 	}
+#
+# 	# now use the newly created UML model
+# 	envUML.find(:class => UMLObjectModel::UMLObject).each { |o|
+# 		puts o.name
+# 	}
+#
+# This module relies on XmiToObjectmodel to do the actual transformation.
+# 
+module XMIObjectInstantiator
+	
+	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)
+
+		require 'ea/xmi_to_objectmodel'
+		
+		XmiToObjectmodel.new(envXMI,envOut).transform
+	end
+
+end

data/lib/ea/xmi_to_classmodel.rb

@@ -0,0 +1,78 @@
+require 'rgen/transformer'
+require 'ea/xmi_helper'
+require 'ea/xmi_metamodel'
+require 'uml/uml_classmodel'
+require 'rgen/array_extensions'
+
+# This class is a RGen::Transformer working on an input and output Environment.
+# It creates an UMLClassModel from an XMI Model instantiated by a
+# RGen::XMLInstantiator.
+# 
+# See description of RGen::XMLInstantiator for details about the XMI (meta-)model.
+# See UMLClassModel for details about the UML Class (meta-)model.
+class XmiToClassmodel < RGen::Transformer
+	include UMLClassModel
+	include RGen::XMIHelper
+
+	# Do the actual transformation.
+	# Input and output environment have to be provided to the transformer constructor.
+	def transform
+		trans(:class => XMIMetaModel::UML_Class)
+	end
+	
+	transform XMIMetaModel::UML_Package, :to => UMLPackage do
+		{ :name => name, 
+			:superpackage => trans(_p_UML_Namespace_ownedElement._p_UML_Package) }
+	end
+	
+	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
+		{ :name => name }
+	end
+	
+	transform XMIMetaModel::UML_TaggedValue, :to => UMLTaggedValue do
+		{ :tag => tag, :value => value }
+	end
+	
+	transform XMIMetaModel::UML_Class, :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)}
+	end
+	
+	transform XMIMetaModel::UML_Association, :to => :scAssociationClass do
+		{ :endA => trans(scAssocEnds[0]),
+			:endB => trans(scAssocEnds[1]) }
+	end	
+	
+	method :scAssocEnds do
+		getUML_Association_connection.UML_AssociationEnd
+	end
+	
+	method :scAssociationClass do
+		(scAssocEnds[0].aggregation == 'composite' or 
+		 scAssocEnds[1].aggregation == 'composite' ?
+		 UMLAggregation : UMLAssociation )
+	end
+	
+	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),
+			:role => name,
+			:multiplicity => multiplicity,
+			:composite => (aggregation == 'composite'),
+			:navigable => (isNavigable == 'true')	}
+	end
+				
+end

data/lib/ea/xmi_to_objectmodel.rb

@@ -0,0 +1,89 @@
+require 'rgen/transformer'
+require 'ea/xmi_helper'
+require 'ea/xmi_metamodel'
+require 'uml/uml_objectmodel'
+require 'rgen/array_extensions'
+
+# This class is a RGen::Transformer working on an input and output Environment.
+# It creates an UMLObjectModel from an XMI Model instantiated by a
+# RGen::XMLInstantiator.
+# 
+# See description of RGen::XMLInstantiator for details about the XMI (meta-)model.
+# See UMLObjectModel for details about the UML Object (meta-)model.
+class XmiToObjectmodel < RGen::Transformer
+	include UMLObjectModel
+	include RGen::XMIHelper
+	
+	# Do the actual transformation.
+	# Input and output environment have to be provided to the transformer constructor.
+	def transform
+		trans(:class => XMIMetaModel::UML_ClassifierRole)
+	end
+
+	transform XMIMetaModel::UML_Package, :to => UMLPackage do
+		{ :name => name,
+			:superpackage => trans(_p_UML_Namespace_ownedElement._p_UML_Package) }
+	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)
+	 	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) }
+	end
+	
+	method :isEASTypeObject do
+	 	taggedValues = TaggedValueHelper.new(@current_object)
+	 	taggedValues['ea_stype'] == 'Object'
+	end
+	
+	def createAttributeSettings(runstate)
+		return [] unless runstate
+		result = []
+		as = nil
+		runstate.split(';').each do |t|
+			if t == '@VAR'
+				as = @env_out.new UMLAttributeSetting
+				result << as
+			elsif t =~ /(\w+)=(\w+)/
+				as.name = $2 if $1 == 'Variable'
+				as.value = $2 if $1 == 'Value'
+			end
+		end
+		result
+	end
+	
+	transform XMIMetaModel::UML_AssociationRole, :to => UMLAssociation, :if => :isEATypeAssociation do
+		ends = getUML_Association_connection.UML_AssociationEndRole
+		{ :endA => trans(ends[0]), :endB => trans(ends[1])}
+	end
+	
+	method :isEATypeAssociation do
+	 	taggedValues = TaggedValueHelper.new(@current_object)
+		taggedValues['ea_type'] == 'Association'
+	end
+
+	transform XMIMetaModel::UML_Association, :to => UMLAggregation do
+		ends = getUML_Association_connection.UML_AssociationEnd
+		{ :endA => trans(ends[0]), :endB => trans(ends[1])}
+	end
+		
+	transform XMIMetaModel::UML_AssociationEndRole, :to => UMLAssociationEnd do
+		buildAssociationEnd
+	end
+	
+	transform XMIMetaModel::UML_AssociationEnd, :to => UMLAssociationEnd do
+		buildAssociationEnd
+	end
+	
+	method :buildAssociationEnd do
+		{ :object => trans(type_UML_ClassifierRole),
+		  :role => name,
+		  :composite => (aggregation == 'composite'),
+		  :navigable => (isNavigable == 'true') }
+	end
+	
+end

data/lib/mmgen/metamodel_generator.rb

@@ -0,0 +1,19 @@
+require 'rgen/environment'
+require 'rgen/template_language'
+require 'uml/uml_classmodel'
+require 'mmgen/mm_ext/uml_classmodel_ext'
+
+module MMGen
+
+module MetamodelGenerator
+
+	def generateMetamodel(rootPackage, out_file, modules=[])
+		tc = RGen::TemplateLanguage::DirectoryTemplateContainer.new(UMLClassModel, File.dirname(out_file))
+		tpl_path = File.dirname(__FILE__) + '/templates'
+		tc.load(tpl_path)
+		tc.expand('uml_classmodel::GenerateClassModel', File.basename(out_file), modules, :for => rootPackage)
+	end
+
+end
+
+end

data/lib/mmgen/mm_ext/uml_classmodel_ext.rb

@@ -0,0 +1,71 @@
+require 'rgen/name_helper'
+
+module UMLClassModel
+	class UMLPackage
+		include RGen::NameHelper
+		
+		def moduleName
+			firstToUpper(name)
+		end
+		
+		def qualifiedModuleName(rootPackage)
+			return moduleName unless superpackage and self != rootPackage
+			superpackage.qualifiedModuleName(rootPackage) + "::" + moduleName
+		end
+		
+		def sortedClasses
+			sortArray = classes.dup
+			i1 = 0
+			while i1 < sortArray.size-1
+				again = false
+				for i2 in i1+1..sortArray.size-1
+					e2 = sortArray[i2]
+					if sortArray[i1].superclasses.include?(e2)
+						sortArray.delete(e2)
+						sortArray.insert(i1,e2)
+						again = true
+						break
+					end
+				end
+				i1 += 1 unless again
+			end
+			sortArray
+		end
+	end
+	
+	class UMLClass
+		include RGen::NameHelper
+		def className
+			firstToUpper(name)			
+		end
+		def qualifiedName(rootPackage)
+			(package ? package.qualifiedModuleName(rootPackage) + "::" : "") + className
+		end
+		def RubySuperclass(modules)
+			superclasses = self.superclasses.reject {|c| modules.include?(c.name)}
+			raise StandardError.new("#{self.name}: Duplicate superclasses: #{superclasses}") unless superclasses.size < 2
+			superclasses[0]
+		end
+	end
+	
+	class UMLAttribute
+		def RubyType
+			typeMap = {'float' => 'Float', 'int' => 'Integer'}
+			typeMap[self.getType.downcase] || 'String'
+		end
+	end
+	
+	class UMLAssociationEnd
+		def MName
+			return self.clazz.name.downcase unless role
+			self.role
+		end
+		def one?
+			self.upperMult == 1 or self.upperMult.nil?
+		end
+		def many?
+			self.upperMult == :many
+		end
+	end
+	
+end