rgen 0.5.4 → 0.6.0

data/lib/rgen/fragment/model_fragment.rb

@@ -0,0 +1,268 @@
+require 'rgen/instantiator/reference_resolver'
+
+module RGen
+
+module Fragment
+
+# A model fragment is a list of root model elements associated with a location (e.g. a file)
+#
+# Optionally, an arbitrary data object may be associated with the fragment. The data object
+# will also be stored in the cache.
+#
+# If an element within the fragment changes this must be indicated to the fragment by calling
+# +mark_changed+. 
+#
+class ModelFragment
+  attr_reader :root_elements
+  attr_accessor :location, :fragment_ref, :data
+  
+  # A FragmentRef serves as a single target object for elements which need to reference the
+  # fragment they are contained in. The FragmentRef references the fragment it is contained in.
+  # The FragmentRef is separate from the fragment itself to allow storing it in a marshal dump
+  # independently of the fragment.
+  #
+  class FragmentRef
+    attr_accessor :fragment
+  end
+
+  # A ResolvedReference wraps an unresolved reference after it has been resolved.
+  # It also holds the target element to which it has been resolved, i.e. with which the proxy
+  # object has been replaced.
+  #
+  class ResolvedReference
+    attr_reader :uref, :target
+    def initialize(uref, target)
+      @uref, @target = uref, target
+    end
+  end
+
+  # Create a model fragment
+  #
+  #  :data
+  #    data object associated with this fragment
+  #
+  #  :identifier_provider
+  #    identifier provider to be used when resolving references
+  #    it must be a proc which receives a model element and must return 
+  #    that element's identifier or nil if the element has no identifier
+  #
+  def initialize(location, options={})
+    @location = location
+    @fragment_ref = FragmentRef.new
+    @fragment_ref.fragment = self
+    @data = options[:data]
+    @resolved_refs = nil 
+    @changed = false
+    @identifier_provider = options[:identifier_provider]
+  end
+
+  # Set the root elements, normally done by an instantiator.
+  #
+  # For optimization reasons the instantiator of the fragment may provide data explicitly which
+  # is normally derived by the fragment itself. In this case it is essential that this
+  # data is consistent with the fragment.
+  #
+  def set_root_elements(root_elements, options={})
+    @root_elements = root_elements 
+    @elements = options[:elements]
+    @index = options[:index]
+    @unresolved_refs = options[:unresolved_refs]
+    @resolved_refs = nil 
+    @changed = false
+  end
+
+  # Must be called when any of the elements in this fragment has been changed
+  #
+  def mark_changed
+    @changed = true
+    @elements = nil
+    @index = nil
+    @unresolved_refs = nil
+    @resolved_refs = :dirty 
+  end
+
+  # Can be used to reset the change status to unchanged.
+  #
+  def mark_unchanged
+    @changed = false
+  end
+
+  # Indicates whether the fragment has been changed or not
+  #
+  def changed?
+    @changed
+  end
+
+  # Returns all elements within this fragment
+  #
+  def elements
+    return @elements if @elements
+    @elements = []
+    @root_elements.each do |e|
+      all_child_elements(e, @elements)
+    end
+    @elements
+  end
+  
+  # Returns the index of the element contained in this fragment.
+  #
+  def index
+    build_index unless @index
+    @index
+  end
+
+  # Returns all unresolved references within this fragment, i.e. references to MMProxy objects
+  #
+  def unresolved_refs
+    return @unresolved_refs if @unresolved_refs
+    @unresolved_refs = []
+    elements.each do |e|
+      each_reference_target(e) do |r, t|
+        if t.is_a?(RGen::MetamodelBuilder::MMProxy)
+          @unresolved_refs << 
+            RGen::Instantiator::ReferenceResolver::UnresolvedReference.new(e, r.name, t)
+        end
+      end
+    end
+    @unresolved_refs
+  end
+
+  # Builds the index of all elements within this fragment having an identifier
+  # the index is an array of 2-element arrays holding the identifier and the element
+  #
+  def build_index
+    raise "cannot build index without an identifier provider" unless @identifier_provider
+    @index = elements.collect { |e|
+      ident = @identifier_provider.call(e, nil)
+      ident && !ident.empty? ? [ident, e] : nil 
+    }.compact
+  end
+
+  # Resolves local references (within this fragment) as far as possible
+  #
+  # Options:
+  #
+  #  :use_target_type:
+  #    reference resolver uses the expected target type to narrow the set of possible targets 
+  #
+  def resolve_local(options={})
+    resolver = RGen::Instantiator::ReferenceResolver.new
+    index.each do |i|
+      resolver.add_identifier(i[0], i[1])
+    end
+    @unresolved_refs = resolver.resolve(unresolved_refs, :use_target_type => options[:use_target_type])
+  end
+
+  # Resolves references to external fragments using the external_index provided.
+  # The external index must be a Hash mapping identifiers uniquely to model elements.
+  #
+  # Options:
+  #
+  #  :fragment_provider:
+  #    If a +fragment_provider+ is given, the resolve step can be reverted later on 
+  #    by a call to unresolve_external or unresolve_external_fragment. The fragment provider
+  #    is a proc which receives a model element and must return the fragment in which it is
+  #    contained.
+  #
+  #  :use_target_type:
+  #    reference resolver uses the expected target type to narrow the set of possible targets 
+  #
+  #
+  def resolve_external(external_index, options)
+    fragment_provider = options[:fragment_provider]
+    resolver = RGen::Instantiator::ReferenceResolver.new(
+      :identifier_resolver => proc {|ident| external_index[ident] })
+    if fragment_provider
+      @resolved_refs = {} if @resolved_refs.nil? || @resolved_refs == :dirty
+      on_resolve = proc { |ur, target|
+        target_fragment = fragment_provider.call(target)
+        target_fragment ||= :unknown
+        raise "can not resolve local reference in resolve_external, call resolve_local first" \
+          if target_fragment == self
+        @resolved_refs[target_fragment] ||= []
+        @resolved_refs[target_fragment] << ResolvedReference.new(ur, target)
+      } 
+      @unresolved_refs = resolver.resolve(unresolved_refs, :on_resolve => on_resolve, :use_target_type => options[:use_target_type])
+    else
+      @unresolved_refs = resolver.resolve(unresolved_refs, :use_target_type => options[:use_target_type])
+    end
+  end
+
+  # Unresolve outgoing references to all external fragments, i.e. references which used to
+  # be represented by an unresolved reference from within this fragment.
+  # Note, that there may be more references to external fragments due to references which 
+  # were represented by unresolved references from within other fragments.
+  # 
+  def unresolve_external
+    return if @resolved_refs.nil?
+    raise "can not unresolve, missing fragment information" if @resolved_refs == :dirty || @resolved_refs[:unknown]
+    rrefs = @resolved_refs.values.flatten
+    @resolved_refs = {}
+    unresolve_refs(rrefs)
+  end
+
+  # Like unresolve_external but only unresolve references to external fragment +fragment+
+  #
+  def unresolve_external_fragment(fragment)
+    return if @resolved_refs.nil?
+    raise "can not unresolve, missing fragment information" if @resolved_refs == :dirty || @resolved_refs[:unknown]
+    rrefs = @resolved_refs[fragment]
+    @resolved_refs.delete(fragment)
+    unresolve_refs(rrefs) if rrefs
+  end
+
+  private
+
+  # Turns resolved references +rrefs+ back into unresolved references
+  #
+  def unresolve_refs(rrefs)
+    rrefs.each do |rr|
+      ur = rr.uref
+      refs = ur.element.getGeneric(ur.feature_name)
+      if refs.is_a?(Array)
+        index = refs.index(rr.target)
+        ur.element.removeGeneric(ur.feature_name, rr.target)
+        ur.element.addGeneric(ur.feature_name, ur.proxy, index)
+      else
+        ur.element.setGeneric(ur.feature_name, ur.proxy)
+      end
+      @unresolved_refs << ur
+    end
+  end
+
+  def each_reference_target(element)
+    non_containment_references(element.class).each do |r|
+      element.getGenericAsArray(r.name).each do |t|
+        yield(r, t)
+      end
+    end
+  end
+
+  def all_child_elements(element, childs)
+    containment_references(element.class).each do |r|
+      element.getGenericAsArray(r.name).each do |c|
+        childs << c
+        all_child_elements(c, childs)
+      end
+    end
+  end
+
+  def containment_references(clazz)
+    @@containment_references_cache ||= {}
+    @@containment_references_cache[clazz] ||=
+      clazz.ecore.eAllReferences.select{|r| r.containment}
+  end
+
+  def non_containment_references(clazz)
+    @@non_containment_references_cache ||= {}
+    @@non_containment_references_cache[clazz] ||= 
+      clazz.ecore.eAllReferences.select{|r| !r.containment}
+  end 
+
+end
+
+end
+
+end
+
+

data/lib/rgen/instantiator/abstract_xml_instantiator.rb

@@ -1,94 +1,66 @@
-$:.unshift File.join(File.dirname(__FILE__),"..","..","..","redist","xmlscan","lib")
-
-require 'xmlscan/namespace'
+require 'nokogiri'
 
 class AbstractXMLInstantiator
     
-  class XMLScanVisitor
-    include XMLScan::NSVisitor
+  class Visitor < Nokogiri::XML::SAX::Document
     
     def initialize(inst, gcSuspendCount)
-      @current_attributes = {}
       @instantiator = inst
       @gcSuspendCount = gcSuspendCount
+      @namespaces = {}
     end
     
-    def on_attribute_ns(qname, prefix, localpart)
-      @current_attr_name = qname
-    end
-    
-    def on_attr_value(str)
-      @current_attributes[@current_attr_name] = str
-    end
-    
-    def split_qname(qname)
-      if qname =~ /^([^:]+):([^:]+)$/
-        prefix, tag = $1, $2
-      else
-        prefix, tag = nil, qname
-      end
-      return prefix, tag
+    def start_element_namespace(tag, attributes, prefix, uri, ns)
+      controlGC
+      ns.each{|n| @namespaces[n[0]] = n[1]}
+      attrs = attributes.collect{|a| [a.prefix ? a.prefix+":"+a.localname : a.localname, a.value]}
+      @instantiator.start_tag(prefix, tag, @namespaces, Hash[*(attrs.flatten)])
+      attrs.each { |pair| @instantiator.set_attribute(pair[0], pair[1]) }
     end
     
-    def on_stag_end_ns(qname, namespaces)
-			controlGC
-      prefix, tag = split_qname(qname)
-      @instantiator.start_tag(prefix, tag, namespaces, @current_attributes)
-      @current_attributes.each_pair { |k,v| @instantiator.set_attribute(k, v) }
-      @current_attributes = {}
+    def end_element_namespace(tag, prefix, uri)
+      @instantiator.end_tag(prefix, tag)
     end
     
-    def on_stag_end_empty_ns(qname, namespaces)
-			controlGC
-      prefix, tag = split_qname(qname)
-      @instantiator.start_tag(prefix, tag, namespaces, @current_attributes)
-      @current_attributes.each_pair { |k,v| @instantiator.set_attribute(k, v) }
-      @current_attributes = {}
-      @instantiator.end_tag(prefix, tag)
+    def characters(str)
+      @instantiator.text(str)
     end
     
-    def on_etag(qname)
-      prefix, tag = split_qname(qname)
-      @instantiator.end_tag(prefix, tag)
+    def controlGC
+      return unless @gcSuspendCount > 0
+      @gcCounter ||= 0
+      @gcCounter += 1
+      if @gcCounter == @gcSuspendCount
+        @gcCounter = 0
+        GC.enable
+        ObjectSpace.garbage_collect
+        GC.disable 
+      end 
     end
-		
-		def on_chardata(str)
-			@instantiator.text(str)
-		end
-		
-		def controlGC
-			return unless @gcSuspendCount > 0
-			@gcCounter ||= 0
-			@gcCounter += 1
-			if @gcCounter == @gcSuspendCount
-				@gcCounter = 0
-				GC.enable
-				ObjectSpace.garbage_collect
-				GC.disable 
-			end    	
-		end
   end
 
-	# Parses str and calls start_tag, end_tag, set_attribute and text methods of a subclass.
-	# 
-	# If gcSuspendCount is specified, the garbage collector will be disabled for that
-	# number of start or end tags. After that period it will clean up and then be disabled again.
-	# A value of about 1000 can significantly improve overall performance.
-	# The memory usage normally does not increase.
-	# Depending on the work done for every xml tag the value might have to be adjusted.
-	# 
+  # Parses str and calls start_tag, end_tag, set_attribute and text methods of a subclass.
+  # 
+  # If gcSuspendCount is specified, the garbage collector will be disabled for that
+  # number of start or end tags. After that period it will clean up and then be disabled again.
+  # A value of about 1000 can significantly improve overall performance.
+  # The memory usage normally does not increase.
+  # Depending on the work done for every xml tag the value might have to be adjusted.
+  # 
   def instantiate(str, gcSuspendCount=0)
-  	gcDisabledBefore = GC.disable
-  	gcSuspendCount = 0 if gcDisabledBefore
-  	begin
-	    visitor = XMLScanVisitor.new(self, gcSuspendCount)
-			parser = XMLScan::XMLParserNS.new(visitor)
-			parser.parse(str)
-   	ensure 	
-    	GC.enable unless gcDisabledBefore
+    gcDisabledBefore = GC.disable
+    gcSuspendCount = 0 if gcDisabledBefore
+    begin
+      visitor = Visitor.new(self, gcSuspendCount)
+      parser = Nokogiri::XML::SAX::Parser.new(visitor)
+      parser.parse(str) do |ctx|
+        @parserContext = ctx
+      end
+     ensure 
+      GC.enable unless gcDisabledBefore
     end
   end
   
-	def text(str)
-	end
-end
+  def text(str)
+  end
+end

data/lib/rgen/instantiator/default_xml_instantiator.rb

@@ -8,7 +8,7 @@ module Instantiator
 # Derive your own instantiator from this class or use it as is.
 # 
 class DefaultXMLInstantiator < NodebasedXMLInstantiator
-	include NameHelper
+	include Util::NameHelper
 
 	NamespaceDescriptor = Struct.new(:prefix, :target)
 	
@@ -114,4 +114,4 @@ end
 
 end
 
-end
+end

data/lib/rgen/instantiator/ecore_xml_instantiator.rb

@@ -14,6 +14,7 @@ class ECoreXMLInstantiator < AbstractXMLInstantiator
     @env = env
     @rolestack = []
     @elementstack = []
+    @element_by_id = {}
     @loglevel = loglevel
   end
   
@@ -38,6 +39,10 @@ class ECoreXMLInstantiator < AbstractXMLInstantiator
     eClass = RGen::ECore.ecore.eClassifiers.find{|c| c.name == class_name}
     if eClass
       obj = RGen::ECore.const_get(class_name).new
+      if attributes["xmi:id"]
+        @element_by_id[attributes["xmi:id"]] = obj
+        attributes.delete("xmi:id")
+      end
       if eRef
         if eRef.many
           @elementstack.last.addGeneric(eRef.name, obj)
@@ -51,6 +56,10 @@ class ECoreXMLInstantiator < AbstractXMLInstantiator
       log WARN, "Class not found: #{class_name}"
       @elementstack.push nil
     end
+
+    attributes.each_pair do |attr, value|
+      set_attribute_internal(attr, value)
+    end
   end
   
   def end_tag(prefix, tag)
@@ -60,6 +69,10 @@ class ECoreXMLInstantiator < AbstractXMLInstantiator
   ResolverDescription = Struct.new(:object, :attribute, :value)
   
   def set_attribute(attr, value)
+    # do nothing, already handled by start_tag/set_attribute_internal
+  end
+
+  def set_attribute_internal(attr, value)
     return unless @elementstack.last
     eFeat = eAllStructuralFeatures(@elementstack.last).find{|a| a.name == attr}
     if eFeat.is_a?(EReference)
@@ -113,7 +126,9 @@ class ECoreXMLInstantiator < AbstractXMLInstantiator
   
   def find_referenced(context, desc)
     desc.split(/\s+/).collect do |r|
-      if r =~ /^#\/\d*\/([\w\/]+)/
+      if r =~ /^#([^\/]+)$/
+        @element_by_id[$1]
+      elsif r =~ /^#\/\d*\/([\w\/]+)/
         find_in_context(context, $1.split('/'))
       elsif r =~ /#\/\/(\w+)$/
         case $1