rgen 0.5.4 → 0.6.0

data/lib/rgen/ecore/ecore.rb

@@ -93,6 +93,14 @@ module RGen
     class EDataType < EClassifier
       has_attr 'serializable', Boolean
     end
+
+    class EGenericType < EDataType
+      has_one 'eClassifier', EDataType
+    end
+
+    class ETypeArgument < EModelElement
+      has_one 'eClassifier', EDataType
+    end
     
     class EEnum < EDataType
     end
@@ -173,7 +181,7 @@ module RGen
     
     EString = EDataType.new(:name => "EString", :instanceClassName => "String")
     EInt = EDataType.new(:name => "EInt", :instanceClassName => "Integer")
-    EBoolean = EDataType.new(:name => "EBoolean", :instanceClassName => "RGen::MetamodelBuilder::DataTypes::Boolean")
+    EBoolean = EDataType.new(:name => "EBoolean", :instanceClassName => "Boolean")
     EFloat = EDataType.new(:name => "EFloat", :instanceClassName => "Float")
     ERubyObject = EDataType.new(:name => "ERubyObject", :instanceClassName => "Object")
     EJavaObject = EDataType.new(:name => "EJavaObject")
@@ -200,5 +208,7 @@ module RGen
   
   ECore::EAttribute.has_one 'eAttributeType', ECore::EDataType, :lowerBound=>1, :derived=>true
   ECore::EReference.has_one 'eReferenceType', ECore::EClass, :lowerBound=>1, :derived=>true
+  ECore::EParameter.contains_one 'eGenericType', ECore::EGenericType, 'eParameter'
+  ECore::EGenericType.contains_many 'eTypeArguments', ECore::ETypeArgument, 'eGenericType'
   
 end

data/lib/rgen/ecore/ecore_interface.rb

@@ -0,0 +1,47 @@
+module RGen
+
+module ECore
+
+# Mixin to provide access to the ECore model describing a Ruby class or module
+# built using MetamodelBuilder.
+# The module should be used to +extend+ a class or module, i.e. to make its
+# methods class methods.
+# 
+module ECoreInterface
+  
+  # This method will lazily build to ECore model element belonging to the calling
+  # class or module using RubyToECore.
+  # Alternatively, the ECore model element can be provided up front. This is used
+  # when the Ruby metamodel classes and modules are created from ECore.
+  # 
+  def ecore
+    if defined?(@ecore)
+      @ecore
+    else
+      unless defined?(@@transformer)
+        require 'rgen/ecore/ruby_to_ecore'
+        @@transformer = RubyToECore.new
+      end
+      @@transformer.trans(self)
+    end
+  end  
+
+  # This method can be used to clear the ecore cache after the metamodel classes
+  # or modules have been changed; the ecore model will be recreated on next access
+  # to the +ecore+ method
+  # Beware, the ecore cache is global, i.e. for all metamodels.
+  #
+  def self.clear_ecore_cache
+    require 'rgen/ecore/ruby_to_ecore'
+    @@transformer = RubyToECore.new
+  end
+
+  def _set_ecore_internal(ecore) # :nodoc:
+    @ecore = ecore
+  end
+
+end
+
+end
+
+end

data/lib/rgen/ecore/ecore_to_ruby.rb

@@ -0,0 +1,166 @@
+require 'rgen/ecore/ecore'
+
+module RGen
+  
+module ECore
+
+class ECoreToRuby
+  
+  def initialize
+    @modules = {}
+    @classifiers = {}
+    @features_added = {}
+    @in_create_module = false
+  end
+
+  def create_module(epackage)
+    return @modules[epackage] if @modules[epackage]
+    
+    top = (@in_create_module == false)
+    @in_create_module = true
+
+    m = Module.new do
+      extend RGen::MetamodelBuilder::ModuleExtension
+    end
+    @modules[epackage] = m
+
+    epackage.eSubpackages.each{|p| create_module(p)}
+    m._set_ecore_internal(epackage)
+
+    create_module(epackage.eSuperPackage).const_set(epackage.name, m) if epackage.eSuperPackage
+
+    # create classes only after all modules have been created
+    # otherwise classes may be created multiple times
+    if top
+      epackage.eAllClassifiers.each do |c| 
+        if c.is_a?(RGen::ECore::EClass)
+          create_class(c)
+        elsif c.is_a?(RGen::ECore::EEnum)
+          create_enum(c)
+        end
+      end
+      @in_create_module = false
+    end
+    m
+  end
+
+  def create_class(eclass)
+    return @classifiers[eclass] if @classifiers[eclass]
+
+    c = Class.new(super_class(eclass)) do
+      abstract if eclass.abstract
+      class << self
+        attr_accessor :_ecore_to_ruby
+      end
+    end
+    class << eclass
+      attr_accessor :instanceClass
+      def instanceClassName
+        instanceClass.to_s
+      end
+    end
+    eclass.instanceClass = c
+    c::ClassModule.module_eval do
+      alias _method_missing method_missing
+      def method_missing(m, *args)
+        if self.class._ecore_to_ruby.add_features(self.class.ecore)
+          send(m, *args)
+        else
+          _method_missing(m, *args)
+        end
+      end
+      alias _respond_to respond_to?
+      def respond_to?(m)
+        self.class._ecore_to_ruby.add_features(self.class.ecore)
+        _respond_to(m)
+      end
+    end
+    @classifiers[eclass] = c
+    c._set_ecore_internal(eclass)
+    c._ecore_to_ruby = self
+
+    create_module(eclass.ePackage).const_set(eclass.name, c)
+    c
+  end
+
+  def create_enum(eenum)
+    return @classifiers[eenum] if @classifiers[eenum]
+
+    e = RGen::MetamodelBuilder::DataTypes::Enum.new(eenum.eLiterals.collect{|l| l.name.to_sym})
+    @classifiers[eenum] = e
+
+    create_module(eenum.ePackage).const_set(eenum.name, e)
+    e
+  end
+
+  class FeatureWrapper
+    def initialize(efeature, classifiers)
+      @efeature = efeature
+      @classifiers = classifiers
+    end
+    def value(prop)
+      @efeature.send(prop)
+    end
+    def many
+      @efeature.many
+    end
+    def reference?
+      @efeature.is_a?(RGen::ECore::EReference)
+    end
+    def opposite
+      @efeature.eOpposite
+    end
+    def impl_type
+      etype = @efeature.eType
+      if etype.is_a?(RGen::ECore::EClass) || etype.is_a?(RGen::ECore::EEnum)
+        @classifiers[etype]
+      else
+        ic = etype.instanceClass
+        if ic
+          ic
+        else
+          raise "unknown type: #{etype.name}" 
+        end
+      end
+    end
+  end
+
+  def add_features(eclass)
+    return false if @features_added[eclass]
+    c = @classifiers[eclass]
+    eclass.eStructuralFeatures.each do |f|
+      w1 = FeatureWrapper.new(f, @classifiers) 
+      w2 = FeatureWrapper.new(f.eOpposite, @classifiers) if f.is_a?(RGen::ECore::EReference) && f.eOpposite
+      c.module_eval do
+        if w1.many
+          _build_many_methods(w1, w2)
+        else
+          _build_one_methods(w1, w2)
+        end
+      end
+    end
+    @features_added[eclass] = true
+    eclass.eSuperTypes.each do |t|
+      add_features(t)
+    end
+    true
+  end
+
+  def super_class(eclass)
+    super_types = eclass.eSuperTypes
+    case super_types.size
+    when 0
+      RGen::MetamodelBuilder::MMBase
+    when 1
+      create_class(super_types.first)
+    else
+      RGen::MetamodelBuilder::MMMultiple(*super_types.collect{|t| create_class(t)})
+    end
+  end
+
+end
+
+end
+
+end
+

data/lib/rgen/ecore/{ecore_transformer.rb → ruby_to_ecore.rb}

@@ -8,7 +8,7 @@ module ECore
 # This transformer creates an ECore model from Ruby classes built
 # by RGen::MetamodelBuilder.
 # 
-class ECoreTransformer < Transformer
+class RubyToECore < Transformer
   
   transform Class, :to => EClass, :if => :convert? do
     { :name => name.gsub(/.*::(\w+)$/,'\1'),
@@ -31,13 +31,13 @@ class ECoreTransformer < Transformer
   end
   
   transform Module, :to => EPackage, :if => :convert?  do
-  	@enumParentModule ||= {}
+    @enumParentModule ||= {}
     _constants = _constantOrder + (constants - _constantOrder)
-  	_constants.select {|c| const_get(c).is_a?(MetamodelBuilder::DataTypes::Enum)}.
-  		each {|c| @enumParentModule[const_get(c)] = @current_object}
+    _constants.select {|c| const_get(c).is_a?(MetamodelBuilder::DataTypes::Enum)}.
+      each {|c| @enumParentModule[const_get(c)] = @current_object}
     { :name => name.gsub(/.*::(\w+)$/,'\1'),
       :eClassifiers => trans(_constants.collect{|c| const_get(c)}.select{|c| c.is_a?(Class) || 
-	      (c.is_a?(MetamodelBuilder::DataTypes::Enum) && c != MetamodelBuilder::DataTypes::Boolean) }),
+        (c.is_a?(MetamodelBuilder::DataTypes::Enum) && c != MetamodelBuilder::DataTypes::Boolean) }),
       :eSuperPackage => trans(name =~ /(.*)::\w+$/ ? eval($1) : nil),
       :eSubpackages => trans(_constants.collect{|c| const_get(c)}.select{|c| c.is_a?(Module) && !c.is_a?(Class)}),
       :eAnnotations => trans(_annotations)
@@ -48,15 +48,15 @@ class ECoreTransformer < Transformer
     @current_object.respond_to?(:ecore) && @current_object != RGen::MetamodelBuilder::MMBase
   end
   
-  transform MetamodelBuilder::AttributeDescription, :to => EAttribute do
-    Hash[*MetamodelBuilder::AttributeDescription.propertySet.collect{|p| [p, value(p)]}.flatten].merge({
+  transform MetamodelBuilder::Intermediate::Attribute, :to => EAttribute do
+    Hash[*MetamodelBuilder::Intermediate::Attribute.properties.collect{|p| [p, value(p)]}.flatten].merge({
       :eType => (etype == :EEnumerable ? trans(impl_type) : RGen::ECore.const_get(etype)),
       :eAnnotations => trans(annotations)
     })
   end
   
-  transform MetamodelBuilder::ReferenceDescription, :to => EReference do
-    Hash[*MetamodelBuilder::ReferenceDescription.propertySet.collect{|p| [p, value(p)]}.flatten].merge({
+  transform MetamodelBuilder::Intermediate::Reference, :to => EReference do
+    Hash[*MetamodelBuilder::Intermediate::Reference.properties.collect{|p| [p, value(p)]}.flatten].merge({
       :eType => trans(impl_type),
       :eOpposite => trans(opposite),
       :eAnnotations => trans(annotations)
@@ -66,7 +66,7 @@ class ECoreTransformer < Transformer
   transform MetamodelBuilder::Intermediate::Annotation, :to => EAnnotation do
     { :source => source,
       :details => details.keys.collect do |k|
-        e = EStringToStringMapEntry.new
+        e = RGen::ECore::EStringToStringMapEntry.new
         e.key = k
         e.value = details[k]
         e
@@ -78,7 +78,7 @@ class ECoreTransformer < Transformer
     { :name => name, 
       :instanceClassName => @enumParentModule && @enumParentModule[@current_object] && @enumParentModule[@current_object].name+"::"+name,
       :eLiterals => literals.collect do |l|
-        lit = EEnumLiteral.new
+        lit = RGen::ECore::EEnumLiteral.new
         lit.name = l.to_s
         lit
       end }

data/lib/rgen/environment.rb

@@ -8,6 +8,8 @@ class Environment
 		@elements = {}
 		@subClasses = {}
 		@subClassesUpdated = {}
+    @deleted = {}
+    @deletedClasses = {}
 	end
 	
 	# Add a model element. Returns the environment so <code><<</code> can be chained.
@@ -22,19 +24,21 @@ class Environment
 
 	# Removes model element from environment.
 	def delete(el)
-		return unless @elements[el.class]
-		@elements[el.class].delete(el)
+    @deleted[el] = true
+    @deletedClasses[el.class] = true
 	end
 		
 	# Iterates each element
 	#
 	def each(&b)
+    removeDeleted
 		@elements.values.flatten.each(&b)
 	end
 	
 	# Return the elements of the environment as an array
 	#
 	def elements
+    removeDeleted
 		@elements.values.flatten
 	end
 	
@@ -57,6 +61,7 @@ class Environment
 	# class. In this case an array of possible classes can optionally be given.
 	# 
 	def find(desc)
+    removeDeleted
 		result = []
 		classes = desc[:class] if desc[:class] and desc[:class].is_a?(Array)
 		classes = [ desc[:class] ] if !classes and desc[:class]
@@ -79,6 +84,14 @@ class Environment
 	end
 	
 	private
+
+  def removeDeleted
+    @deletedClasses.keys.each do |c|
+      @elements[c].reject!{|e| @deleted[e]}
+    end
+    @deletedClasses.clear
+    @deleted.clear
+  end
 	
 	def updateSubClasses(clazz)
 		return if @subClassesUpdated[clazz]

data/lib/rgen/fragment/dump_file_cache.rb

@@ -0,0 +1,63 @@
+module RGen
+
+module Fragment
+
+# Caches model fragments in Ruby dump files.
+#
+# Dump files are created per each fragment file.
+#
+# The main goal is to support fast loading and joining of fragments. Therefore the cache 
+# stores additional information which makes the joining process faster (adding to 
+# environment, resolving references)
+#
+class DumpFileCache
+
+  # +cache_map+ must be an object responding to +load_data+ and +store_data+
+  # for loading or storing data associated with a file;
+  # this can be an instance of Util::FileCacheMap
+  def initialize(cache_map)
+    @cache_map = cache_map 
+  end
+
+  # Note that the fragment must not be connected to other fragments by resolved references
+  # unresolve the fragment if necessary
+  def store(fragment)
+    fref = fragment.fragment_ref
+    # temporarily remove the reference to the fragment to avoid dumping the fragment
+    fref.fragment = nil
+    @cache_map.store_data(fragment.location,
+      Marshal.dump({
+        :root_elements => fragment.root_elements,
+        :elements => fragment.elements,
+        :index => fragment.index,
+        :unresolved_refs => fragment.unresolved_refs,
+        :fragment_ref => fref,
+        :data => fragment.data
+      }))
+    fref.fragment = fragment
+  end
+
+  def load(fragment)
+    dump = @cache_map.load_data(fragment.location)
+    return :invalid if dump == :invalid
+    header = Marshal.load(dump)
+    fragment.set_root_elements(header[:root_elements],
+      :elements => header[:elements],
+      :index => header[:index],
+      :unresolved_refs => header[:unresolved_refs])
+    fragment.data = header[:data]
+    if header[:fragment_ref]
+      fragment.fragment_ref = header[:fragment_ref]
+      fragment.fragment_ref.fragment = fragment
+    else
+      raise "no fragment_ref in fragment loaded from cache"
+    end
+  end
+
+end
+
+end
+
+end
+
+

data/lib/rgen/fragment/fragmented_model.rb

@@ -0,0 +1,139 @@
+require 'rgen/instantiator/reference_resolver'
+
+module RGen
+
+module Fragment
+
+# A FragmentedModel represents a model which consists of fragments (ModelFragment).
+# 
+# The main purpose of this class is to resolve references across fragments and
+# to keep the references consistent while fragments are added or removed.
+# This way it also plays an important role in keeping the model fragments consistent
+# and thus ModelFragment objects should only be accessed via this interface.
+# Overall unresolved references after the resolution step are also maintained.
+#
+# A FragmentedModel can also  keep an RGen::Environment object up to date while fragments
+# are added or removed. The environment must be registered with the constructor.
+#
+# Reference resolution is based on arbitrary identifiers. The identifiers must be
+# provided in the fragments' indices. The FragmentedModel takes care to maintain
+# the overall index.
+#
+class FragmentedModel
+  attr_reader :fragments
+  attr_reader :environment
+
+  # Creates a fragmented model. Options:
+  #
+  #  :env 
+  #    environment which will be updated as model elements are added and removed
+  #
+  def initialize(options={})
+    @environment = options[:env]
+    @fragments = []
+    @index = nil
+    @fragment_change_listeners = []
+    @fragment_index = {}
+  end
+
+  # Adds a proc which is called when a fragment is added or removed
+  # The proc receives the fragment and one of :added, :removed
+  #
+  def add_fragment_change_listener(listener)
+    @fragment_change_listeners << listener
+  end
+
+  def remove_fragment_change_listener(listener)
+    @fragment_change_listeners.delete(listener)
+  end
+
+  # Add a fragment.
+  #
+  def add_fragment(fragment)
+    invalidate_cache
+    @fragments << fragment
+    fragment.elements.each{|e| @environment << e} if @environment
+    @fragment_change_listeners.each{|l| l.call(fragment, :added)}
+  end
+
+  # Removes the fragment. The fragment will be unresolved using unresolve_fragment.
+  #
+  def remove_fragment(fragment)
+    raise "fragment not part of model" unless @fragments.include?(fragment)
+    invalidate_cache
+    @fragments.delete(fragment)
+    @fragment_index.delete(fragment)
+    unresolve_fragment(fragment)
+    fragment.elements.each{|e| @environment.delete(e)} if @environment
+    @fragment_change_listeners.each{|l| l.call(fragment, :removed)}
+  end
+
+  # Resolve references between fragments. 
+  # It is assumed that references within fragments have already been resolved.
+  # This method can be called several times. It will update the overall unresolved references.
+  #
+  # Options:
+  #
+  #  :fragment_provider:
+  #    Only if a +fragment_provider+ is given, the resolve step can be reverted later on
+  #    by a call to unresolve_fragment. The fragment provider is a proc which receives a model
+  #    element and must return the fragment in which the element is contained.
+  #
+  #  :use_target_type:
+  #    reference resolver uses the expected target type to narrow the set of possible targets 
+  #
+  def resolve(options)
+    @fragments.each do |f|
+      f.resolve_external(index, options)
+    end
+  end
+
+  # Remove all references between this fragment and all other fragments.
+  # The references will be replaced with unresolved references (MMProxy objects).
+  #
+  def unresolve_fragment(fragment)
+    fragment.unresolve_external
+    @fragments.each do |f|
+      if f != fragment
+        f.unresolve_external_fragment(fragment)
+      end
+    end
+  end
+
+  # Returns the overall unresolved references.
+  #
+  def unresolved_refs
+    @fragments.collect{|f| f.unresolved_refs}.flatten
+  end
+
+  # Returns the overall index. 
+  # This is a Hash mapping identifiers to model elements accessible via the identifier. 
+  #
+  def index
+    fragments.each do |f|
+      if !@fragment_index[f] || (@fragment_index[f].object_id != f.index.object_id)
+        @fragment_index[f] = f.index
+        invalidate_cache
+      end
+    end
+    return @index if @index
+    @index = {}
+    fragments.each do |f|
+      f.index.each do |i| 
+        (@index[i[0]] ||= []) << i[1]
+      end
+    end
+    @index
+  end
+
+  private
+
+  def invalidate_cache
+    @index = nil
+  end
+
+end
+
+end
+
+end