puppet 4.10.12-universal-darwin → 5.0.0-universal-darwin

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

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

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