rgen 0.3.0 → 0.4.0

data/lib/metamodels/uml13_metamodel_ext.rb

@@ -0,0 +1,26 @@
+# Some handy extensions to the UML13 metamodel
+# 
+module UML13
+  
+  module AssociationEnd::ClassModule
+    def otherEnd
+      association.connection.find{|c| c != self}
+    end
+  end
+  
+  module Classifier::ClassModule
+    def localCompositeEnd
+      associationEnd.select{|e| e.aggregation == :composite}
+    end
+    def remoteCompositeEnd
+      associationEnd.otherEnd.select{|e| e.aggregation == :composite}
+    end
+    def localNavigableEnd
+      associationEnd.select{|e| e.isNavigable}
+    end
+    def remoteNavigableEnd
+      associationEnd.otherEnd.select{|e| e.isNavigable}
+    end
+  end
+
+end

data/lib/mmgen/metamodel_generator.rb

@@ -1,17 +1,17 @@
 require 'rgen/environment'
 require 'rgen/template_language'
-require 'uml/uml_classmodel'
-require 'mmgen/mm_ext/uml_classmodel_ext'
+require 'rgen/ecore/ecore'
+require 'mmgen/mm_ext/ecore_ext'
 
 module MMGen
 
 module MetamodelGenerator
 
-	def generateMetamodel(rootPackage, out_file, modules=[])
-		tc = RGen::TemplateLanguage::DirectoryTemplateContainer.new(UMLClassModel, File.dirname(out_file))
+	def generateMetamodel(rootPackage, out_file)
+		tc = RGen::TemplateLanguage::DirectoryTemplateContainer.new(RGen::ECore, 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)
+		tc.expand('metamodel_generator::GenerateMetamodel', File.basename(out_file), :for => rootPackage)
 	end
 
 end

data/lib/mmgen/mm_ext/ecore_ext.rb

@@ -0,0 +1,95 @@
+require 'rgen/name_helper'
+
+module RGen
+  
+  module ECore
+    
+    module EPackage::ClassModule
+      include RGen::NameHelper
+      
+      def moduleName
+        firstToUpper(name)
+      end
+      
+      def qualifiedModuleName(rootPackage)
+        return moduleName unless eSuperPackage and self != rootPackage
+        eSuperPackage.qualifiedModuleName(rootPackage) + "::" + moduleName
+      end
+      
+      def allClassifiers
+        eSubpackages.inject(eClassifiers) {|r,p| r.concat(p.allClassifiers) }	 
+      end
+      
+      def ancestorPackages
+        return [] unless eSuperPackage
+        [eSuperPackage] + eSuperPackage.ancestorPackages
+      end
+      
+      def ownClasses
+        eClassifiers.select{|c| c.is_a?(EClass)}
+      end
+      
+      def classesInGenerationOrdering
+        ownClasses + eSubpackages.collect{|s| s.classesInGenerationOrdering}.flatten
+      end
+      
+      def needClassReorder?
+        classesInGenerationOrdering != inheritanceOrderClasses(classesInGenerationOrdering)
+      end
+      
+      def allClassesSorted
+        inheritanceOrderClasses(classesInGenerationOrdering)
+      end
+      
+      def inheritanceOrderClasses(cls)
+        sortArray = cls.dup
+        i1 = 0
+        while i1 < sortArray.size-1
+          again = false
+          for i2 in i1+1..sortArray.size-1
+            e2 = sortArray[i2]
+            if sortArray[i1].eSuperTypes.include?(e2)
+              sortArray.delete(e2)
+              sortArray.insert(i1,e2)
+              again = true
+              break
+            end
+          end
+          i1 += 1 unless again
+        end
+        sortArray
+      end
+    end
+    
+    module EClassifier::ClassModule
+      include RGen::NameHelper
+      def classifierName
+        firstToUpper(name)			
+      end
+      def qualifiedName(rootPackage)
+       (ePackage ? ePackage.qualifiedModuleName(rootPackage) + "::" : "") + classifierName
+      end
+      def ancestorPackages
+        return [] unless ePackage
+        [ePackage] + ePackage.ancestorPackages
+      end
+      def qualifiedNameIfRequired(package)
+        if ePackage != package
+          commonSuper = (package.ancestorPackages & ancestorPackages).first
+          qualifiedName(commonSuper)
+        else
+          classifierName
+        end
+      end
+    end
+    
+    module EAttribute::ClassModule
+      def RubyType
+        typeMap = {'float' => 'Float', 'int' => 'Integer'}
+         (self.getType && typeMap[self.getType.downcase]) || 'String'
+      end
+    end
+    
+  end
+  
+end

data/lib/mmgen/mmgen.rb

@@ -1,6 +1,6 @@
 $:.unshift File.join(File.dirname(__FILE__),"..")
 
-require 'ea/xmi_class_instantiator'
+require 'ea/xmi_ecore_instantiator'
 require 'mmgen/metamodel_generator'
 
 include MMGen::MetamodelGenerator
@@ -16,11 +16,13 @@ else
 	puts out_file
 end
 
-envUML = RGen::Environment.new
+env = RGen::Environment.new
 File.open(file_name) { |f|
-	XMIClassInstantiator.new.instantiateUMLClassModel(envUML, f.read)
+    puts "instantiating ..."
+	XMIECoreInstantiator.new.instantiateECoreModel(env, f.read)
 }
 
-rootPackage = envUML.find(:class => UMLClassModel::UMLPackage).select{|p| p.name == root_package_name}.first
+rootPackage = env.find(:class => RGen::ECore::EPackage, :name => root_package_name).first
 
+puts "generating ..."
 generateMetamodel(rootPackage, out_file, modules)

data/lib/mmgen/templates/annotations.tpl

@@ -0,0 +1,37 @@
+<% define 'Annotations', :for => EPackage do %>
+	<% for a in eAnnotations %>
+		annotation <% expand 'AnnotationArgs', :for => a %>
+	<% end %>
+<% end %>
+
+<% define 'Annotations', :for => EClass do %>
+	<% for a in eAnnotations %>
+		annotation <% expand 'AnnotationArgs', :for => a %>
+	<% end %>
+<% end %>
+
+<% define 'Annotations', :for => EStructuralFeature do %>
+	<% oppositeAnnotations = (this.respond_to?(:eOpposite) && eOpposite && eOpposite.eAnnotations) || [] %>
+	<% if eAnnotations.size > 0 || oppositeAnnotations.size > 0 %>
+		do<%iinc%>
+			<% for a in eAnnotations %>
+				annotation <% expand 'AnnotationArgs', :for => a %>
+			<% end %>
+			<% for a in oppositeAnnotations %>
+				opposite_annotation <% expand 'AnnotationArgs', :for => a %>
+			<% end %><%idec%>
+		end<%nows%>
+	<% end %>
+<% end %>
+
+<% define 'AnnotationArgs', :for => EAnnotation do %>
+	<% if source.nil? %>
+		<% expand 'Details' %>
+	<% else %>
+		:source => "<%= source.to_s %>", :details => {<% expand 'Details' %>}<%nows%>
+	<% end %>
+<% end %>
+
+<% define 'Details', :for => EAnnotation do %>
+	<%= details.sort{|a,b| a.key<=>b.key}.collect{ |d| "\'" + d.key + "\' => \'"+ d.value.gsub('\'','\\\'').to_s + "\'"}.join(', ') %><%nows%>
+<% end %>

data/lib/mmgen/templates/metamodel_generator.tpl

@@ -0,0 +1,171 @@
+
+<% define 'GenerateMetamodel', :for => EPackage do |filename| %>
+	<% file filename do %>
+		require 'rgen/metamodel_builder'
+		<%nl%>
+		<% if needClassReorder? %>
+			<% expand 'GeneratePackagesOnly' %>
+			<% expand 'GenerateClassesReordered' %>
+		<% else %>
+			<% expand 'GeneratePackage' %>
+		<% end %>
+		<%nl%>
+		<% expand 'GenerateAssocs' %>
+	<% end %>
+<% end %>
+		
+<% define 'GeneratePackage', :for => EPackage do %>
+	module <%= moduleName %><% iinc %>
+		extend RGen::MetamodelBuilder::ModuleExtension
+		include RGen::MetamodelBuilder::DataTypes
+		<% expand 'annotations::Annotations' %>
+		<%nl%>
+		<% expand 'EnumTypes' %>
+		<% for c in ownClasses %><%nl%>
+			<% expand 'ClassHeader', this, :for => c %><%iinc%>
+				<% expand 'annotations::Annotations', :for => c %>
+				<% expand 'Attribute', this, :foreach => c.eAttributes %>
+				<%idec%>
+			end
+		<% end %><%nl%>
+		<% for p in eSubpackages %>
+			<%nl%><% expand 'GeneratePackage', :for => p %>
+		<% end %><%idec%>
+	end
+<% end %>
+
+<% define 'GenerateClassesReordered', :for => EPackage do %>
+	<% for c in allClassesSorted %><%nl%>
+		<% expand 'ClassHeaderFullyQualified', this, :for => c %><%iinc%>
+			<% expand 'annotations::Annotations', :for => c %>
+			<% expand 'Attribute', this, :foreach => c.eAttributes %>
+			<%idec%>
+		end
+	<% end %><%nl%>
+<% end %>
+
+<% define 'GeneratePackagesOnly', :for => EPackage do %>
+	module <%= moduleName %><% iinc %>
+		extend RGen::MetamodelBuilder::ModuleExtension
+		include RGen::MetamodelBuilder::DataTypes
+		<% expand 'annotations::Annotations' %>
+		<%nl%>
+		<% expand 'EnumTypes' %>
+		<% for p in eSubpackages %>
+			<%nl%><% expand 'GeneratePackagesOnly', :for => p %>
+		<% end %><%idec%>
+	end
+<% end %>
+
+<% define 'Attribute', :for => EAttribute do |rootp| %>
+	<% if upperBound == 1%>
+	has_attr '<%= name %>', <%nows%>
+	<% if eType.is_a?(EEnum) %><%nows%>
+		<%= eType.qualifiedName(rootp) %><%nows%>
+	<% else %><%nows%>
+		<%= eType && eType.instanceClass.to_s %><%nows%>
+	<% end %><%nows%>
+	<% for p in RGen::MetamodelBuilder::AttributeDescription.propertySet %>
+		<% unless p == :name || p == :upperBound || RGen::MetamodelBuilder::AttributeDescription.default_value(p) == getGeneric(p) %>
+	    	, :<%=p%> => <%nows%>
+	    	<% if getGeneric(p).is_a?(String) %>
+	    		"<%= getGeneric(p) %>"<%nows%>
+	    	<% elsif getGeneric(p).is_a?(Symbol) %>
+	    		:<%= getGeneric(p) %><%nows%>
+	    	<% else %>
+	    		<%= getGeneric(p) %><%nows%>
+	    	<% end %>
+		<% end %>
+	<% end %>
+	<%ws%><% expand 'annotations::Annotations' %><%nl%>
+	<% end %>
+<% end %>
+
+<% define 'EnumTypes', :for => EPackage do %>
+	<% for enum in eClassifiers.select{|c| c.is_a?(EEnum)} %>
+		<%= enum.name %> = Enum.new([ <%nows%>
+		<%= enum.eLiterals.collect { |lit| ":"+lit.name }.join(', ') %> ])
+	<% end %>
+<% end %>
+
+<% define 'GenerateAssocs', :for => EPackage do %>
+	<% refDone = {} %>
+	<% for ref in allClassifiers.select{|c| c.is_a?(EClass)}.eReferences %>
+		<% if !refDone[ref] && ref.eOpposite %>
+			<% ref = ref.eOpposite if ref.eOpposite.containment %>
+			<% refDone[ref] = refDone[ref.eOpposite] = true %>
+			<% if !ref.many && !ref.eOpposite.many %>
+				<% if ref.containment %>
+					<% expand 'Reference', "contains_one", this, :for => ref %>
+				<% else %>
+					<% expand 'Reference', "one_to_one", this, :for => ref %>
+				<% end %>
+			<% elsif !ref.many && ref.eOpposite.many %>
+				<% expand 'Reference', "many_to_one", this, :for => ref %>
+			<% elsif ref.many && !ref.eOpposite.many %>
+				<% if ref.containment %>
+					<% expand 'Reference', "contains_many", this, :for => ref %>
+				<% else %>
+					<% expand 'Reference', "one_to_many", this, :for => ref %>
+				<% end %>
+			<% elsif ref.many && ref.eOpposite.many %>
+				<% expand 'Reference', "many_to_many", this, :for => ref %>
+			<% end %>
+			<% expand 'annotations::Annotations', :for => ref %><%nl%>
+		<% elsif !refDone[ref] %>
+			<% refDone[ref] = true %>
+			<% if !ref.many %>
+				<% if ref.containment %>
+					<% expand 'Reference', "contains_one_uni", this, :for => ref %>
+				<% else %>
+					<% expand 'Reference', "has_one", this, :for => ref %>
+				<% end %>
+			<% elsif ref.many %>
+				<% if ref.containment %>
+					<% expand 'Reference', "contains_many_uni", this, :for => ref %>
+				<% else %>
+					<% expand 'Reference', "has_many", this, :for => ref %>
+				<% end %>
+			<% end %>
+			<% expand 'annotations::Annotations', :for => ref %><%nl%>
+		<% end %>
+	<% end %>
+<% end %>
+
+<% define 'Reference', :for => EReference do |cmd, rootpackage| %>
+	<%= eContainingClass.qualifiedName(rootpackage) %>.<%= cmd %> '<%= name %>', <%= eType && eType.qualifiedName(rootpackage) %><%nows%>
+	<% if eOpposite %><%nows%>
+		, '<%= eOpposite.name%>'<%nows%>
+	<% end %><%nows%>
+	<% pset = RGen::MetamodelBuilder::ReferenceDescription.propertySet.reject{|p| p == :name || p == :upperBound || p == :containment} %>
+	<% for p in pset.reject{|p| RGen::MetamodelBuilder::ReferenceDescription.default_value(p) == getGeneric(p)} %>
+    	, :<%=p%> => <%=getGeneric(p)%><%nows%>
+	<% end %>
+	<% if eOpposite %>
+		<% for p in pset.reject{|p| RGen::MetamodelBuilder::ReferenceDescription.default_value(p) == eOpposite.getGeneric(p)} %>
+	    	, :opposite_<%=p%> => <%=eOpposite.getGeneric(p)%><%nows%>
+		<% end %>
+	<% end %><%ws%>
+<% end %>
+
+<% define 'ClassHeader', :for => EClass do |rootp| %>
+	class <%= classifierName %> < <% nows %>
+	<% if eSuperTypes.size > 1 %><% nows %>
+		RGen::MetamodelBuilder::MMMultiple(<%= eSuperTypes.collect{|t| t.qualifiedNameIfRequired(rootp)}.join(', ') %>)
+	<% elsif eSuperTypes.size > 0 %><% nows %>
+		<%= eSuperTypes.first.qualifiedNameIfRequired(rootp) %>
+	<% else %><% nows %>
+		RGen::MetamodelBuilder::MMBase
+	<% end %>
+<% end %>
+
+<% define 'ClassHeaderFullyQualified', :for => EClass do |rootp| %>
+	class <%= qualifiedName(rootp) %> < <% nows %>
+	<% if eSuperTypes.size > 1 %><% nows %>
+		RGen::MetamodelBuilder::MMMultiple(<%= eSuperTypes.collect{|t| t.qualifiedName(rootp)}.join(', ') %>)
+	<% elsif eSuperTypes.size > 0 %><% nows %>
+		<%= eSuperTypes.first.qualifiedName(rootp) %>
+	<% else %><% nows %>
+		RGen::MetamodelBuilder::MMBase
+	<% end %>
+<% end %>

data/lib/rgen/ecore/ecore.rb

@@ -0,0 +1,190 @@
+require 'rgen/metamodel_builder'
+
+module RGen
+  extend RGen::MetamodelBuilder::ModuleExtension
+  
+  # This is the ECore metamodel described using the RGen::MetamodelBuilder language.
+  #
+  # Known differences to the Java/EMF implementation are:
+  # * Attributes can not be "many"
+  # 
+  module ECore
+    extend RGen::MetamodelBuilder::ModuleExtension
+    
+    class EObject < RGen::MetamodelBuilder::MMBase
+    end
+    
+    class EModelElement < RGen::MetamodelBuilder::MMBase
+    end
+    
+    class EAnnotation < RGen::MetamodelBuilder::MMMultiple(EModelElement, EObject)
+      has_attr 'source', String
+    end
+    
+    class ENamedElement < EModelElement
+      has_attr 'name', String
+    end
+    
+    class ETypedElement < ENamedElement
+      has_attr 'lowerBound', Integer, :defaultValueLiteral => "0"
+      has_attr 'ordered', Boolean, :defaultValueLiteral => "true"
+      has_attr 'unique', Boolean, :defaultValueLiteral => "true"
+      has_attr 'upperBound', Integer, :defaultValueLiteral => "1"
+      has_attr 'many', Boolean, :derived=>true
+      has_attr 'required', Boolean, :derived=>true
+      module ClassModule
+        def many_derived
+          upperBound > 1 || upperBound == -1
+        end
+        def required_derived
+          lowerBound > 0
+        end
+      end
+    end
+    
+    class EStructuralFeature < ETypedElement
+      has_attr 'changeable', Boolean, :defaultValueLiteral => "true"
+      has_attr 'defaultValue', Object, :derived=>true
+      has_attr 'defaultValueLiteral', String
+      has_attr 'derived', Boolean, :defaultValueLiteral => "false"
+      has_attr 'transient', Boolean, :defaultValueLiteral => "false"
+      has_attr 'unsettable', Boolean, :defaultValueLiteral => "false"
+      has_attr 'volatile', Boolean, :defaultValueLiteral => "false"
+      module ClassModule
+        def defaultValue_derived
+          eval(defaultValueLiteral) unless defaultValueLiteral.nil?
+        end
+      end
+    end
+    
+    class EAttribute < EStructuralFeature
+      has_attr 'iD', Boolean, :defaultValueLiteral => "false"
+    end
+    
+    class EClassifier < ENamedElement
+      has_attr 'defaultValue', Object, :derived=>true
+      has_attr 'instanceClass', Object, :derived=>true
+      has_attr 'instanceClassName', String
+      module ClassModule
+        def instanceClass_derived
+          map = {"java.lang.String" => "String", "boolean" => "RGen::MetamodelBuilder::DataTypes::Boolean", "int" => "Integer"}
+          icn = instanceClassName
+          icn = "NilClass" if icn.nil?
+          icn = map[icn] if map[icn]
+          eval(icn)
+        end
+      end
+    end
+    
+    class EDataType < EClassifier
+      has_attr 'serializable', Boolean
+    end
+    
+    class EEnum < EDataType
+    end
+    
+    class EEnumLiteral < ENamedElement
+      # instance may point to a "singleton object" (e.g. a Symbol) representing the literal
+      #      has_attr 'instance', Object, :eType=>:EEnumerator, :transient=>true
+      has_attr 'literal', String
+      has_attr 'value', Integer
+    end
+    
+    # TODO: check if required
+    class EFactory < EModelElement
+    end
+    
+    class EOperation < ETypedElement
+    end
+    
+    class EPackage < ENamedElement
+      has_attr 'nsPrefix', String
+      has_attr 'nsURI', String
+    end
+    
+    class EParameter < ETypedElement
+    end
+    
+    class EReference < EStructuralFeature
+      has_attr 'container', Boolean, :derived=>true
+      has_attr 'containment', Boolean, :defaultValueLiteral => "false"
+      has_attr 'resolveProxies', Boolean, :defaultValueLiteral => "true"
+    end
+    
+    class EStringToStringMapEntry < RGen::MetamodelBuilder::MMBase
+      has_attr 'key', String
+      has_attr 'value', String
+    end
+    
+    class EClass < EClassifier
+      has_attr 'abstract', Boolean
+      has_attr 'interface', Boolean
+      has_one  'eIDAttribute', ECore::EAttribute, :derived=>true, :resolveProxies=>false
+      
+      has_many 'eAllAttributes', ECore::EAttribute, :derived=>true
+      has_many 'eAllContainments', ECore::EReference, :derived=>true
+      has_many 'eAllOperations', ECore::EOperation, :derived=>true
+      has_many 'eAllReferences', ECore::EReference, :derived=>true
+      has_many 'eAllStructuralFeatures', ECore::EStructuralFeature, :derived=>true
+      has_many 'eAllSuperTypes', ECore::EClass, :derived=>true
+      has_many 'eAttributes', ECore::EAttribute, :derived=>true
+      has_many 'eReferences', ECore::EReference, :derived=>true
+      
+      module ClassModule		
+        def eAllAttributes_derived
+          eAttributes + eSuperTypes.eAllAttributes
+        end
+        def eAllContainments_derived
+          eReferences.select{|r| r.containment} + eSuperTypes.eAllContainments
+        end
+        def eAllReferences_derived
+          eReferences + eSuperTypes.eAllReferences
+        end
+        def eAllStructuralFeatures_derived
+          eStructuralFeatures + eSuperTypes.eAllStructuralFeatures
+        end
+        def eAllSuperTypes_derived
+          eSuperTypes + eSuperTypes.eAllSuperTypes
+        end
+        def eAttributes_derived
+          eStructuralFeatures.select{|f| f.is_a?(EAttribute)}
+        end
+        def eReferences_derived
+          eStructuralFeatures.select{|f| f.is_a?(EReference)}
+        end
+      end
+    end
+    
+    # predefined datatypes
+    
+    EString = EDataType.new(:name => "EString", :instanceClassName => "String")
+    EInt = EDataType.new(:name => "EInt", :instanceClassName => "Integer")
+    EBoolean = EDataType.new(:name => "EBoolean", :instanceClassName => "RGen::MetamodelBuilder::DataTypes::Boolean")
+    EFloat = EDataType.new(:name => "EFloat", :instanceClassName => "Float")
+    ERubyObject = EDataType.new(:name => "ERubyObject", :instanceClassName => "Object")
+    EJavaObject = EDataType.new(:name => "EJavaObject")
+    ERubyClass = EDataType.new(:name => "ERubyClass", :instanceClassName => "Class")
+    EJavaClass = EDataType.new(:name => "EJavaClass")
+    
+  end
+  
+  ECore::EModelElement.contains_many 'eAnnotations', ECore::EAnnotation, 'eModelElement', :resolveProxies=>false
+  ECore::EAnnotation.contains_many_uni 'details', ECore::EStringToStringMapEntry, :resolveProxies=>false
+  ECore::EAnnotation.contains_many_uni 'contents', ECore::EObject, :resolveProxies=>false
+  ECore::EAnnotation.has_many 'references', ECore::EObject
+  ECore::EPackage.contains_many 'eClassifiers', ECore::EClassifier, 'ePackage'
+  ECore::EPackage.contains_many 'eSubpackages', ECore::EPackage, 'eSuperPackage'
+  ECore::ETypedElement.has_one 'eType', ECore::EClassifier
+  ECore::EClass.contains_many 'eOperations', ECore::EOperation, 'eContainingClass', :resolveProxies=>false
+  ECore::EClass.contains_many 'eStructuralFeatures', ECore::EStructuralFeature, 'eContainingClass', :resolveProxies=>false
+  ECore::EClass.has_many 'eSuperTypes', ECore::EClass
+  ECore::EEnum.contains_many 'eLiterals', ECore::EEnumLiteral, 'eEnum', :resolveProxies=>false
+  ECore::EFactory.one_to_one 'ePackage', ECore::EPackage, 'eFactoryInstance', :lowerBound=>1, :transient=>true, :resolveProxies=>false
+  ECore::EOperation.contains_many 'eParameters', ECore::EParameter, 'eOperation', :resolveProxies=>false
+  ECore::EOperation.has_many 'eExceptions', ECore::EClassifier
+  ECore::EReference.has_one 'eOpposite', ECore::EReference
+  
+  ECore::EAttribute.has_one 'eAttributeType', ECore::EDataType, :lowerBound=>1, :derived=>true
+  ECore::EReference.has_one 'eReferenceType', ECore::EClass, :lowerBound=>1, :derived=>true
+  
+end