rgen 0.4.6 → 0.5.0

data/lib/ea_support/uml13_ea_metamodel_ext.rb

@@ -0,0 +1,45 @@
+module UML13EA
+  class << self
+    attr_accessor :idStore
+  end
+  module ModelElement::ClassModule
+    def qualifiedName
+      _name = (respond_to?(:_name) ? self._name : name) || "unnamed"
+      _namespace = respond_to?(:_namespace) ? self._namespace : namespace
+      _namespace && _namespace.qualifiedName ? _namespace.qualifiedName+"::"+_name : _name
+    end
+  end
+  module XmiIdProvider::ClassModule
+    def _xmi_id
+      UML13EA.idStore.idHash[qualifiedName] ||= "EAID_"+object_id.to_s
+    end
+  end
+  module Package::ClassModule
+    def _xmi_id
+      UML13EA.idStore.idHash[qualifiedName] ||= "EAPK_"+object_id.to_s
+    end
+  end
+  module Generalization::ClassModule
+    def _name
+      "#{subtype.name}_#{supertype.name}"
+    end
+  end
+  module Association::ClassModule
+    def _name
+      connection.collect{|c| "#{c.getType.name}_#{c.name}"}.sort.join("_")
+    end
+  end
+  module AssociationEnd::ClassModule
+    def _name
+      "#{getType.name}_#{name}"
+    end
+    def _namespace
+      association
+    end
+  end
+  module StateVertex::ClassModule
+    def _namespace
+      container
+    end
+  end
+end

data/lib/ea_support/uml13_ea_metamodel_generator.rb

@@ -0,0 +1,43 @@
+require 'metamodels/uml13_metamodel'
+require 'mmgen/metamodel_generator'
+require 'rgen/transformer'
+require 'rgen/environment'
+require 'rgen/ecore/ecore'
+
+include MMGen::MetamodelGenerator
+
+class ECoreCopyTransformer < RGen::Transformer
+  copy_all RGen::ECore
+end
+
+eaMMRoot = ECoreCopyTransformer.new.trans(UML13.ecore)
+
+eaMMRoot.name = "UML13EA"
+eaMMRoot.eClassifiers.find{|c| c.name == "ActivityGraph"}.name = "ActivityModel"
+eaMMRoot.eClassifiers.find{|c| c.name == "Pseudostate"}.name = "PseudoState"
+
+compositeState = eaMMRoot.eClassifiers.find{|c| c.name == "CompositeState"}
+compositeState.eReferences.find{|r| r.name == "subvertex"}.name = "substate"
+
+generalization = eaMMRoot.eClassifiers.find{|c| c.name == "Generalization"}
+generalization.eReferences.find{|r| r.name == "parent"}.name = "supertype"
+generalization.eReferences.find{|r| r.name == "child"}.name = "subtype"
+
+assocEnd = eaMMRoot.eClassifiers.find{|c| c.name == "AssociationEnd"}
+assocEnd.eAttributes.find{|r| r.name == "ordering"}.name = "isOrdered"
+assocEnd.eAttributes.find{|r| r.name == "changeability"}.name = "changeable"
+assocEnd.eAttributes.find{|r| r.name == "isOrdered"}.eType = RGen::ECore::EBoolean
+assocEnd.eAttributes.find{|r| r.name == "changeable"}.eType.eLiterals.find{|l| l.name == "frozen"}.name = "none"
+multRef = assocEnd.eStructuralFeatures.find{|f| f.name == "multiplicity"}
+multRef.eType = nil
+assocEnd.removeEStructuralFeatures(multRef)
+assocEnd.addEStructuralFeatures(RGen::ECore::EAttribute.new(:name => "multiplicity", :eType => RGen::ECore::EString))
+
+xmiIdProvider = RGen::ECore::EClass.new(:name => "XmiIdProvider", :ePackage => eaMMRoot)
+eaMMRoot.eClassifiers.each do |c|
+  if %w(Package Class Generalization Association AssociationEnd StateVertex).include?(c.name)
+    c.addESuperTypes(xmiIdProvider)
+  end
+end
+
+generateMetamodel(eaMMRoot, File.dirname(__FILE__)+"/uml13_ea_metamodel.rb")

data/lib/ea_support/uml13_ea_to_uml13.rb

@@ -0,0 +1,72 @@
+require 'rgen/transformer'
+require 'metamodels/uml13_metamodel'
+require 'ea_support/uml13_ea_metamodel'
+
+class UML13EAToUML13 < RGen::Transformer
+  include UML13EA
+  
+  def transform
+    trans(:class => Package)
+    trans(:class => Class)
+  end
+  
+  def cleanModel
+    @env_out.find(:class => UML13::ModelElement).each do |me|
+      me.taggedValue = []
+    end
+  end
+  
+  copy_all UML13EA, :to => UML13, :except => %w(
+    XmiIdProvider
+    AssociationEnd AssociationEndRole
+    StructuralFeature
+    Generalization
+    ActivityModel 
+    CompositeState 
+    PseudoState
+  )  
+    
+  transform AssociationEndRole, :to => UML13::AssociationEndRole do
+    copyAssociationEnd
+  end
+
+  transform AssociationEnd, :to => UML13::AssociationEnd do
+    copyAssociationEnd
+  end
+  
+  def copyAssociationEnd
+    copy_features :except => [:isOrdered, :changeable] do
+      {:ordering => isOrdered ? :ordered : :unordered,
+       :changeability => {:none => :frozen}[changeable] || changeable,
+       :aggregation => {:shared => :aggregate}[aggregation] || aggregation,
+       :multiplicity => UML13::Multiplicity.new(
+        :range => [UML13::MultiplicityRange.new(
+          :lower => multiplicity && multiplicity.split("..").first,
+          :upper => multiplicity && multiplicity.split("..").last)])}
+    end
+  end
+
+  transform StructuralFeature, :to => UML13::StructuralFeature do
+    copy_features :except => [:changeable] do
+      {:changeability => {:none => :frozen}[changeable] }
+    end
+  end
+
+  transform Generalization, :to => UML13::Generalization do
+    copy_features :except => [:subtype, :supertype] do 
+      { :child => trans(subtype),
+        :parent => trans(supertype) }
+    end
+  end
+  
+  copy ActivityModel, :to => UML13::ActivityGraph
+
+  transform CompositeState, :to => UML13::CompositeState do
+    copy_features :except => [:substate] do
+      { :subvertex => trans(substate) }
+    end
+  end
+  
+  copy PseudoState, :to => UML13::Pseudostate
+  
+end

data/lib/ea_support/uml13_to_uml13_ea.rb

@@ -0,0 +1,82 @@
+require 'rgen/transformer'
+require 'metamodels/uml13_metamodel'
+require 'ea_support/uml13_ea_metamodel'
+require 'ea_support/uml13_ea_metamodel_ext'
+
+class UML13ToUML13EA < RGen::Transformer
+  include UML13
+  
+  def transform
+    trans(:class => Package)
+    trans(:class => Class)
+  end
+  
+  copy_all UML13, :to => UML13EA, :except => %w(
+    ActivityGraph 
+    CompositeState SimpleState
+    Class 
+    Association AssociationEnd AssociationEndRole
+    Generalization
+    Pseudostate    
+  )  
+  
+  copy ActivityGraph, :to => UML13EA::ActivityModel
+  
+  copy Pseudostate, :to => UML13EA::PseudoState
+  
+  transform CompositeState, :to => UML13EA::CompositeState do
+    copy_features :except => [:subvertex] do
+      { :substate => trans(subvertex) }
+    end
+  end
+  
+  transform SimpleState, :to => UML13EA::SimpleState do
+    copy_features :except => [:container] do
+      { :taggedValue => trans(taggedValue) + 
+        [@env_out.new(UML13EA::TaggedValue, :tag => "ea_stype", :value => "State")] +
+        (container ? [ @env_out.new(UML13EA::TaggedValue, :tag => "owner", :value => trans(container)._xmi_id)] : []) }
+    end
+  end
+  
+  transform Class, :to => UML13EA::Class do
+    copy_features do
+      { :taggedValue => trans(taggedValue) + [@env_out.new(UML13EA::TaggedValue, :tag => "ea_stype", :value => "Class")]}
+    end
+  end
+  
+  transform Association, :to => UML13EA::Association do
+    copy_features do
+      { :connection => trans(connection[1].isNavigable ? [connection[0], connection[1]] : [connection[1], connection[0]]),
+        :taggedValue => trans(taggedValue) + [
+          @env_out.new(UML13EA::TaggedValue, :tag => "ea_type", :value => "Association"),
+          @env_out.new(UML13EA::TaggedValue, :tag => "direction", :value => 
+            connection.all?{|c| c.isNavigable} ? "Bi-Directional" : "Source -&gt; Destination")] }
+    end
+  end
+  
+  transform AssociationEnd, :to => UML13EA::AssociationEnd do 
+    copyAssociationEnd
+  end
+  
+  transform AssociationEndRole, :to => UML13EA::AssociationEndRole do 
+    copyAssociationEnd
+  end
+  
+  def copyAssociationEnd
+    _lower = multiplicity && multiplicity.range.first.lower
+    _upper = multiplicity && multiplicity.range.first.upper
+    copy_features :except => [:multiplicity, :ordering, :changeability] do
+      { :multiplicity => _lower == _upper ? _lower : "#{_lower}..#{_upper}",
+        :isOrdered => ordering == :ordered,
+        :changeable => :none } #{:frozen => :none}[changeability] || changeability}
+    end
+  end
+
+  transform Generalization, :to => UML13EA::Generalization do
+    copy_features :except => [:child, :parent] do
+      { :taggedValue => trans(taggedValue) + [@env_out.new(UML13EA::TaggedValue, :tag => "ea_type", :value => "Generalization")],
+        :subtype => trans(child),
+        :supertype => trans(parent)}
+    end
+  end
+end

data/lib/rgen/ecore/ecore.rb

@@ -52,7 +52,21 @@ module RGen
       has_attr 'volatile', Boolean, :defaultValueLiteral => "false"
       module ClassModule
         def defaultValue_derived
-          eval(defaultValueLiteral) unless defaultValueLiteral.nil?
+          return nil if defaultValueLiteral.nil?
+          case eType
+            when EInt
+              defaultValueLiteral.to_i
+            when EFloat
+              defaultValueLiteral.to_f
+            when EEnum
+              defaultValueLiteral.to_sym
+            when EBoolean
+              defaultValueLiteral == "true"
+            when EString
+              defaultValueLiteral
+            else
+              raise "Unhandled type"
+            end
         end
       end
     end
@@ -187,4 +201,4 @@ module RGen
   ECore::EAttribute.has_one 'eAttributeType', ECore::EDataType, :lowerBound=>1, :derived=>true
   ECore::EReference.has_one 'eReferenceType', ECore::EClass, :lowerBound=>1, :derived=>true
   
-end
+end

data/lib/rgen/ecore/ecore_builder_methods.rb

@@ -0,0 +1,81 @@
+module RGen
+  
+module ECore
+  
+module ECoreBuilderMethods
+  def eAttr(name, type, argHash={}, &block)
+    eAttribute(name, {:eType => type}.merge(argHash), &block)
+  end
+  
+  def eRef(name, type, argHash={}, &block)
+    eReference(name, {:eType => type}.merge(argHash), &block)
+  end
+  
+  # create bidirectional reference at once
+  def eBiRef(name, type, oppositeName, argHash={})
+    raise BuilderError.new("eOpposite attribute not allowed for bidirectional references") \
+      if argHash[:eOpposite] || argHash[:opposite_eOpposite]
+    eReference(name, {:eType => type}.merge(argHash.reject{|k,v| k.to_s =~ /^opposite_/})) do 
+      eReference oppositeName, {:eContainingClass => type, :eType => _context(2),
+        :as => :eOpposite, :eOpposite => _context(1)}.
+          merge(Hash[*(argHash.select{|k,v| k.to_s =~ /^opposite_/}.
+            collect{|p| [p[0].to_s.sub(/^opposite_/,"").to_sym, p[1]]}.flatten)])
+    end
+  end
+  
+  # reference shortcuts
+  
+  alias references_1 eRef
+  alias references_one eRef
+  
+  def references_N(name, type, argHash={})
+    eRef(name, type, {:upperBound => -1}.merge(argHash))
+  end
+  alias references_many references_N
+  
+  def references_1to1(name, type, oppositeName, argHash={})
+    eBiRef(name, type, oppositeName, {:upperBound => 1, :opposite_upperBound => 1}.merge(argHash))
+  end
+  alias references_one_to_one references_1to1
+  
+  def references_1toN(name, type, oppositeName, argHash={})
+    eBiRef(name, type, oppositeName, {:upperBound => -1, :opposite_upperBound => 1}.merge(argHash))
+  end
+  alias references_one_to_many references_1toN
+  
+  def references_Nto1(name, type, oppositeName, argHash={})
+    eBiRef(name, type, oppositeName, {:upperBound => 1, :opposite_upperBound => -1}.merge(argHash))
+  end
+  alias references_many_to_one references_Nto1
+  
+  def references_MtoN(name, type, oppositeName, argHash={})
+    eBiRef(name, type, oppositeName, {:upperBound => -1, :opposite_upperBound => -1}.merge(argHash))
+  end
+  alias references_many_to_many references_MtoN
+  
+  # containment reference shortcuts
+  
+  def contains_1(name, type, argHash={})
+    references_1(name, type, {:containment => true}.merge(argHash))  
+  end
+  alias contains_one contains_1
+  
+  def contains_N(name, type, argHash={})
+    references_N(name, type, {:containment => true}.merge(argHash))  
+  end
+  alias contains_many contains_N
+  
+  def contains_1to1(name, type, oppositeName, argHash={})
+    references_1to1(name, type, oppositeName, {:containment => true}.merge(argHash))  
+  end
+  alias contains_one_to_one contains_1to1
+  
+  def contains_1toN(name, type, oppositeName, argHash={})
+    references_1toN(name, type, oppositeName, {:containment => true}.merge(argHash))  
+  end
+  alias contains_one_to_many contains_1toN  
+end
+
+end
+
+end

data/lib/rgen/ecore/ecore_instantiator.rb

@@ -19,7 +19,11 @@ module ECoreInstantiator
 		end
 		@@transformer.trans(self)
 	end	
-	
+
+  def self.clear_ecore_cache
+    require 'rgen/ecore/ecore_transformer'
+    @@transformer = ECoreTransformer.new
+  end
 end
 
 end

data/lib/rgen/metamodel_builder/builder_extensions.rb

@@ -217,7 +217,15 @@ module BuilderExtensions
 		
 	def _metamodel_description # :nodoc:
 		@metamodel_description ||= []
-	end
+  end
+
+  def _add_metamodel_description(desc) # :nodoc
+		@metamodel_description ||= []
+    @metamodelDescriptionByName ||= {}
+    @metamodel_description.delete(@metamodelDescriptionByName[desc.value(:name)])
+    @metamodel_description << desc 
+    @metamodelDescriptionByName[desc.value(:name)] = desc
+  end
   
   def abstract
     @abstract = true
@@ -236,7 +244,7 @@ module BuilderExtensions
 	# Central builder method
 	# 
 	def _build_internal(props1, props2=nil)
-		_metamodel_description << props1
+		_add_metamodel_description(props1)
 		if props1.is_a?(ReferenceDescription) && props1.many?
 			_build_many_methods(props1, props2)
 		else
@@ -246,7 +254,7 @@ module BuilderExtensions
 			# this is a bidirectional reference
 			props1.opposite, props2.opposite = props2, props1
 			other_class = props1.impl_type			
-			other_class._metamodel_description << props2
+			other_class._add_metamodel_description(props2)
 			raise "Internal error: second description must be a ReferenceDescription" \
 				unless props2.is_a?(ReferenceDescription)
 			if props2.many?

data/lib/rgen/metamodel_builder/module_extension2.rb

@@ -0,0 +1,205 @@
+require 'rgen/ecore/ecore_ext'
+
+module RGen
+
+module ModelBuilder
+
+class BuilderContext
+  attr_accessor :contextElement, :resolver
+end
+
+class ReferenceResolver
+  ResolverJob = Struct.new(:receiver, :reference, :namespace, :string)
+  
+  class ResolverException < Exception
+  end
+
+  def addJob(job)
+    @jobs ||= []
+    @jobs << job
+  end
+  
+  def resolve(env=nil)
+    (@jobs || []).each do |job|
+      begin
+        target = resolveReference(env, job.namespace, job.string.split("."), job.reference.eType.instanceClass, true)
+      rescue ResolverException => e
+        raise ResolverException.new("Can not resolve reference #{job.string}: #{e.message}")
+      end
+      if job.reference.many
+        job.receiver.addGeneric(job.reference.name, target)
+      else
+        job.receiver.setGeneric(job.reference.name, target)
+      end
+    end
+  end
+  
+  private
+  
+  def resolveReference(env, namespace, nameParts, targetClass, toplevel=false)
+    #puts "resolveReferences nameParts " + nameParts.inspect + " namespace #{namespace}"
+    firstPart, *restParts = nameParts
+    if namespace
+      children = elementChildren(namespace)
+      #puts children.inspect
+      #puts "looking for a element named #{firstPart}"
+      elements = children.select{|e| e.respond_to?(:name) && e.name == firstPart}
+      #puts elements.inspect
+      #puts elementParents(namespace).inspect
+      if elements.empty? && elementParents(namespace).size > 0 && toplevel
+        #puts "Trying parent"
+        raise ResolverException.new("Element #{namespace} has multiple parents") if elementParents(namespace).size > 1
+        elements << resolveReference(env, elementParents(namespace).first, nameParts, targetClass, true)
+      else
+        where = "within children of #{namespace}"
+        where += " named #{namespace.name}" if namespace.respond_to?(:name)
+      end
+    elsif env
+      elements = env.find(:class => targetClass, :name => firstPart)
+      where = "in environment"
+    else
+      raise ResolverException.new("Neither namespace nor environment specified")
+    end
+    raise ResolverException.new("Can not find element named #{firstPart} #{where}") if elements.size == 0
+    raise ResolverException.new("Multiple elements named #{firstPart} found #{where}") if elements.size > 1
+    if restParts.size > 0
+      resolveReference(env, elements.first, restParts, targetClass)
+    else
+      elements.first
+    end
+  end
+  
+  def elementChildren(element)
+    @elementChildren ||= {}
+    return @elementChildren[element] if @elementChildren[element]
+    children = element.class.ecore.eAllReferences.select{|r| r.containment}.collect do |r|
+      element.getGeneric(r.name)
+    end.flatten.compact
+    @elementChildren[element] = children
+  end
+  
+  def elementParents(element)
+    @elementParents ||= {}
+    return @elementParents[element] if @elementParents[element]
+    parents = element.class.ecore.eAllReferences.select{|r| r.eOpposite && r.eOpposite.containment}.collect do |r|
+      element.getGeneric(r.name)
+    end.flatten.compact
+    @elementParents[element] = parents
+  end  
+end
+
+# this module takes up helper methods to avoid littering the package modules
+module Helper
+  class << self
+    def processArguments(args)
+      unless (args.size == 2 && args.first.is_a?(String) && args.last.is_a?(Hash)) ||
+        (args.size == 1 && (args.first.is_a?(String) || args.first.is_a?(Hash)))
+        raise "Provide a Hash to set feature values, " +
+          "optionally the first argument may be a String specifying " + 
+          "the value of the \"name\" attribute."
+      end
+      if args.last.is_a?(Hash)
+        argHash = args.last
+      else
+        argHash = {}
+      end
+      argHash[:name] ||= args.first if args.first.is_a?(String)
+      argHash
+    end
+    
+    def processArgHash(argHash, eClass)
+      resolverJobs = []
+      asRole = nil
+      argHash.each_pair do |k,v|
+        if k == :as
+          asRole = v
+          argHash.delete(k)
+        elsif v.is_a?(String)
+          ref = eClass.eAllReferences.find{|r| r.name == k.to_s}
+          if ref
+            argHash.delete(k)
+            resolverJobs << ReferenceResolver::ResolverJob.new(nil, ref, nil,  v)
+          end
+        end
+      end
+      [ resolverJobs, asRole ]
+    end
+    
+    def associateWithContextElement(element, contextElement, asRole)
+      return unless contextElement
+      contextClass = contextElement.class.ecore
+      if asRole
+        asRoleRef = contextClass.eAllReferences.find{|r| r.name == asRole.to_s}
+        raise "Context class #{contextClass.name} has no reference named #{asRole}" unless asRoleRef
+        ref = asRoleRef
+      else
+        possibleContainmentRefs = contextClass.eAllReferences.select { |r| r.containment && 
+          (element.class.ecore.eAllSuperTypes << element.class.ecore).include?(r.eType) }
+        if possibleContainmentRefs.size == 1
+          ref = possibleContainmentRefs.first
+        elsif possibleContainmentRefs.size == 0
+          raise "Context class #{contextClass.name} can not contain a #{element.class.ecore.name}"
+        else
+          raise "Context class #{contextClass.name} has several containment references to a #{element.class.ecore.name}." +
+            " Clearify using \":as => <role>\""
+        end
+      end
+      if ref.many
+        contextElement.addGeneric(ref.name, element)
+      else
+        contextElement.setGeneric(ref.name, element)
+      end
+    end
+  end
+end
+
+end
+
+module MetamodelBuilder
+
+module ModuleExtension
+
+  def method_missing(m, *args, &block)
+    return super unless self.ecore.is_a?(RGen::ECore::EPackage)
+    className = m.to_s[0..0].upcase + m.to_s[1..-1]
+    eClass = self.ecore.eClasses.find{|c| c.name == className}
+    return super unless eClass
+    argHash = ModelBuilder::Helper.processArguments(args)
+    resolverJobs, asRole = ModelBuilder::Helper.processArgHash(argHash, eClass)
+    element = eClass.instanceClass.new(argHash)
+    if @builderContext
+      ModelBuilder::Helper.associateWithContextElement(element, @builderContext.contextElement, asRole)
+      resolver = @builderContext.resolver 
+    else
+      resolver = ModelBuilder::ReferenceResolver.new
+    end
+    resolverJobs.each do |job|
+      job.receiver = element
+      job.namespace = @builderContext && @builderContext.contextElement
+      resolver.addJob(job)
+    end
+    # process block
+    if block
+      if @builderContext
+        @builderContext, oldContext = @builderContext.dup, @builderContext
+      else
+        @builderContext = ModelBuilder::BuilderContext.new
+        @builderContext.resolver = resolver
+        oldContext = nil
+      end
+      @builderContext.contextElement = element
+      instance_eval(&block)
+      @builderContext = oldContext
+      if oldContext.nil?
+        # we are back on toplevel
+        resolver.resolve
+      end
+    end
+    element
+  end
+  
+end
+
+end
+
+end