puppet 4.10.0 → 5.0.0

data/lib/puppet/vendor/rgen/lib/rgen/ecore/ecore_interface.rb

@@ -1,47 +0,0 @@
-module RGen
-
-module ECore
-
-# Mixin to provide access to the ECore model describing a Ruby class or module
-# built using MetamodelBuilder.
-# The module should be used to +extend+ a class or module, i.e. to make its
-# methods class methods.
-# 
-module ECoreInterface
-  
-  # This method will lazily build to ECore model element belonging to the calling
-  # class or module using RubyToECore.
-  # Alternatively, the ECore model element can be provided up front. This is used
-  # when the Ruby metamodel classes and modules are created from ECore.
-  # 
-  def ecore
-    if defined?(@ecore)
-      @ecore
-    else
-      unless defined?(@@transformer)
-        require 'rgen/ecore/ruby_to_ecore'
-        @@transformer = RubyToECore.new
-      end
-      @@transformer.trans(self)
-    end
-  end  
-
-  # This method can be used to clear the ecore cache after the metamodel classes
-  # or modules have been changed; the ecore model will be recreated on next access
-  # to the +ecore+ method
-  # Beware, the ecore cache is global, i.e. for all metamodels.
-  #
-  def self.clear_ecore_cache
-    require 'rgen/ecore/ruby_to_ecore'
-    @@transformer = RubyToECore.new
-  end
-
-  def _set_ecore_internal(ecore) # :nodoc:
-    @ecore = ecore
-  end
-
-end
-
-end
-
-end

data/lib/puppet/vendor/rgen/lib/rgen/ecore/ecore_to_ruby.rb

@@ -1,167 +0,0 @@
-require 'rgen/ecore/ecore'
-
-module RGen
-  
-module ECore
-
-class ECoreToRuby
-  
-  def initialize
-    @modules = {}
-    @classifiers = {}
-    @features_added = {}
-    @in_create_module = false
-  end
-
-  def create_module(epackage)
-    return @modules[epackage] if @modules[epackage]
-    
-    top = (@in_create_module == false)
-    @in_create_module = true
-
-    m = Module.new do
-      extend RGen::MetamodelBuilder::ModuleExtension
-    end
-    @modules[epackage] = m
-
-    epackage.eSubpackages.each{|p| create_module(p)}
-    m._set_ecore_internal(epackage)
-
-    create_module(epackage.eSuperPackage).const_set(epackage.name, m) if epackage.eSuperPackage
-
-    # create classes only after all modules have been created
-    # otherwise classes may be created multiple times
-    if top
-      epackage.eAllClassifiers.each do |c| 
-        if c.is_a?(RGen::ECore::EClass)
-          create_class(c)
-        elsif c.is_a?(RGen::ECore::EEnum)
-          create_enum(c)
-        end
-      end
-      @in_create_module = false
-    end
-    m
-  end
-
-  def create_class(eclass)
-    return @classifiers[eclass] if @classifiers[eclass]
-
-    c = Class.new(super_class(eclass)) do
-      abstract if eclass.abstract
-      class << self
-        attr_accessor :_ecore_to_ruby
-      end
-    end
-    class << eclass
-      attr_accessor :instanceClass
-      def instanceClassName
-        instanceClass.to_s
-      end
-    end
-    eclass.instanceClass = c
-    c::ClassModule.module_eval do
-      alias _method_missing method_missing
-      def method_missing(m, *args)
-        if self.class._ecore_to_ruby.add_features(self.class.ecore)
-          send(m, *args)
-        else
-          _method_missing(m, *args)
-        end
-      end
-      alias _respond_to respond_to?
-      def respond_to?(m, include_all=false)
-        self.class._ecore_to_ruby.add_features(self.class.ecore)
-        _respond_to(m)
-      end
-    end
-    @classifiers[eclass] = c
-    c._set_ecore_internal(eclass)
-    c._ecore_to_ruby = self
-
-    create_module(eclass.ePackage).const_set(eclass.name, c)
-    c
-  end
-
-  def create_enum(eenum)
-    return @classifiers[eenum] if @classifiers[eenum]
-
-    e = RGen::MetamodelBuilder::DataTypes::Enum.new(eenum.eLiterals.collect{|l| l.name.to_sym})
-    @classifiers[eenum] = e
-
-    create_module(eenum.ePackage).const_set(eenum.name, e)
-    e
-  end
-
-  class FeatureWrapper
-    def initialize(efeature, classifiers)
-      @efeature = efeature
-      @classifiers = classifiers
-    end
-    def value(prop)
-      return false if prop == :containment && @efeature.is_a?(RGen::ECore::EAttribute)
-      @efeature.send(prop)
-    end
-    def many?
-      @efeature.many
-    end
-    def reference?
-      @efeature.is_a?(RGen::ECore::EReference)
-    end
-    def opposite
-      @efeature.eOpposite
-    end
-    def impl_type
-      etype = @efeature.eType
-      if etype.is_a?(RGen::ECore::EClass) || etype.is_a?(RGen::ECore::EEnum)
-        @classifiers[etype]
-      else
-        ic = etype.instanceClass
-        if ic
-          ic
-        else
-          raise "unknown type: #{etype.name}" 
-        end
-      end
-    end
-  end
-
-  def add_features(eclass)
-    return false if @features_added[eclass]
-    c = @classifiers[eclass]
-    eclass.eStructuralFeatures.each do |f|
-      w1 = FeatureWrapper.new(f, @classifiers) 
-      w2 = FeatureWrapper.new(f.eOpposite, @classifiers) if f.is_a?(RGen::ECore::EReference) && f.eOpposite
-      c.module_eval do
-        if w1.many?
-          _build_many_methods(w1, w2)
-        else
-          _build_one_methods(w1, w2)
-        end
-      end
-    end
-    @features_added[eclass] = true
-    eclass.eSuperTypes.each do |t|
-      add_features(t)
-    end
-    true
-  end
-
-  def super_class(eclass)
-    super_types = eclass.eSuperTypes
-    case super_types.size
-    when 0
-      RGen::MetamodelBuilder::MMBase
-    when 1
-      create_class(super_types.first)
-    else
-      RGen::MetamodelBuilder::MMMultiple(*super_types.collect{|t| create_class(t)})
-    end
-  end
-
-end
-
-end
-
-end
-

data/lib/puppet/vendor/rgen/lib/rgen/ecore/ruby_to_ecore.rb

@@ -1,91 +0,0 @@
-require 'rgen/transformer'
-require 'rgen/ecore/ecore'
-
-module RGen
-  
-module ECore
-  
-# This transformer creates an ECore model from Ruby classes built
-# by RGen::MetamodelBuilder.
-# 
-class RubyToECore < Transformer
-  
-  transform Class, :to => EClass, :if => :convert? do
-    { :name => name.gsub(/.*::(\w+)$/,'\1'),
-      :abstract => _abstract_class,
-      :interface => false,
-      :eStructuralFeatures => trans(_metamodel_description),
-      :ePackage =>  trans(name =~ /(.*)::\w+$/ ? eval($1) : nil),
-      :eSuperTypes => trans(superclasses),
-      :instanceClassName => name,
-      :eAnnotations => trans(_annotations)
-    }
-  end
-  
-  method :superclasses do
-    if superclass.respond_to?(:multiple_superclasses) && superclass.multiple_superclasses
-      superclass.multiple_superclasses
-    else
-      [ superclass ]
-    end
-  end
-  
-  transform Module, :to => EPackage, :if => :convert?  do
-    @enumParentModule ||= {}
-    _constants = _constantOrder + (constants - _constantOrder)
-    _constants.select {|c| const_get(c).is_a?(MetamodelBuilder::DataTypes::Enum)}.
-      each {|c| @enumParentModule[const_get(c)] = @current_object}
-    { :name => name.gsub(/.*::(\w+)$/,'\1'),
-      :eClassifiers => trans(_constants.collect{|c| const_get(c)}.select{|c| c.is_a?(Class) || 
-        (c.is_a?(MetamodelBuilder::DataTypes::Enum) && c != MetamodelBuilder::DataTypes::Boolean) }),
-      :eSuperPackage => trans(name =~ /(.*)::\w+$/ ? eval($1) : nil),
-      :eSubpackages => trans(_constants.collect{|c| const_get(c)}.select{|c| c.is_a?(Module) && !c.is_a?(Class)}),
-      :eAnnotations => trans(_annotations)
-    }
-  end
-  
-  method :convert? do
-    @current_object.respond_to?(:ecore) && @current_object != RGen::MetamodelBuilder::MMBase
-  end
-  
-  transform MetamodelBuilder::Intermediate::Attribute, :to => EAttribute do
-    Hash[*MetamodelBuilder::Intermediate::Attribute.properties.collect{|p| [p, value(p)]}.flatten].merge({
-      :eType => (etype == :EEnumerable ? trans(impl_type) : RGen::ECore.const_get(etype)),
-      :eAnnotations => trans(annotations)
-    })
-  end
-  
-  transform MetamodelBuilder::Intermediate::Reference, :to => EReference do
-    Hash[*MetamodelBuilder::Intermediate::Reference.properties.collect{|p| [p, value(p)]}.flatten].merge({
-      :eType => trans(impl_type),
-      :eOpposite => trans(opposite),
-      :eAnnotations => trans(annotations)
-    })
-  end
-  
-  transform MetamodelBuilder::Intermediate::Annotation, :to => EAnnotation do
-    { :source => source,
-      :details => details.keys.collect do |k|
-        e = RGen::ECore::EStringToStringMapEntry.new
-        e.key = k
-        e.value = details[k]
-        e
-      end
-    }
-  end
-  
-  transform MetamodelBuilder::DataTypes::Enum, :to => EEnum do
-    { :name => name, 
-      :instanceClassName => @enumParentModule && @enumParentModule[@current_object] && @enumParentModule[@current_object].name+"::"+name,
-      :eLiterals => literals.collect do |l|
-        lit = RGen::ECore::EEnumLiteral.new
-        lit.name = l.to_s
-        lit
-      end }
-  end
-  
-end
-  
-end
-  
-end

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

@@ -1,129 +0,0 @@
-module RGen
-
-# An Environment is used to hold model elements.
-#
-class Environment
-
-	def initialize
-		@elements = {}
-		@subClasses = {}
-		@subClassesUpdated = {}
-    @deleted = {}
-    @deletedClasses = {}
-	end
-	
-	# Add a model element. Returns the environment so <code><<</code> can be chained.
-	# 
-	def <<(el)
-		clazz = el.class
-		@elements[clazz] ||= []
-		@elements[clazz] << el
-		updateSubClasses(clazz)
-		self
-	end
-
-	# Removes model element from environment.
-	def delete(el)
-    @deleted[el] = true
-    @deletedClasses[el.class] = true
-	end
-		
-	# Iterates each element
-	#
-	def each(&b)
-    removeDeleted
-		@elements.values.flatten.each(&b)
-	end
-	
-	# Return the elements of the environment as an array
-	#
-	def elements
-    removeDeleted
-		@elements.values.flatten
-	end
-	
-	# This method can be used to instantiate a class and automatically put it into
-	# the environment. The new instance is returned.
-	#
-	def new(clazz, *args)
-		obj = clazz.new(*args)
-		self << obj
-		obj
-	end
-	
-	# Finds and returns model elements in the environment.
-	# 
-	# The search description argument must be a hash specifying attribute/value pairs.
-	# Only model elements are returned which respond to the specified attribute methods
-	# and return the specified values as result of these attribute methods.
-	# 
-	# As a special hash key :class can be used to look for model elements of a specific
-	# class. In this case an array of possible classes can optionally be given.
-	# 
-	def find(desc)
-    removeDeleted
-		result = []
-		classes = desc[:class] if desc[:class] and desc[:class].is_a?(Array)
-		classes = [ desc[:class] ] if !classes and desc[:class]
-		if classes
-			hashKeys = classesWithSubClasses(classes)
-		else
-			hashKeys = @elements.keys
-		end
-		hashKeys.each do |clazz|
-			next unless @elements[clazz]
-			@elements[clazz].each do |e|
-				failed = false
-				desc.each_pair { |k,v|
-					failed = true if k != :class and ( !e.respond_to?(k) or e.send(k) != v )
-				}
-				result << e unless failed
-			end
-		end
-		result
-	end
-	
-	private
-
-  def removeDeleted
-    @deletedClasses.keys.each do |c|
-      @elements[c].reject!{|e| @deleted[e]}
-    end
-    @deletedClasses.clear
-    @deleted.clear
-  end
-	
-	def updateSubClasses(clazz)
-		return if @subClassesUpdated[clazz]
-		if clazz.respond_to?( :ecore )
-			superClasses = clazz.ecore.eAllSuperTypes.collect{|c| c.instanceClass}
-		else
-			superClasses = superclasses(clazz)
-		end
-		superClasses.each do |c|
-			next if c == Object
-			@subClasses[c] ||= []
-			@subClasses[c] << clazz
-		end
-		@subClassesUpdated[clazz] = true
-	end	
-	
-	def classesWithSubClasses(classes)
-		result = classes
-		classes.each do |c|
-			result += @subClasses[c] if @subClasses[c]
-		end
-		result.uniq
-	end
-	
-	def superclasses(clazz)
-		if clazz == Object
-			[]
-		else
-			superclasses(clazz.superclass) << clazz.superclass
-		end
-	end
-	
-end
-
-end

data/lib/puppet/vendor/rgen/lib/rgen/fragment/dump_file_cache.rb

@@ -1,63 +0,0 @@
-module RGen
-
-module Fragment
-
-# Caches model fragments in Ruby dump files.
-#
-# Dump files are created per each fragment file.
-#
-# The main goal is to support fast loading and joining of fragments. Therefore the cache 
-# stores additional information which makes the joining process faster (adding to 
-# environment, resolving references)
-#
-class DumpFileCache
-
-  # +cache_map+ must be an object responding to +load_data+ and +store_data+
-  # for loading or storing data associated with a file;
-  # this can be an instance of Util::FileCacheMap
-  def initialize(cache_map)
-    @cache_map = cache_map 
-  end
-
-  # Note that the fragment must not be connected to other fragments by resolved references
-  # unresolve the fragment if necessary
-  def store(fragment)
-    fref = fragment.fragment_ref
-    # temporarily remove the reference to the fragment to avoid dumping the fragment
-    fref.fragment = nil
-    @cache_map.store_data(fragment.location,
-      Marshal.dump({
-        :root_elements => fragment.root_elements,
-        :elements => fragment.elements,
-        :index => fragment.index,
-        :unresolved_refs => fragment.unresolved_refs,
-        :fragment_ref => fref,
-        :data => fragment.data
-      }))
-    fref.fragment = fragment
-  end
-
-  def load(fragment)
-    dump = @cache_map.load_data(fragment.location)
-    return :invalid if dump == :invalid
-    header = Marshal.load(dump)
-    fragment.set_root_elements(header[:root_elements],
-      :elements => header[:elements],
-      :index => header[:index],
-      :unresolved_refs => header[:unresolved_refs])
-    fragment.data = header[:data]
-    if header[:fragment_ref]
-      fragment.fragment_ref = header[:fragment_ref]
-      fragment.fragment_ref.fragment = fragment
-    else
-      raise "no fragment_ref in fragment loaded from cache"
-    end
-  end
-
-end
-
-end
-
-end
-
-

data/lib/puppet/vendor/rgen/lib/rgen/fragment/fragmented_model.rb

@@ -1,140 +0,0 @@
-require 'rgen/instantiator/reference_resolver'
-
-module RGen
-
-module Fragment
-
-# A FragmentedModel represents a model which consists of fragments (ModelFragment).
-# 
-# The main purpose of this class is to resolve references across fragments and
-# to keep the references consistent while fragments are added or removed.
-# This way it also plays an important role in keeping the model fragments consistent
-# and thus ModelFragment objects should only be accessed via this interface.
-# Overall unresolved references after the resolution step are also maintained.
-#
-# A FragmentedModel can also  keep an RGen::Environment object up to date while fragments
-# are added or removed. The environment must be registered with the constructor.
-#
-# Reference resolution is based on arbitrary identifiers. The identifiers must be
-# provided in the fragments' indices. The FragmentedModel takes care to maintain
-# the overall index.
-#
-class FragmentedModel
-  attr_reader :fragments
-  attr_reader :environment
-
-  # Creates a fragmented model. Options:
-  #
-  #  :env 
-  #    environment which will be updated as model elements are added and removed
-  #
-  def initialize(options={})
-    @environment = options[:env]
-    @fragments = []
-    @index = nil
-    @fragment_change_listeners = []
-    @fragment_index = {}
-  end
-
-  # Adds a proc which is called when a fragment is added or removed
-  # The proc receives the fragment and one of :added, :removed
-  #
-  def add_fragment_change_listener(listener)
-    @fragment_change_listeners << listener
-  end
-
-  def remove_fragment_change_listener(listener)
-    @fragment_change_listeners.delete(listener)
-  end
-
-  # Add a fragment.
-  #
-  def add_fragment(fragment)
-    invalidate_cache
-    @fragments << fragment
-    fragment.elements.each{|e| @environment << e} if @environment
-    @fragment_change_listeners.each{|l| l.call(fragment, :added)}
-  end
-
-  # Removes the fragment. The fragment will be unresolved using unresolve_fragment.
-  #
-  def remove_fragment(fragment)
-    raise "fragment not part of model" unless @fragments.include?(fragment)
-    invalidate_cache
-    @fragments.delete(fragment)
-    @fragment_index.delete(fragment)
-    unresolve_fragment(fragment)
-    fragment.elements.each{|e| @environment.delete(e)} if @environment
-    @fragment_change_listeners.each{|l| l.call(fragment, :removed)}
-  end
-
-  # Resolve references between fragments. 
-  # It is assumed that references within fragments have already been resolved.
-  # This method can be called several times. It will update the overall unresolved references.
-  #
-  # Options:
-  #
-  #  :fragment_provider:
-  #    Only if a +fragment_provider+ is given, the resolve step can be reverted later on
-  #    by a call to unresolve_fragment. The fragment provider is a proc which receives a model
-  #    element and must return the fragment in which the element is contained.
-  #
-  #  :use_target_type:
-  #    reference resolver uses the expected target type to narrow the set of possible targets 
-  #
-  def resolve(options={})
-    local_index = index
-    @fragments.each do |f|
-      f.resolve_external(local_index, options)
-    end
-  end
-
-  # Remove all references between this fragment and all other fragments.
-  # The references will be replaced with unresolved references (MMProxy objects).
-  #
-  def unresolve_fragment(fragment)
-    fragment.unresolve_external
-    @fragments.each do |f|
-      if f != fragment
-        f.unresolve_external_fragment(fragment)
-      end
-    end
-  end
-
-  # Returns the overall unresolved references.
-  #
-  def unresolved_refs
-    @fragments.collect{|f| f.unresolved_refs}.flatten
-  end
-
-  # Returns the overall index. 
-  # This is a Hash mapping identifiers to model elements accessible via the identifier. 
-  #
-  def index
-    fragments.each do |f|
-      if !@fragment_index[f] || (@fragment_index[f].object_id != f.index.object_id)
-        @fragment_index[f] = f.index
-        invalidate_cache
-      end
-    end
-    return @index if @index
-    @index = {}
-    fragments.each do |f|
-      f.index.each do |i| 
-        (@index[i[0]] ||= []) << i[1]
-      end
-    end
-    @index
-  end
-
-  private
-
-  def invalidate_cache
-    @index = nil
-  end
-
-end
-
-end
-
-end