puppet 4.10.12-x86-mingw32 → 5.0.0-x86-mingw32

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

@@ -1,156 +0,0 @@
-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

@@ -1,121 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,116 +0,0 @@
-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