puppet 3.6.2-x86-mingw32 → 3.7.0-x86-mingw32

data/lib/puppet/vendor/rgen/lib/rgen/model_builder/reference_resolver.rb

@@ -0,0 +1,156 @@
+require 'rgen/array_extensions'
+
+module RGen
+  
+module ModelBuilder
+
+class ReferenceResolver
+  ResolverJob = Struct.new(:receiver, :reference, :namespace, :string)
+  
+  class ResolverException < Exception
+  end
+
+  class ToplevelNamespace
+    def initialize(ns)
+      raise "Namespace must be an Enumerable" unless ns.is_a?(Enumerable)
+      @ns = ns
+    end
+    def elements
+      @ns
+    end
+  end
+  
+  def initialize
+    @jobs = []
+    @elementName = {}
+  end
+
+  def addJob(job)
+    @jobs << job
+  end
+  
+  def setElementName(element, name)
+    @elementName[element] = name
+  end
+
+  def resolve(ns=[])
+    @toplevelNamespace = ToplevelNamespace.new(ns)
+    (@jobs || []).each_with_index do |job, i|
+      target = resolveReference(job.namespace || @toplevelNamespace, job.string.split("."))
+      raise ResolverException.new("Can not resolve reference #{job.string}") unless target
+      if job.reference.many
+        job.receiver.addGeneric(job.reference.name, target)
+      else
+        job.receiver.setGeneric(job.reference.name, target)
+      end
+    end
+  end
+  
+  private
+  
+  # TODO: if a reference can not be fully resolved, but a prefix can be found,
+  # the exception reported is that its first path element can not be found on
+  # toplevel
+  def resolveReference(namespace, nameParts)
+    element = resolveReferenceDownwards(namespace, nameParts)
+    if element.nil? && parentNamespace(namespace)
+      element = resolveReference(parentNamespace(namespace), nameParts)
+    end
+    element
+  end
+  
+  def resolveReferenceDownwards(namespace, nameParts)
+    firstPart, *restParts = nameParts
+    element = namespaceElementByName(namespace, firstPart)
+    return nil unless element
+    if restParts.size > 0
+      resolveReferenceDownwards(element, restParts)
+    else
+      element
+    end
+  end
+  
+  def namespaceElementByName(namespace, name)
+    @namespaceElementsByName ||= {}
+    return @namespaceElementsByName[namespace][name] if @namespaceElementsByName[namespace]
+    hash = {}
+    namespaceElements(namespace).each do |e|
+      raise ResolverException.new("Multiple elements named #{elementName(e)} found in #{nsToS(namespace)}") if hash[elementName(e)]
+      hash[elementName(e)] = e if elementName(e)
+    end
+    @namespaceElementsByName[namespace] = hash
+    hash[name]
+  end
+  
+  def parentNamespace(namespace)
+    if namespace.class.respond_to?(:ecore)
+      parents = elementParents(namespace)
+      raise ResolverException.new("Element #{nsToS(namespace)} has multiple parents") \
+        if parents.size > 1
+      parents.first || @toplevelNamespace
+    else
+      nil
+    end
+  end
+  
+  def namespaceElements(namespace)
+    if namespace.is_a?(ToplevelNamespace)
+      namespace.elements
+    elsif namespace.class.respond_to?(:ecore)
+      elementChildren(namespace)
+    else
+      raise ResolverException.new("Element #{nsToS(namespace)} can not be used as a namespace")
+    end
+  end
+  
+  def nsToS(namespace)
+    if namespace.is_a?(ToplevelNamespace)
+      "toplevel namespace"
+    else
+      result = namespace.class.name    
+      result += ":\"#{elementName(namespace)}\"" if elementName(namespace)
+      result
+    end
+  end
+  
+  def elementName(element)
+    @elementName[element]
+  end
+  
+  def elementChildren(element)
+    @elementChildren ||= {}
+    return @elementChildren[element] if @elementChildren[element]
+    children = containmentRefs(element).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 = parentRefs(element).collect do |r|
+      element.getGeneric(r.name)
+    end.flatten.compact
+    @elementParents[element] = parents
+  end  
+  
+  def containmentRefs(element)
+    @containmentRefs ||= {}
+    @containmentRefs[element.class] ||= eAllReferences(element).select{|r| r.containment}
+  end
+  
+  def parentRefs(element)
+    @parentRefs ||= {}
+    @parentRefs[element.class] ||= eAllReferences(element).select{|r| r.eOpposite && r.eOpposite.containment}
+  end
+
+  def eAllReferences(element)
+    @eAllReferences ||= {}
+    @eAllReferences[element.class] ||= element.class.ecore.eAllReferences
+  end
+end
+
+end
+
+end

data/lib/puppet/vendor/rgen/lib/rgen/serializer/json_serializer.rb

@@ -0,0 +1,121 @@
+module RGen
+
+module Serializer
+
+class JsonSerializer
+
+  def initialize(writer, opts={})
+    @writer = writer
+    @elementIdentifiers = {}
+    @identAttrName = opts[:identAttrName] || "name"
+    @separator = opts[:separator] || "/"
+    @leadingSeparator = opts.has_key?(:leadingSeparator) ? opts[:leadingSeparator] : true 
+    @featureFilter = opts[:featureFilter]
+    @identifierProvider = opts[:identifierProvider]
+  end
+
+  def elementIdentifier(element)
+    ident = @identifierProvider && @identifierProvider.call(element)
+    ident || (element.is_a?(RGen::MetamodelBuilder::MMProxy) && element.targetIdentifier) || qualifiedElementName(element)
+  end
+
+  # simple identifier calculation based on qualified names
+  # prerequisits:
+  # * containment relations must be bidirectionsl
+  # * local name stored in single attribute +@identAttrName+ for all classes
+  #
+  def qualifiedElementName(element)
+    return @elementIdentifiers[element] if @elementIdentifiers[element]
+    localIdent = ((element.respond_to?(@identAttrName) && element.getGeneric(@identAttrName)) || "").strip
+    parentRef = element.class.ecore.eAllReferences.select{|r| r.eOpposite && r.eOpposite.containment}.first
+    parent = parentRef && element.getGeneric(parentRef.name)
+    if parent
+      if localIdent.size > 0
+        parentIdent = qualifiedElementName(parent)
+        result = parentIdent + @separator + localIdent
+      else
+        result = qualifiedElementName(parent)
+      end
+    else
+      result = (@leadingSeparator ? @separator : "") + localIdent
+    end
+    @elementIdentifiers[element] = result
+  end
+
+  def serialize(elements)
+    if elements.is_a?(Array)
+      write("[ ")
+      elements.each_with_index do |e, i| 
+        serializeElement(e)
+        write(",\n") unless i == elements.size-1 
+      end
+      write("]")
+    else
+      serializeElement(elements)
+    end
+  end
+
+  def serializeElement(element, indent="")
+    write(indent + "{ \"_class\": \""+element.class.ecore.name+"\"")
+    element.class.ecore.eAllStructuralFeatures.each do |f|
+      next if f.derived
+      value = element.getGeneric(f.name)
+      unless value == [] || value.nil? || 
+        (f.is_a?(RGen::ECore::EReference) && f.eOpposite && f.eOpposite.containment) || 
+        (@featureFilter && !@featureFilter.call(f)) 
+        write(", ")
+        writeFeature(f, value, indent)
+      end
+    end
+    write(" }")
+  end
+
+  def writeFeature(feat, value, indent)
+    write("\""+feat.name+"\": ")
+    if feat.is_a?(RGen::ECore::EAttribute)
+      if value.is_a?(Array)
+        write("[ "+value.collect{|v| attributeValue(v, feat)}.join(", ")+" ]")
+      else
+        write(attributeValue(value, feat))
+      end
+    elsif !feat.containment
+      if value.is_a?(Array)
+        write("[ "+value.collect{|v| "\""+elementIdentifier(v)+"\""}.join(", ")+" ]")
+      else
+        write("\""+elementIdentifier(value)+"\"")
+      end
+    else
+      if value.is_a?(Array)
+        write("[ \n")
+        value.each_with_index do |v, i|
+          serializeElement(v, indent+"  ")
+          write(",\n") unless i == value.size-1
+        end
+        write("]")
+      else
+        write("\n")
+        serializeElement(value, indent+"  ")
+      end
+    end
+  end
+
+  def attributeValue(value, a)
+    if a.eType == RGen::ECore::EString || a.eType.is_a?(RGen::ECore::EEnum)
+      "\""+value.to_s.gsub('\\','\\\\\\\\').gsub('"','\\"').gsub("\n","\\n").gsub("\r","\\r").
+        gsub("\t","\\t").gsub("\f","\\f").gsub("\b","\\b")+"\""
+    else
+      value.to_s
+    end
+  end
+   
+  private
+
+  def write(s)
+    @writer.write(s) 
+  end
+end
+
+end
+
+end
+

data/lib/puppet/vendor/rgen/lib/rgen/serializer/opposite_reference_filter.rb

@@ -0,0 +1,18 @@
+module RGen
+
+module Serializer
+
+# Filters refereences with an eOpposite:
+#  1. containment references are always preferred
+#  2. at a 1-to-n reference the 1-reference is always preferred
+#  3. otherwise the reference with the name in string sort order before the opposite's name is prefereed
+# 
+OppositeReferenceFilter = proc do |features|
+  features.reject{|f| f.is_a?(RGen::ECore::EReference) && !f.containment && f.eOpposite &&
+    (f.eOpposite.containment || (f.many && !f.eOpposite.many) || (!(!f.many && f.eOpposite.many) && (f.name < f.eOpposite.name)))}
+end
+
+end
+
+end
+

data/lib/puppet/vendor/rgen/lib/rgen/serializer/qualified_name_provider.rb

@@ -0,0 +1,47 @@
+module RGen
+
+module Serializer
+
+# simple identifier calculation based on qualified names.
+# as a prerequisit, elements must have a local name stored in single attribute +attribute_name+.
+# there may be classes without the name attribute though and there may be elements without a
+# local name. in both cases the element will have the same qualified name as its container.
+#
+class QualifiedNameProvider
+
+  def initialize(options={})
+    @qualified_name_cache = {}
+    @attribute_name = options[:attribute_name] || "name"
+    @separator = options[:separator] || "/"
+    @leading_separator = options.has_key?(:leading_separator) ? options[:leading_separator] : true 
+  end
+
+  def identifier(element)
+    if element.is_a?(RGen::MetamodelBuilder::MMProxy) 
+      element.targetIdentifier
+    else
+      qualified_name(element)
+    end
+  end
+
+  def qualified_name(element)
+    return @qualified_name_cache[element] if @qualified_name_cache[element]
+    local_ident = ((element.respond_to?(@attribute_name) && element.getGeneric(@attribute_name)) || "").strip
+    parent = element.eContainer
+    if parent
+      if local_ident.size > 0
+        result = qualified_name(parent) + @separator + local_ident
+      else
+        result = qualified_name(parent)
+      end
+    else
+      result = (@leading_separator ? @separator : "") + local_ident
+    end
+    @qualified_name_cache[element] = result
+  end
+end
+
+end
+
+end
+

data/lib/puppet/vendor/rgen/lib/rgen/serializer/xmi11_serializer.rb

@@ -0,0 +1,116 @@
+require 'rgen/serializer/xml_serializer'
+
+module RGen
+
+module Serializer
+
+class XMI11Serializer < XMLSerializer
+
+  def initialize(file)
+    super
+    @namespacePrefix = ""
+    @contentLevelElements = []
+  end
+  
+  def setNamespace(shortcut, url)
+    @namespaceShortcut = shortcut
+    @namespaceUrl = url
+    @namespacePrefix = shortcut+":"
+  end
+  
+  def serialize(rootElement, headerInfo=nil)
+    attrs = []
+    attrs << ['xmi.version', "1.1"]
+    attrs << ['xmlns:'+@namespaceShortcut, @namespaceUrl] if @namespaceUrl
+    attrs << ['timestamp', Time.now.to_s]
+    startTag("XMI", attrs)
+    if headerInfo
+      startTag("XMI.header")
+      writeHeaderInfo(headerInfo)
+      endTag("XMI.header")
+    end
+    startTag("XMI.content")
+    @contentLevelElements = []
+    writeElement(rootElement)
+    # write remaining toplevel elements, each of which could have
+    # more toplevel elements as childs
+    while @contentLevelElements.size > 0
+      writeElement(@contentLevelElements.shift)
+    end
+    endTag("XMI.content") 
+    endTag("XMI") 
+  end
+  
+  def writeHeaderInfo(hash)
+    hash.each_pair do |k,v|
+      tag = "XMI." + k.to_s
+      startTag(tag)
+      if v.is_a?(Hash)
+        writeHeaderInfo(v)
+      else
+        writeText(v.to_s)
+      end
+      endTag(tag)
+    end
+  end
+  
+  def writeElement(element)
+    tag = @namespacePrefix + element.class.ecore.name
+    attrs = attributeValues(element)
+    startTag(tag, attrs)
+    containmentReferences(element).each do |r|
+      roletag = @namespacePrefix + r.eContainingClass.name + "." + r.name
+      targets = element.getGeneric(r.name)
+      targets = [ targets ] unless targets.is_a?(Array)
+      targets.compact!
+      next if targets.empty?
+      startTag(roletag)
+      targets.each do |t|
+        if xmiLevel(t) == :content
+          @contentLevelElements << t
+        else
+          writeElement(t)
+        end
+      end
+      endTag(roletag)
+    end
+    endTag(tag)
+  end
+
+  def attributeValues(element)
+    result = [["xmi.id", xmiId(element)]]
+    eAllAttributes(element).select{|a| !a.derived}.each do |a|
+      val = element.getGeneric(a.name)
+      result << [a.name, val] unless val.nil? || val == ""
+    end
+    eAllReferences(element).each do |r|
+      next if r.derived
+      next if r.containment
+      next if r.eOpposite && r.eOpposite.containment && xmiLevel(element).nil?
+      next if r.eOpposite && r.many && !r.eOpposite.many
+      targetElements = element.getGenericAsArray(r.name)
+      targetElements.compact!
+      val = targetElements.collect{|te| xmiId(te)}.compact.join(' ')
+      result << [r.name, val] unless val == ""
+    end
+    result  
+  end
+  
+  def xmiId(element)
+    if element.respond_to?(:_xmi_id) && element._xmi_id
+      element._xmi_id.to_s
+    else
+      element.object_id.to_s
+    end
+  end
+  
+  def xmiLevel(element)
+    return nil unless element.respond_to?(:_xmi_level) 
+    element._xmi_level
+  end
+  
+end
+
+end
+
+end