rgen 0.5.4 → 0.6.0

data/lib/rgen/instantiator/json_instantiator.rb

@@ -21,6 +21,8 @@ class JsonInstantiator
   # classes are looked for in metamodel package module +mm+,
   # +options+ include:
   #   short_class_names: if true subpackages will be searched for unqualifed class names (default: true)
+  #   ignore_keys:       an array of json object key names which are to be ignored (default: none)
+  #
   # The options are also passed to the underlying QualifiedNameResolver.
   #
   def initialize(env, mm, options={})
@@ -28,6 +30,7 @@ class JsonInstantiator
     @mm = mm
     @options = options
     @short_class_names = !@options.has_key?(:short_class_names) || @options[:short_class_names]
+    @ignore_keys = @options[:ignore_keys] || []
     @unresolvedReferences = []
     @classes = {}
     @classes_flat = {}
@@ -42,15 +45,23 @@ class JsonInstantiator
   # Returns an array of ReferenceResolver::UnresolvedReference
   # describing the references which could not be resolved
   #
-  def instantiate(str)
+  # Options:
+  #   :root_elements: if an array is provided, it will be filled with the root elements
+  #
+  def instantiate(str, options={})
     root = @parser.parse(str)
+    if options[:root_elements].is_a?(Array)
+      options[:root_elements].clear
+      root.each{|r| options[:root_elements] << r}
+    end
     resolver = QualifiedNameResolver.new(root, @options)
     resolver.resolveReferences(@unresolvedReferences)
   end
 
   def createObject(hash)
     className = hash["_class"]
-    raise "no class information" unless className
+    # hashes without a _class key are returned as is
+    return hash unless className
     if @classes[className]
       clazz = @classes[className].instanceClass
     elsif @short_class_names && @classes_flat[className]
@@ -59,6 +70,9 @@ class JsonInstantiator
       raise "class not found: #{className}"
     end
     hash.delete("_class")
+    @ignore_keys.each do |k|
+      hash.delete(k)
+    end
     urefs = []
     hash.keys.each do |k|
       f = eFeature(k, clazz)

data/lib/rgen/instantiator/nodebased_xml_instantiator.rb

@@ -1,157 +1,137 @@
-$:.unshift File.join(File.dirname(__FILE__),"..","..","..","redist","xmlscan","lib")
-
 require 'rgen/metamodel_builder'
 require 'rgen/instantiator/abstract_instantiator'
-require 'xmlscan/namespace'
+require 'nokogiri'
 
 module RGen
 
 module Instantiator
 
 class NodebasedXMLInstantiator < AbstractInstantiator
-	
-	class << self
+  
+  class << self
 
-		# The prune level is the number of parent/children associations which
-		# is kept when the instantiator ascents the XML tree.
-		# If the level is 2, information for the node's children and the childrens'
-		# children will be available as an XMLNodeDescriptor object.
-		# If the level is 0 no pruning will take place, i.e. the whole information
-		# is kept until the end of the instantiation process. 0 is default.
-		def set_prune_level(level)
-			@prune_level = level
-		end
+    # The prune level is the number of parent/children associations which
+    # is kept when the instantiator ascents the XML tree.
+    # If the level is 2, information for the node's children and the childrens'
+    # children will be available as an XMLNodeDescriptor object.
+    # If the level is 0 no pruning will take place, i.e. the whole information
+    # is kept until the end of the instantiation process. 0 is default.
+    def set_prune_level(level)
+      @prune_level = level
+    end
 
-		def prune_level # :nodoc:
-			@prune_level ||= 0
-		end
+    def prune_level # :nodoc:
+      @prune_level ||= 0
+    end
 
-	end
+  end
 
-	class XMLNodeDescriptor
-		attr_reader :namespace, :qtag, :prefix, :tag, :parent, :attributes, :chardata
-		attr_accessor :object, :children
-		
-		def initialize(ns, qtag, prefix, tag, parent, children, attributes)
-			@namespace, @qtag, @prefix, @tag, @parent, @children, @attributes = 
-				ns, qtag, prefix, tag, parent, children, attributes
-			@parent.children << self if @parent
-			@chardata = []
-		end
-	end
-	
-	class XMLScanVisitor
-	    attr_reader :namespaces
-	    
-		include XMLScan::NSVisitor
-	
-		def initialize(inst)
-			@current_attributes = {}
-			@instantiator = inst
-		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 on_stag_end_ns(qname, namespaces)
-		    @namespaces = namespaces
-			if qname =~ /^([^:]+):([^:]+)$/
-				prefix, tag = $1, $2
-			else
-				prefix, tag = nil, qname
-			end
-			@instantiator.start_element(namespaces[prefix], qname, prefix, tag, @current_attributes)
-			@current_attributes = {}
-		end
-		
-		def on_stag_end_empty_ns(qname, namespaces)
-			on_stag_end_ns(qname, namespaces)
-			@instantiator.end_element
-		end
-		
-		def on_etag(name)
-			@instantiator.end_element
-		end
-		
-		def on_chardata(str)
-			@instantiator.on_chardata(str)
-		end
-	end
-	
-	def initialize(env)
-		super
-		@env = env
-		@stack = []
-	end
-	
-	def instantiate_file(file)
-		File.open(file) { |f| parse(f.read)}
-		resolve
-	end
-	
-	def instantiate(text)
-		parse(text)
-		resolve
-	end
-		
-	def parse(src)
-	    @visitor = XMLScanVisitor.new(self)
-		parser = XMLScan::XMLParserNS.new(@visitor)
-	    parser.parse(src)
-		@visitor = nil
-	end	
-		
-	def start_element(ns, qtag, prefix, tag, attributes)
-		node = XMLNodeDescriptor.new(ns, qtag, prefix, tag, @stack[-1], [], attributes)
-		@stack.push node
-		on_descent(node)
-	end
-	
-	def end_element
-		node = @stack.pop
-		on_ascent(node)
-		prune_children(node, self.class.prune_level - 1) if self.class.prune_level > 0
-	end
-	
-	def on_chardata(str)
-		node = @stack.last
-		node.chardata << str
-	end
+  class XMLNodeDescriptor
+    attr_reader :namespace, :qtag, :prefix, :tag, :parent, :attributes, :chardata
+    attr_accessor :object, :children
+    
+    def initialize(ns, qtag, prefix, tag, parent, children, attributes)
+      @namespace, @qtag, @prefix, @tag, @parent, @children, @attributes = 
+        ns, qtag, prefix, tag, parent, children, attributes
+      @parent.children << self if @parent
+      @chardata = []
+    end
+  end
+  
+  class Visitor < Nokogiri::XML::SAX::Document
+    attr_reader :namespaces
+      
+    def initialize(inst)
+      @instantiator = inst
+      @namespaces = {}
+    end
+    
+    def start_element_namespace(tag, attributes, prefix, uri, ns)
+      ns.each{|n| @namespaces[n[0]] = n[1]}
+      attrs = {}
+      attributes.each{|a| attrs[a.prefix ? a.prefix+":"+a.localname : a.localname] = a.value}
+      qname = prefix ? prefix+":"+tag : tag
+      @instantiator.start_element(uri, qname, prefix, tag, attrs) 
+    end
+    
+    def end_element(name)
+      @instantiator.end_element
+    end
+    
+    def characters(str)
+      @instantiator.on_chardata(str)
+    end
+  end
+  
+  def initialize(env)
+    super
+    @env = env
+    @stack = []
+  end
+  
+  def instantiate_file(file)
+    File.open(file) { |f| parse(f.read)}
+    resolve
+  end
+  
+  def instantiate(text)
+    parse(text)
+    resolve
+  end
+    
+  def parse(src)
+    @visitor = Visitor.new(self)
+    parser = Nokogiri::XML::SAX::Parser.new(@visitor)
+    parser.parse(src)
+    @visitor = nil
+  end  
+    
+  def start_element(ns, qtag, prefix, tag, attributes)
+    node = XMLNodeDescriptor.new(ns, qtag, prefix, tag, @stack[-1], [], attributes)
+    @stack.push node
+    on_descent(node)
+  end
+  
+  def end_element
+    node = @stack.pop
+    on_ascent(node)
+    prune_children(node, self.class.prune_level - 1) if self.class.prune_level > 0
+  end
+  
+  def on_chardata(str)
+    node = @stack.last
+    node.chardata << str
+  end
 
-	# This method is called when the XML parser goes down the tree.
-	# An XMLNodeDescriptor +node+ describes the current node.
-	# Implementing classes must overwrite this method.
-	def on_descent(node)
-		raise "Overwrite this method !"
-	end
-	
-	# This method is called when the XML parser goes up the tree.
-	# An XMLNodeDescriptor +node+ describes the current node.
-	# Implementing classes must overwrite this method.
-	def on_ascent(node)
-		raise "Overwrite this method !"
-	end
+  # This method is called when the XML parser goes down the tree.
+  # An XMLNodeDescriptor +node+ describes the current node.
+  # Implementing classes must overwrite this method.
+  def on_descent(node)
+    raise "Overwrite this method !"
+  end
+  
+  # This method is called when the XML parser goes up the tree.
+  # An XMLNodeDescriptor +node+ describes the current node.
+  # Implementing classes must overwrite this method.
+  def on_ascent(node)
+    raise "Overwrite this method !"
+  end
 
-    def namespaces
-      @visitor.namespaces if @visitor
-    end
+  def namespaces
+    @visitor.namespaces if @visitor
+  end
     
-	private
-	
-	def prune_children(node, level)
-		if level == 0
-			node.children = nil
-		else
-			node.children.each { |c| prune_children(c, level-1) }
-		end
-	end					
+  private
+  
+  def prune_children(node, level)
+    if level == 0
+      node.children = nil
+    else
+      node.children.each { |c| prune_children(c, level-1) }
+    end
+  end          
 end
 
 end
 
-end
+end

data/lib/rgen/instantiator/qualified_name_resolver.rb

@@ -6,7 +6,6 @@ module Instantiator
 
 # This is a resolver resolving element identifiers which are qualified names.
 class QualifiedNameResolver
-  include ReferenceResolver
 
   attr_reader :nameAttribute
   attr_reader :separator
@@ -20,6 +19,7 @@ class QualifiedNameResolver
     @elementByQName = {}
     @visitedQName = {}
     @childReferences = {}
+    @resolverDelegate = ReferenceResolver.new(:identifier_resolver => method(:resolveIdentifier))
   end
 
   def resolveIdentifier(qualifiedName)
@@ -57,6 +57,10 @@ class QualifiedNameResolver
     @elementByQName[qualifiedName] ||= nil
   end
 
+  def resolveReferences(unresolvedReferences, problems=[])
+    @resolverDelegate.resolve(unresolvedReferences, :problems => problems)
+  end
+
   private
 
   def allNamedChildren(element)

data/lib/rgen/instantiator/reference_resolver.rb

@@ -2,41 +2,143 @@ module RGen
 
 module Instantiator
 
-# This module is meant to be mixed into a resolver class providing the method +resolveIdentifier+
-module ReferenceResolver
+# The ReferenceResolver can be used to resolve unresolved references, i.e. instances
+# of class UnresolvedReference
+#
+# There are two ways how this can be used:
+#  1. the identifiers and associated model elements are added upfront using +add_identifier+
+#  2. register an :identifier_resolver with the constructor, which will be invoked 
+#     for every unresolved identifier
+#
+class ReferenceResolver
  
   # Instances of this class represent information about not yet resolved references.
-  # This consists of the +element+ and metamodel +featureName+ which hold/is to hold the reference
-  # and the proxy object which is the placeholder for the reference.
-  UnresolvedReference = Struct.new(:element, :featureName, :proxy)
-
-  # tries to resolve the given +unresolvedReferences+
-  # if resolution is successful, the proxy object will be removed
-  # otherwise there will be an error description in +problems+
-  # returns an array of the references which are still unresolved
-  def resolveReferences(unresolvedReferences, problems=[])
-    stillUnresolvedReferences = []
-    unresolvedReferences.each do |ur|
-      target = resolveIdentifier(ur.proxy.targetIdentifier)
-      if target && !target.is_a?(Array)
-        if ur.element.hasManyMethods(ur.featureName)
-          ur.element.removeGeneric(ur.featureName, ur.proxy)
-          ur.element.addGeneric(ur.featureName, target)
+  # This consists of the +element+ and metamodel +feature_name+ which hold/is to hold the 
+  # reference and the +proxy+ object which is the placeholder for the reference.
+  # If the reference could not be resolved because the target type does not match the
+  # feature type, the flag +target_type_error+ will be set.
+  #
+  class UnresolvedReference 
+    attr_reader :feature_name, :proxy
+    attr_accessor :element, :target_type_error
+    def initialize(element, feature_name, proxy)
+      @element = element
+      @feature_name = feature_name
+      @proxy = proxy
+    end
+  end
+
+  # Create a reference resolver, options:
+  #
+  #  :identifier_resolver:
+  #    a proc which is called with an identifier and which should return the associated element
+  #    in case the identifier is not uniq, the proc may return multiple values
+  #    default: lookup element in internal map
+  #
+  def initialize(options={})
+    @identifier_resolver = options[:identifier_resolver]
+    @identifier_map = {}
+  end
+
+  # Add an +identifer+ / +element+ pair which will be used for looking up unresolved identifers
+  def add_identifier(ident, element)
+    map_entry = @identifier_map[ident]
+    if map_entry 
+      if map_entry.is_a?(Array)
+        map_entry << element
+      else
+        @identifier_map[ident] = [map_entry, element]
+      end
+    else 
+      @identifier_map[ident] = element
+    end
+  end
+
+  # Tries to resolve the given +unresolved_refs+. If resolution is successful, the proxy object
+  # will be removed, otherwise there will be an error description in the problems array.
+  # In case the resolved target element's type is not valid for the given feature, the 
+  # +target_type_error+ flag will be set on the unresolved reference.
+  # Returns an array of the references which are still unresolved. Options:
+  # 
+  #  :problems
+  #    an array to which problems will be appended
+  #
+  #  :on_resolve
+  #    a proc which will be called for every sucessful resolution, receives the unresolved
+  #    reference as well as to new target element
+  #
+  #  :use_target_type
+  #    use the expected target type to narrow the set of possible targets 
+  #    (i.e. ignore targets with wrong type)
+  #
+  def resolve(unresolved_refs, options={})
+    problems = options[:problems] || []
+    still_unresolved_refs = []
+    unresolved_refs.each do |ur|
+      if @identifier_resolver
+        target = @identifier_resolver.call(ur.proxy.targetIdentifier)
+      else
+        target = @identifier_map[ur.proxy.targetIdentifier]
+      end
+      target = [target].compact unless target.is_a?(Array)
+      if options[:use_target_type] 
+        feature = ur.element.class.ecore.eAllReferences.find{|r| r.name == ur.feature_name}
+        target = target.select{|e| e.is_a?(feature.eType.instanceClass)}
+      end
+      if target.size == 1
+        refs = ur.element.getGeneric(ur.feature_name)
+        if refs.is_a?(Array) 
+          index = refs.index(ur.proxy)
+          ur.element.removeGeneric(ur.feature_name, ur.proxy)
+          begin
+            ur.element.addGeneric(ur.feature_name, target[0], index)
+            options[:on_resolve] && options[:on_resolve].call(ur, target[0])
+          rescue StandardError => e
+            if is_type_error?(e)
+              ur.element.addGeneric(ur.feature_name, ur.proxy, index)
+              ur.target_type_error = true
+              problems << type_error_message(target[0])
+              still_unresolved_refs << ur
+            else
+              raise
+            end
+          end
         else
-          # this will replace the proxy
-          ur.element.setGeneric(ur.featureName, target)
+          begin
+            # this will replace the proxy
+            ur.element.setGeneric(ur.feature_name, target[0])
+            options[:on_resolve] && options[:on_resolve].call(ur, target[0])
+          rescue StandardError => e
+            if is_type_error?(e)
+              ur.target_type_error = true
+              problems << type_error_message(target[0])
+              still_unresolved_refs << ur
+            else
+              raise
+            end
+          end
         end
-      elsif target
+      elsif target.size > 1
         problems << "identifier #{ur.proxy.targetIdentifier} not uniq"
-        stillUnresolvedReferences << ur
+        still_unresolved_refs << ur
       else
         problems << "identifier #{ur.proxy.targetIdentifier} not found"
-        stillUnresolvedReferences << ur
+        still_unresolved_refs << ur
       end
     end
-    stillUnresolvedReferences
+    still_unresolved_refs
   end   
 
+  private
+
+  def is_type_error?(e)
+    e.message =~ /Can not use a .* where a .* is expected/
+  end
+
+  def type_error_message(target)
+    "invalid target type #{target.class}"
+  end
+
 end
 
 end