puppet 4.10.12 → 5.0.0

data/lib/puppet/vendor/rgen/lib/rgen/metamodel_builder/mm_multiple.rb

@@ -1,23 +0,0 @@
-
-module RGen
-
-module MetamodelBuilder
-
-def self.MMMultiple(*superclasses)
-  c = Class.new(MMBase)
-  class << c
-    attr_reader :multiple_superclasses
-  end
-  c.instance_variable_set(:@multiple_superclasses, superclasses)
-  superclasses.collect{|sc| sc.ancestors}.flatten.
-    reject{|m| m.is_a?(Class)}.each do |arg|
-      c.instance_eval do
-        include arg
-      end
-  end
-  return c
-end
-
-end
-
-end

data/lib/puppet/vendor/rgen/lib/rgen/metamodel_builder/module_extension.rb

@@ -1,42 +0,0 @@
-require 'rgen/ecore/ecore_interface'
-require 'rgen/metamodel_builder/intermediate/annotation'
-
-module RGen
-
-module MetamodelBuilder
-
-# This module is used to extend modules which should be
-# part of RGen metamodels
-module ModuleExtension
-  include RGen::ECore::ECoreInterface
-  
-  def annotation(hash)
-    _annotations << Intermediate::Annotation.new(hash)
-  end
-  
-  def _annotations
-    @_annotations ||= []
-  end
-
-  def _constantOrder
-    @_constantOrder ||= []
-  end
-  
-  def final_method(m)
-    @final_methods ||= []
-    @final_methods << m
-  end
-  
-  def method_added(m)
-    raise "Method #{m} can not be redefined" if @final_methods && @final_methods.include?(m)
-  end
-
-  def self.extended(m)
-    MetamodelBuilder::ConstantOrderHelper.moduleCreated(m)
-  end
-
-end
-
-end
-
-end

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

@@ -1,32 +0,0 @@
-require 'rgen/model_builder/builder_context'
-require 'rgen/util/method_delegation'
-#require 'ruby-prof'
-
-module RGen
-  
-module ModelBuilder
-
-  def self.build(package, env=nil, builderMethodsModule=nil, &block)
-    resolver = ReferenceResolver.new
-    bc = BuilderContext.new(package, builderMethodsModule, resolver, env)
-    contextModule = eval("Module.nesting", block.binding).first
-    Util::MethodDelegation.registerDelegate(bc, contextModule, "const_missing")
-    BuilderContext.currentBuilderContext = bc
-    begin
-    #RubyProf.start
-      bc.instance_eval(&block)
-    #prof = RubyProf.stop
-    #File.open("profile_flat.txt","w+") do |f|
-    #  RubyProf::FlatPrinter.new(prof).print(f, 0)
-    # end
-    ensure
-      BuilderContext.currentBuilderContext = nil
-    end
-    Util::MethodDelegation.unregisterDelegate(bc, contextModule, "const_missing")
-    #puts "Resolving..."
-    resolver.resolve(bc.toplevelElements)
-    bc.toplevelElements
-  end    
-end
-
-end

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

@@ -1,334 +0,0 @@
-require 'rgen/ecore/ecore_ext'
-require 'rgen/model_builder/reference_resolver'
-
-module RGen
-  
-module ModelBuilder
-  
-class BuilderContext
-  attr_reader :toplevelElements
-  
-  def initialize(package, extensionsModule, resolver, env=nil)
-    package = package.ecore unless package.is_a?(RGen::ECore::EPackage)
-    raise "First argument must be a metamodel package" \
-      unless package.is_a?(RGen::ECore::EPackage)
-    @rootPackage, @env = package, env
-    @commandResolver = CommandResolver.new(package, extensionsModule, self)
-    @package = @rootPackage
-    @resolver = resolver
-    @contextStack = []
-    @toplevelElements = []
-    @helperNames = {}
-  end
-  
-  def const_missing_delegated(delegator, const)
-    ConstPathElement.new(const, self)
-  end
-  
-  # in Ruby 1.9.0 and 1.9.1 #instance_eval looks up constants in the calling scope
-  # that's why const_missing needs to be prepared in BuilderContext, too 
-  class << self
-    def currentBuilderContext=(bc)
-     @@currentBuilderContext = bc
-    end
-
-    def const_missing(name)
-      if @@currentBuilderContext
-        ConstPathElement.new(name, @@currentBuilderContext)
-      else
-        super
-      end
-    end
-  end
-
-  class CommandResolver
-    def initialize(rootPackage, extensionsModule, builderContext)
-      @extensionFactory = ExtensionContainerFactory.new(rootPackage, extensionsModule, builderContext)
-      @packageResolver = PackageResolver.new(rootPackage, @extensionFactory)
-      @resolveCommand = {}
-    end
-    
-    def resolveCommand(cmd, parentPackage)
-      return @resolveCommand[[parentPackage, cmd]] if @resolveCommand.has_key?([parentPackage, cmd])
-      package = @packageResolver.packageByCommand(parentPackage, cmd)
-      result = nil
-	    if package
-  	    extensionContainer = @extensionFactory.extensionContainer(package)
-  	    if extensionContainer.respond_to?(cmd)
-          result = extensionContainer
-        else
-    	    className = cmd.to_s[0..0].upcase + cmd.to_s[1..-1]
-    	    result = package.eClasses.find{|c| c.name == className}
-        end
-      end
-      @resolveCommand[[parentPackage, cmd]] = [package, result]
-	  end
-  end
-  
-  def method_missing(m, *args, &block)
-    package, classOrContainer = @commandResolver.resolveCommand(m, @package)
-    return super if package.nil?
-    return classOrContainer.send(m, *args, &block) if classOrContainer.is_a?(ExtensionContainerFactory::ExtensionContainer)
-    eClass = classOrContainer
-    nameArg, argHash = self.class.processArguments(args)
-    internalName = nameArg || argHash[:name]
-    argHash[:name] ||= nameArg if nameArg && self.class.hasNameAttribute(eClass)
-    resolverJobs, asRole, helperName = self.class.filterArgHash(argHash, eClass)
-    element = eClass.instanceClass.new(argHash)
-    @resolver.setElementName(element, internalName)
-    @env << element if @env
-    contextElement = @contextStack.last
-    if contextElement
-      self.class.associateWithContextElement(element, contextElement, asRole)
-    else
-      @toplevelElements << element
-    end
-    resolverJobs.each do |job|
-      job.receiver = element
-      job.namespace = contextElement
-      @resolver.addJob(job)
-    end
-    # process block
-    if block
-      @contextStack.push(element)
-      @package, oldPackage = package, @package
-      instance_eval(&block)
-      @package = oldPackage
-      @contextStack.pop
-    end
-    element
-  end
-  
-  def _using(constPathElement, &block)
-    @package, oldPackage = 
-      self.class.resolvePackage(@package, @rootPackage, constPathElement.constPath), @package
-    instance_eval(&block)
-    @package = oldPackage
-  end
-  
-  def _context(depth=1)
-    @contextStack[-depth]
-  end
-
-  class ExtensionContainerFactory
-    
-    class ExtensionContainer
-      def initialize(builderContext)
-        @builderContext = builderContext
-      end
-      def method_missing(m, *args, &block)
-        @builderContext.send(m, *args, &block)
-      end
-    end
-    
-    def initialize(rootPackage, extensionsModule, builderContext)
-      @rootPackage, @extensionsModule, @builderContext = rootPackage, extensionsModule, builderContext
-      @extensionContainer = {}
-    end
-    
-    def moduleForPackage(package)
-      qName = package.qualifiedName
-      rqName = @rootPackage.qualifiedName
-      raise "Package #{qName} is not contained within #{rqName}" unless qName.index(rqName) == 0
-      path = qName.sub(rqName,'').split('::')
-      path.shift if path.first == ""
-      mod = @extensionsModule
-      path.each do |p|
-        if mod && mod.const_defined?(p)
-          mod = mod.const_get(p)
-        else
-          mod = nil
-          break
-        end
-      end
-      mod
-    end
-    
-    def extensionContainer(package)
-      return @extensionContainer[package] if @extensionContainer[package]
-      container = ExtensionContainer.new(@builderContext)
-      extensionModule = moduleForPackage(package)
-      container.extend(extensionModule) if extensionModule
-      @extensionContainer[package] = container
-    end
-  end
-  
-  class PackageResolver
-    def initialize(rootPackage, extensionFactory)
-      @rootPackage = rootPackage
-      @extensionFactory = extensionFactory
-      @packageByCommand = {}
-    end
-    
-    def packageByCommand(contextPackage, name)
-      return @packageByCommand[[contextPackage, name]] if @packageByCommand.has_key?([contextPackage, name])
-      if @extensionFactory.extensionContainer(contextPackage).respond_to?(name)
-        result = contextPackage
-      else
-        className = name.to_s[0..0].upcase + name.to_s[1..-1]
-        eClass = contextPackage.eClasses.find{|c| c.name == className}
-        if eClass
-          result = contextPackage
-        elsif contextPackage != @rootPackage
-          result = packageByCommand(contextPackage.eSuperPackage, name)
-        else
-          result = nil
-        end
-      end
-      @packageByCommand[[contextPackage, name]] = result
-    end
-  end
-  
-  class ConstPathElement < Module
-    def initialize(name, builderContext, parent=nil)
-      @name = name.to_s
-      @builderContext = builderContext
-      @parent = parent
-    end
-    
-    def const_missing(const)
-      ConstPathElement.new(const, @builderContext, self)
-    end
-    
-    def method_missing(m, *args, &block)
-      @builderContext._using(self) do
-        send(m, *args, &block)
-      end
-    end
-    
-    def constPath
-      if @parent
-        @parent.constPath << @name
-      else
-        [@name]
-      end
-    end
-  end
-
-  # helper methods put in the class object to be out of the way of 
-  # method evaluation in the builder context
-  class << self
-    class PackageNotFoundException < Exception
-    end
-  
-    def resolvePackage(contextPackage, rootPackage, path)
-      begin
-        return resolvePackageDownwards(contextPackage, path)
-      rescue PackageNotFoundException
-        if contextPackage.eSuperPackage && contextPackage != rootPackage
-          return resolvePackage(contextPackage.eSuperPackage, rootPackage, path)
-        else
-          raise
-        end
-      end
-    end
-  
-    def resolvePackageDownwards(contextPackage, path)
-      first, *rest = path
-      package = contextPackage.eSubpackages.find{|p| p.name == first}
-      raise PackageNotFoundException.new("Could not resolve package: #{first} is not a subpackage of #{contextPackage.name}") unless package
-      if rest.empty?
-        package 
-      else
-        resolvePackageDownwards(package, rest)
-      end
-    end
-    
-    def processArguments(args)
-      unless (args.size == 2 && args.first.is_a?(String) && args.last.is_a?(Hash)) ||
-        (args.size == 1 && (args.first.is_a?(String) || args.first.is_a?(Hash))) ||
-        args.size == 0
-        raise "Provide a Hash to set feature values, " +
-          "optionally the first argument may be a String specifying " + 
-          "the value of the \"name\" attribute."
-      end
-      if args.last.is_a?(Hash)
-        argHash = args.last
-      else
-        argHash = {}
-      end
-      nameArg = args.first if args.first.is_a?(String)
-      [nameArg, argHash]
-    end
-    
-    def filterArgHash(argHash, eClass)
-      resolverJobs = []
-      asRole, helperName = nil, nil
-      refByName = {}
-      eAllReferences(eClass).each {|r| refByName[r.name] = r}
-      argHash.each_pair do |k,v|
-        if k == :as
-          asRole = v
-          argHash.delete(k)
-        elsif k == :name && !hasNameAttribute(eClass)
-          helperName = v          
-          argHash.delete(k)
-        elsif v.is_a?(String)
-          ref = refByName[k.to_s]#eAllReferences(eClass).find{|r| r.name == k.to_s}
-          if ref
-            argHash.delete(k)
-            resolverJobs << ReferenceResolver::ResolverJob.new(nil, ref, nil,  v)
-          end
-        elsif v.is_a?(Array)
-          ref = refByName[k.to_s] #eAllReferences(eClass).find{|r| r.name == k.to_s}
-          ref && v.dup.each do |e|
-            if e.is_a?(String)
-              v.delete(e)
-              resolverJobs << ReferenceResolver::ResolverJob.new(nil, ref, nil, e)
-            end
-          end
-        end
-      end
-      [ resolverJobs, asRole, helperName ]
-    end
-    
-    def hasNameAttribute(eClass)
-      @hasNameAttribute ||= {}
-      @hasNameAttribute[eClass] ||= eClass.eAllAttributes.any?{|a| a.name == "name"}
-    end
-  
-    def eAllReferences(eClass)
-      @eAllReferences ||= {}
-      @eAllReferences[eClass] ||= eClass.eAllReferences
-    end
-    
-    def containmentRefs(contextClass, eClass)
-      @containmentRefs ||= {}
-      @containmentRefs[[contextClass, eClass]] ||=
-        eAllReferences(contextClass).select do |r| 
-          r.containment && (eClass.eAllSuperTypes << eClass).include?(r.eType)
-        end
-    end
-  
-    def associateWithContextElement(element, contextElement, asRole)
-      return unless contextElement
-      contextClass = contextElement.class.ecore
-      if asRole
-        asRoleRef = eAllReferences(contextClass).find{|r| r.name == asRole.to_s}
-        raise "Context class #{contextClass.name} has no reference named #{asRole}" unless asRoleRef
-        ref = asRoleRef
-      else
-        possibleContainmentRefs = containmentRefs(contextClass, element.class.ecore)
-        if possibleContainmentRefs.size == 1
-          ref = possibleContainmentRefs.first
-        elsif possibleContainmentRefs.size == 0
-          raise "Context class #{contextClass.name} can not contain a #{element.class.ecore.name}"
-        else
-          raise "Context class #{contextClass.name} has several containment references to a #{element.class.ecore.name}." +
-            " Clearify using \":as => <role>\""
-        end
-      end
-      if ref.many
-        contextElement.addGeneric(ref.name, element)
-      else
-        contextElement.setGeneric(ref.name, element)
-      end
-    end
-    
-  end
-  
-end
-
-end
-  
-end

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

@@ -1,225 +0,0 @@
-require 'rgen/array_extensions'
-require 'rgen/ecore/ecore_ext'
-
-module RGen
-  
-module ModelBuilder
-
-class ModelSerializer
-  
-  def initialize(writable, rootPackage)
-    @writable = writable
-    @currentPackage = rootPackage
-    @qualifiedElementName = {}
-    @internalElementName = {}
-    @relativeQualifiedElementName = {}
-  end
-  
-  def serialize(elements)
-    calcQualifiedElementNames(elements)
-    unifyQualifiedElementNames
-    elements = [elements] unless elements.is_a?(Enumerable)
-    elements.each do |e|
-      serializeElement(e)
-    end
-  end
-  
-  private
-  
-  def serializeElement(element, viaRef=nil, namePath=[], indent=0)
-    className = element.class.ecore.name
-    cmd = className[0..0].downcase+className[1..-1]
-    args = ["\"#{@internalElementName[element]}\""]
-    namePath = namePath + [@internalElementName[element]]
-    childs = [] 
-    eAllStructuralFeatures(element).each do |f|
-      next if f.derived
-      if f.is_a?(RGen::ECore::EAttribute)
-        next if f.name == "name" && element.name == @internalElementName[element]
-        val = element.getGeneric(f.name)
-        #puts f.defaultValue.inspect if f.name == "isRoot"
-        args << ":#{f.name} => #{serializeAttribute(val)}" unless val == f.defaultValue || val.nil?
-      elsif !f.containment
-        next if f.eOpposite && f.eOpposite == viaRef
-        val = element.getGeneric(f.name)
-        refString = serializeReference(element, f, val)
-        args << ":#{f.name} => #{refString}" if refString
-      else
-        cs = element.getGeneric(f.name)
-        refString = nil
-        if cs.is_a?(Array)
-          cs.compact!
-          rcs = cs.select{|c| serializeChild?(c, namePath)}
-          childs << [f, rcs] unless rcs.empty?
-          refString = serializeReference(element, f, cs-rcs)
-        else
-          if cs && serializeChild?(cs, namePath)
-            childs << [f, [cs]]
-          else
-            refString = serializeReference(element, f, cs)
-          end
-        end
-        args << ":#{f.name} => #{refString}" if refString
-      end
-    end
-
-    args << ":as => :#{viaRef.name}" if viaRef && containmentRefs(viaRef.eContainingClass, element.class.ecore).size > 1
-    cmd = elementPackage(element)+"."+cmd if elementPackage(element).size > 0
-    @writable.write "  " * indent + cmd + " " + args.join(", ")
-    if childs.size > 0
-      @writable.write " do\n"
-      oldPackage, @currentPackage = @currentPackage, element.class.ecore.ePackage
-      childs.each do |pair|
-        f, cs = pair
-        cs.each {|c| serializeElement(c, f, namePath, indent+1) }
-      end
-      @currentPackage = oldPackage
-      @writable.write "  " * indent + "end\n"
-    else
-      @writable.write "\n"
-    end
-  end
-  
-  def serializeChild?(child, namePath)
-    @qualifiedElementName[child][0..-2] == namePath
-  end
-
-  def serializeAttribute(value)
-    if value.is_a?(String)
-      "\"#{value.gsub("\"","\\\"")}\""
-    elsif value.is_a?(Symbol)
-      ":#{value}"
-    elsif value.nil?
-      "nil"
-    else
-      value.to_s
-    end
-  end
-  
-  def serializeReference(element, ref, value)
-    if value.is_a?(Array)
-      value = value.compact
-      value = value.select{|v| compareWithOppositeReference(ref, element, v) > 0} if ref.eOpposite
-      qualNames = value.collect do |v|
-        relativeQualifiedElementName(v, element).join(".")
-      end
-      !qualNames.empty? && ("[" + qualNames.collect { |v| "\"#{v}\"" }.join(", ") + "]")
-    elsif value && (!ref.eOpposite || compareWithOppositeReference(ref, element, value) > 0)
-      qualName = relativeQualifiedElementName(value, element).join(".")
-      ("\"#{qualName}\"")        
-    end
-  end
-  
-  # descide which part of a bidirectional reference get serialized
-  def compareWithOppositeReference(ref, element, target)
-    result = 0
-    # first try to make the reference from the many side to the one side
-    result = -1 if ref.many && !ref.eOpposite.many
-    result = 1 if !ref.many && ref.eOpposite.many
-    return result if result != 0
-    # for 1:1 or many:many perfer, shorter references
-    result = relativeQualifiedElementName(element, target).size <=> 
-      relativeQualifiedElementName(target, element).size
-    return result if result != 0
-    # there just needs to be a descision, use class name or object_id
-    result = element.class.name <=> target.class.name
-    return result if result != 0
-    element.object_id <=> target.object_id    
-  end
-
-  def elementPackage(element)
-    @elementPackage ||= {}
-    return @elementPackage[element] if @elementPackage[element]
-    eNames = element.class.ecore.ePackage.qualifiedName.split("::")
-    rNames = @currentPackage.qualifiedName.split("::")
-    while eNames.first == rNames.first && !eNames.first.nil?
-      eNames.shift
-      rNames.shift
-    end
-    @elementPackage[element] = eNames.join("::")
-  end
-  
-  def relativeQualifiedElementName(element, context)
-    return @relativeQualifiedElementName[[element, context]] if @relativeQualifiedElementName[[element, context]]
-    # elements which are not in the @qualifiedElementName Hash are not in the scope
-    # of this serialization and will be ignored
-    return [] if element.nil? || @qualifiedElementName[element].nil?
-    return [] if context.nil? || @qualifiedElementName[context].nil?
-    eNames = @qualifiedElementName[element].dup
-    cNames = @qualifiedElementName[context].dup
-    while eNames.first == cNames.first && eNames.size > 1
-      eNames.shift
-      cNames.shift
-    end
-    @relativeQualifiedElementName[[element, context]] = eNames
-  end
-
-  def calcQualifiedElementNames(elements, prefix=[], takenNames=[])
-    elements = [elements] unless elements.is_a?(Array)
-    elements.compact!
-    elements.each do |element|
-      qualifiedNamePath = prefix + [calcInternalElementName(element, takenNames)]
-      @qualifiedElementName[element] ||= []
-      @qualifiedElementName[element] << qualifiedNamePath
-      takenChildNames = []
-      eAllStructuralFeatures(element).each do |f|
-        if f.is_a?(RGen::ECore::EReference) && f.containment
-          childs = element.getGeneric(f.name)
-          calcQualifiedElementNames(childs, qualifiedNamePath, takenChildNames)
-        end
-      end
-    end
-  end
-  
-  def unifyQualifiedElementNames
-    @qualifiedElementName.keys.each do |k|
-      @qualifiedElementName[k] = @qualifiedElementName[k].sort{|a,b| a.size <=> b.size}.first    
-    end
-  end
-
-  def calcInternalElementName(element, takenNames)
-    return @internalElementName[element] if @internalElementName[element]
-    name = if element.respond_to?(:name) && element.name && !element.name.empty?
-        element.name
-      else
-        nextElementHelperName(element)
-      end
-    while takenNames.include?(name)
-      name = nextElementHelperName(element)
-    end
-    takenNames << name
-    @internalElementName[element] = name 
-  end
-  
-  def nextElementHelperName(element)
-    eClass = element.class.ecore
-    @nextElementNameId ||= {}
-    @nextElementNameId[eClass] ||= 1
-    result = "_#{eClass.name}#{@nextElementNameId[eClass]}"
-    @nextElementNameId[eClass] += 1
-    result
-  end
-
-  def eAllStructuralFeatures(element)
-    @eAllStructuralFeatures ||= {}
-    @eAllStructuralFeatures[element.class] ||= element.class.ecore.eAllStructuralFeatures
-  end
-    
-  def eAllReferences(eClass)
-    @eAllReferences ||= {}
-    @eAllReferences[eClass] ||= eClass.eAllReferences
-  end
-    
-  def containmentRefs(contextClass, eClass)
-    @containmentRefs ||= {}
-    @containmentRefs[[contextClass, eClass]] ||=
-      eAllReferences(contextClass).select do |r| 
-        r.containment && (eClass.eAllSuperTypes << eClass).include?(r.eType)
-      end
-  end
-
-end
-
-end
-
-end