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

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

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

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

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

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

@@ -0,0 +1,289 @@
+require 'rgen/instantiator/reference_resolver'
+
+module RGen
+
+module Fragment
+
+# A model fragment is a list of root model elements associated with a location (e.g. a file).
+# It also stores a list of unresolved references as well as a list of unresolved references
+# which have been resolved. Using the latter, a fragment can undo reference resolution.
+#
+# Optionally, an arbitrary data object may be associated with the fragment. The data object
+# will also be stored in the cache.
+#
+# If an element within the fragment changes this must be indicated to the fragment by calling
+# +mark_changed+. 
+#
+# Note: the fragment knows how to resolve references (+resolve_local+, +resolve_external+).
+# However considering a fragment a data structure, this functionality might be removed in the
+# future. Instead the fragment should be told about each resolution taking place. Use 
+# method +mark_resolved+ for this purpose.
+#
+class ModelFragment
+  attr_reader :root_elements
+  attr_accessor :location, :fragment_ref, :data
+  
+  # A FragmentRef serves as a single target object for elements which need to reference the
+  # fragment they are contained in. The FragmentRef references the fragment it is contained in.
+  # The FragmentRef is separate from the fragment itself to allow storing it in a marshal dump
+  # independently of the fragment.
+  #
+  class FragmentRef
+    attr_accessor :fragment
+  end
+
+  # A ResolvedReference wraps an unresolved reference after it has been resolved.
+  # It also holds the target element to which it has been resolved, i.e. with which the proxy
+  # object has been replaced.
+  #
+  class ResolvedReference
+    attr_reader :uref, :target
+    def initialize(uref, target)
+      @uref, @target = uref, target
+    end
+  end
+
+  # Create a model fragment
+  #
+  #  :data
+  #    data object associated with this fragment
+  #
+  #  :identifier_provider
+  #    identifier provider to be used when resolving references
+  #    it must be a proc which receives a model element and must return 
+  #    that element's identifier or nil if the element has no identifier
+  #
+  def initialize(location, options={})
+    @location = location
+    @fragment_ref = FragmentRef.new
+    @fragment_ref.fragment = self
+    @data = options[:data]
+    @resolved_refs = nil 
+    @changed = false
+    @identifier_provider = options[:identifier_provider]
+  end
+
+  # Set the root elements, normally done by an instantiator.
+  #
+  # For optimization reasons the instantiator of the fragment may provide data explicitly which
+  # is normally derived by the fragment itself. In this case it is essential that this
+  # data is consistent with the fragment.
+  #
+  def set_root_elements(root_elements, options={})
+    @root_elements = root_elements 
+    @elements = options[:elements]
+    @index = options[:index]
+    @unresolved_refs = options[:unresolved_refs]
+    @resolved_refs = nil 
+    # new unresolved refs, reset removed_urefs
+    @removed_urefs = nil
+    @changed = false
+  end
+
+  # Must be called when any of the elements in this fragment has been changed
+  #
+  def mark_changed
+    @changed = true
+    @elements = nil
+    @index = nil
+    @unresolved_refs = nil
+    # unresolved refs will be recalculated, no need to keep removed_urefs
+    @removed_urefs = nil
+    @resolved_refs = :dirty 
+  end
+
+  # Can be used to reset the change status to unchanged.
+  #
+  def mark_unchanged
+    @changed = false
+  end
+
+  # Indicates whether the fragment has been changed or not
+  #
+  def changed?
+    @changed
+  end
+
+  # Returns all elements within this fragment
+  #
+  def elements
+    return @elements if @elements
+    @elements = []
+    @root_elements.each do |e|
+      @elements << e
+      @elements.concat(e.eAllContents)
+    end
+    @elements
+  end
+  
+  # Returns the index of the element contained in this fragment.
+  #
+  def index
+    build_index unless @index
+    @index
+  end
+
+  # Returns all unresolved references within this fragment, i.e. references to MMProxy objects
+  #
+  def unresolved_refs
+    @unresolved_refs ||= collect_unresolved_refs
+    if @removed_urefs
+      @unresolved_refs -= @removed_urefs
+      @removed_urefs = nil
+    end
+    @unresolved_refs
+  end
+
+  # Builds the index of all elements within this fragment having an identifier
+  # the index is an array of 2-element arrays holding the identifier and the element
+  #
+  def build_index
+    raise "cannot build index without an identifier provider" unless @identifier_provider
+    @index = elements.collect { |e|
+      ident = @identifier_provider.call(e, nil)
+      ident && !ident.empty? ? [ident, e] : nil 
+    }.compact
+  end
+
+  # Resolves local references (within this fragment) as far as possible
+  #
+  # Options:
+  #
+  #  :use_target_type:
+  #    reference resolver uses the expected target type to narrow the set of possible targets 
+  #
+  def resolve_local(options={})
+    resolver = RGen::Instantiator::ReferenceResolver.new
+    index.each do |i|
+      resolver.add_identifier(i[0], i[1])
+    end
+    @unresolved_refs = resolver.resolve(unresolved_refs, :use_target_type => options[:use_target_type])
+  end
+
+  # Resolves references to external fragments using the external_index provided.
+  # The external index must be a Hash mapping identifiers uniquely to model elements.
+  #
+  # Options:
+  #
+  #  :fragment_provider:
+  #    If a +fragment_provider+ is given, the resolve step can be reverted later on 
+  #    by a call to unresolve_external or unresolve_external_fragment. The fragment provider
+  #    is a proc which receives a model element and must return the fragment in which it is
+  #    contained.
+  #
+  #  :use_target_type:
+  #    reference resolver uses the expected target type to narrow the set of possible targets 
+  #
+  #
+  def resolve_external(external_index, options)
+    fragment_provider = options[:fragment_provider]
+    resolver = RGen::Instantiator::ReferenceResolver.new(
+      :identifier_resolver => proc {|ident| external_index[ident] })
+    if fragment_provider
+      @resolved_refs = {} if @resolved_refs.nil? || @resolved_refs == :dirty
+      on_resolve = proc { |ur, target|
+        target_fragment = fragment_provider.call(target)
+        target_fragment ||= :unknown
+        raise "can not resolve local reference in resolve_external, call resolve_local first" \
+          if target_fragment == self
+        @resolved_refs[target_fragment] ||= []
+        @resolved_refs[target_fragment] << ResolvedReference.new(ur, target)
+      } 
+      @unresolved_refs = resolver.resolve(unresolved_refs, :on_resolve => on_resolve, :use_target_type => options[:use_target_type])
+    else
+      @unresolved_refs = resolver.resolve(unresolved_refs, :use_target_type => options[:use_target_type])
+    end
+  end
+
+  # Marks a particular unresolved reference +uref+ as resolved to +target+ in +target_fragment+.
+  #
+  def mark_resolved(uref, target_fragment, target)
+    @resolved_refs = {} if @resolved_refs.nil? || @resolved_refs == :dirty
+    target_fragment ||= :unknown
+    if target_fragment != self
+      @resolved_refs[target_fragment] ||= []
+      @resolved_refs[target_fragment] << ResolvedReference.new(uref, target)
+    end
+    @removed_urefs ||= []
+    @removed_urefs << uref
+  end
+
+  # Unresolve outgoing references to all external fragments, i.e. references which used to
+  # be represented by an unresolved reference from within this fragment.
+  # Note, that there may be more references to external fragments due to references which 
+  # were represented by unresolved references from within other fragments.
+  # 
+  def unresolve_external
+    return if @resolved_refs.nil?
+    raise "can not unresolve, missing fragment information" if @resolved_refs == :dirty || @resolved_refs[:unknown]
+    rrefs = @resolved_refs.values.flatten
+    @resolved_refs = {}
+    unresolve_refs(rrefs)
+  end
+
+  # Like unresolve_external but only unresolve references to external fragment +fragment+
+  #
+  def unresolve_external_fragment(fragment)
+    return if @resolved_refs.nil?
+    raise "can not unresolve, missing fragment information" if @resolved_refs == :dirty || @resolved_refs[:unknown]
+    rrefs = @resolved_refs[fragment]
+    @resolved_refs.delete(fragment)
+    unresolve_refs(rrefs) if rrefs
+  end
+
+  private
+
+  # Turns resolved references +rrefs+ back into unresolved references
+  #
+  def unresolve_refs(rrefs)
+    # make sure any removed_urefs have been removed, 
+    # otherwise they will be removed later even if this method actually re-added them
+    unresolved_refs
+    rrefs.each do |rr|
+      ur = rr.uref
+      refs = ur.element.getGeneric(ur.feature_name)
+      if refs.is_a?(Array)
+        index = refs.index(rr.target)
+        ur.element.removeGeneric(ur.feature_name, rr.target)
+        ur.element.addGeneric(ur.feature_name, ur.proxy, index)
+      else
+        ur.element.setGeneric(ur.feature_name, ur.proxy)
+      end
+      @unresolved_refs << ur
+    end
+  end
+
+  def collect_unresolved_refs
+    unresolved_refs = []
+    elements.each do |e|
+      each_reference_target(e) do |r, t|
+        if t.is_a?(RGen::MetamodelBuilder::MMProxy)
+          unresolved_refs << 
+            RGen::Instantiator::ReferenceResolver::UnresolvedReference.new(e, r.name, t)
+        end
+      end
+    end
+    unresolved_refs
+  end
+
+  def each_reference_target(element)
+    non_containment_references(element.class).each do |r|
+      element.getGenericAsArray(r.name).each do |t|
+        yield(r, t)
+      end
+    end
+  end
+
+  def non_containment_references(clazz)
+    @@non_containment_references_cache ||= {}
+    @@non_containment_references_cache[clazz] ||= 
+      clazz.ecore.eAllReferences.select{|r| !r.containment}
+  end 
+
+end
+
+end
+
+end
+
+