puppet 4.0.0 → 5.0.0

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
-
-

data/lib/puppet/vendor/rgen/lib/rgen/instantiator/abstract_instantiator.rb

@@ -1,66 +0,0 @@
-module RGen
-
-module Instantiator
-
-class AbstractInstantiator
-
-	ResolverDescription = Struct.new(:from, :attribute, :block) # :nodoc:
-
-	class << self
-		attr_accessor :resolver_descs
-	end
-
-	def initialize(env)
-		@env = env
-	end
-
-	# Specifies that +attribute+ should be resolved. If +:class+ is specified, 
-	# resolve +attribute+ only for objects of type class.
-	# The block must return the value to which the attribute should be assigned.
-	# The object for which the attribute is to be resolved will be accessible
-	# in the current context within the block.
-	# 
-	def self.resolve(attribute, desc=nil, &block)
-		from = (desc.is_a?(Hash) && desc[:class])
-		self.resolver_descs ||= []
-		self.resolver_descs << ResolverDescription.new(from, attribute, block)
-	end
-	
-	# Resolves +attribute+ to a model element which has attribute +:id+ set to the
-	# value currently in attribute +:src+
-	# 
-	def self.resolve_by_id(attribute, desc)
-		id_attr = (desc.is_a?(Hash) && desc[:id])
-		src_attr = (desc.is_a?(Hash) && desc[:src])
-		raise StandardError.new("No id attribute given.") unless id_attr
-		resolve(attribute) do
-			@env.find(id_attr => @current_object.send(src_attr)).first
-		end
-	end
-	
-	private
-	
-	def method_missing(m, *args) #:nodoc:
-		if @current_object
-			@current_object.send(m)
-		else
-			super
-		end
-	end
-	
-	def resolve
-		self.class.resolver_descs ||= []
-		self.class.resolver_descs.each { |desc|
-			@env.find(:class => desc.from).each { |e|
-				old_object, @current_object = @current_object, e
-				e.send("#{desc.attribute}=", instance_eval(&desc.block)) if e.respond_to?("#{desc.attribute}=")
-				@current_object = old_object
-			}
-		}
-	end			
-	
-end
-
-end
-
-end

data/lib/puppet/vendor/rgen/lib/rgen/instantiator/abstract_xml_instantiator.rb

@@ -1,66 +0,0 @@
-require 'nokogiri'
-
-class AbstractXMLInstantiator
-    
-  class Visitor < Nokogiri::XML::SAX::Document
-    
-    def initialize(inst, gcSuspendCount)
-      @instantiator = inst
-      @gcSuspendCount = gcSuspendCount
-      @namespaces = {}
-    end
-    
-    def start_element_namespace(tag, attributes, prefix, uri, ns)
-      controlGC
-      ns.each{|n| @namespaces[n[0]] = n[1]}
-      attrs = attributes.collect{|a| [a.prefix ? a.prefix+":"+a.localname : a.localname, a.value]}
-      @instantiator.start_tag(prefix, tag, @namespaces, Hash[*(attrs.flatten)])
-      attrs.each { |pair| @instantiator.set_attribute(pair[0], pair[1]) }
-    end
-    
-    def end_element_namespace(tag, prefix, uri)
-      @instantiator.end_tag(prefix, tag)
-    end
-    
-    def characters(str)
-      @instantiator.text(str)
-    end
-    
-    def controlGC
-      return unless @gcSuspendCount > 0
-      @gcCounter ||= 0
-      @gcCounter += 1
-      if @gcCounter == @gcSuspendCount
-        @gcCounter = 0
-        GC.enable
-        ObjectSpace.garbage_collect
-        GC.disable 
-      end 
-    end
-  end
-
-  # Parses str and calls start_tag, end_tag, set_attribute and text methods of a subclass.
-  # 
-  # If gcSuspendCount is specified, the garbage collector will be disabled for that
-  # number of start or end tags. After that period it will clean up and then be disabled again.
-  # A value of about 1000 can significantly improve overall performance.
-  # The memory usage normally does not increase.
-  # Depending on the work done for every xml tag the value might have to be adjusted.
-  # 
-  def instantiate(str, gcSuspendCount=0)
-    gcDisabledBefore = GC.disable
-    gcSuspendCount = 0 if gcDisabledBefore
-    begin
-      visitor = Visitor.new(self, gcSuspendCount)
-      parser = Nokogiri::XML::SAX::Parser.new(visitor)
-      parser.parse(str) do |ctx|
-        @parserContext = ctx
-      end
-     ensure 
-      GC.enable unless gcDisabledBefore
-    end
-  end
-  
-  def text(str)
-  end
-end

data/lib/puppet/vendor/rgen/lib/rgen/instantiator/default_xml_instantiator.rb

@@ -1,117 +0,0 @@
-require 'rgen/instantiator/nodebased_xml_instantiator'
-
-module RGen
-
-module Instantiator
-
-# A default XML instantiator.
-# Derive your own instantiator from this class or use it as is.
-# 
-class DefaultXMLInstantiator < NodebasedXMLInstantiator
-	include Util::NameHelper
-
-	NamespaceDescriptor = Struct.new(:prefix, :target)
-	
-	class << self
-	
-		def map_tag_ns(from, to, prefix="")
-			tag_ns_map[from] = NamespaceDescriptor.new(prefix, to)
-		end
-		
-		def tag_ns_map # :nodoc:
-			@tag_ns_map ||={}
-			@tag_ns_map
-		end
-		
-	end	
-	
-	def initialize(env, default_module, create_mm=false)
-		super(env)
-		@default_module = default_module
-		@create_mm = create_mm
-	end
-		
-	def on_descent(node)
-		obj = new_object(node)
-		@env << obj unless obj.nil?
-		node.object = obj
-		node.attributes.each_pair { |k,v| set_attribute(node, k, v) }
-	end
-
-	def on_ascent(node)
-		node.children.each { |c| assoc_p2c(node, c) }
-		node.object.class.has_attr 'chardata', Object unless node.object.respond_to?(:chardata)
-		set_attribute(node, "chardata", node.chardata)
-	end
-	
-  def class_name(str)
-    saneClassName(str)
-  end
-  
-	def new_object(node)
-		ns_desc = self.class.tag_ns_map[node.namespace]
-		class_name = class_name(ns_desc.nil? ? node.qtag : ns_desc.prefix+node.tag)
-		mod = (ns_desc && ns_desc.target) || @default_module		
-		build_on_error(NameError, :build_class, class_name, mod) do
-			mod.const_get(class_name).new
-		end
-	end
-  
-	def build_class(name, mod)
-		mod.const_set(name, Class.new(RGen::MetamodelBuilder::MMBase))
-	end
-  
-  def method_name(str)
-    saneMethodName(str)
-  end
-
-	def assoc_p2c(parent, child)
-        return unless parent.object && child.object
-        method_name = method_name(className(child.object))
-		build_on_error(NoMethodError, :build_p2c_assoc, parent, child, method_name) do
-			parent.object.addGeneric(method_name, child.object)
-			child.object.setGeneric("parent", parent.object)
-		end
-	end
-	
-	def build_p2c_assoc(parent, child, method_name)
-		parent.object.class.has_many(method_name, child.object.class)
-		child.object.class.has_one("parent", RGen::MetamodelBuilder::MMBase)
-	end
-	
-	def set_attribute(node, attr, value)
-	   return unless node.object
-	   	build_on_error(NoMethodError, :build_attribute, node, attr, value) do
-			node.object.setGeneric(method_name(attr), value)
-		end
-	end
-	
-	def build_attribute(node, attr, value)
-		node.object.class.has_attr(method_name(attr))
-	end
-
-	protected
-	
-	# Helper method for implementing classes.
-	# This method yields the given block.
-	# If the metamodel should be create automatically (see constructor)
-	# rescues +error+ and calls +builder_method+ with +args+, then 
-	# yields the block again.
-	def build_on_error(error, builder_method, *args)
-		begin
-			yield
-		rescue error
-			if @create_mm
-				send(builder_method, *args)
-				yield
-			else
-				raise
-			end
-		end
-	end
-
-end
-
-end
-
-end

data/lib/puppet/vendor/rgen/lib/rgen/instantiator/ecore_xml_instantiator.rb

@@ -1,169 +0,0 @@
-require 'rgen/ecore/ecore'
-require 'rgen/instantiator/abstract_xml_instantiator'
-require 'rgen/array_extensions'
-
-class ECoreXMLInstantiator < AbstractXMLInstantiator
-  
-  include RGen::ECore
-  
-  INFO = 0
-  WARN = 1
-  ERROR = 2
-  
-  def initialize(env, loglevel=ERROR)
-    @env = env
-    @rolestack = []
-    @elementstack = []
-    @element_by_id = {}
-    @loglevel = loglevel
-  end
-  
-  def start_tag(prefix, tag, namespaces, attributes)
-    eRef = nil
-    if @elementstack.last
-      eRef = eAllReferences(@elementstack.last).find{|r|r.name == tag}
-      if eRef
-        if attributes["xsi:type"] && attributes["xsi:type"] =~ /ecore:(\w+)/
-          class_name = $1
-          attributes.delete("xsi:type")
-        else 
-          class_name = eRef.eType.name
-        end
-      else
-        raise "Reference not found: #{tag} on #{@elementstack.last}"
-      end
-    else
-      class_name = tag
-    end
-    
-    eClass = RGen::ECore.ecore.eClassifiers.find{|c| c.name == class_name}
-    if eClass
-      obj = RGen::ECore.const_get(class_name).new
-      if attributes["xmi:id"]
-        @element_by_id[attributes["xmi:id"]] = obj
-        attributes.delete("xmi:id")
-      end
-      if eRef
-        if eRef.many
-          @elementstack.last.addGeneric(eRef.name, obj)
-        else
-          @elementstack.last.setGeneric(eRef.name, obj)
-        end
-      end
-      @env << obj
-      @elementstack.push obj
-    else
-      log WARN, "Class not found: #{class_name}"
-      @elementstack.push nil
-    end
-
-    attributes.each_pair do |attr, value|
-      set_attribute_internal(attr, value)
-    end
-  end
-  
-  def end_tag(prefix, tag)
-    @elementstack.pop
-  end
-  
-  ResolverDescription = Struct.new(:object, :attribute, :value)
-  
-  def set_attribute(attr, value)
-    # do nothing, already handled by start_tag/set_attribute_internal
-  end
-
-  def set_attribute_internal(attr, value)
-    return unless @elementstack.last
-    eFeat = eAllStructuralFeatures(@elementstack.last).find{|a| a.name == attr}
-    if eFeat.is_a?(EReference)
-      rd = ResolverDescription.new
-      rd.object = @elementstack.last
-      rd.attribute = attr
-      rd.value = value
-      @resolver_descs << rd
-    elsif eFeat
-      value = true if value == "true" && eFeat.eType == EBoolean
-      value = false if value == "false" && eFeat.eType == EBoolean
-      value = value.to_i if eFeat.eType == EInt || eFeat.eType == ELong
-      @elementstack.last.setGeneric(attr, value)
-    else
-      log WARN, "Feature not found: #{attr} on #{@elementstack.last}"
-    end
-  end
-  
-  def instantiate(str)
-    @resolver_descs = []
-#    puts "Instantiating ..."
-    super(str, 1000)
-    rootpackage = @env.find(:class => EPackage).first
-#    puts "Resolving ..."
-    @resolver_descs.each do |rd|
-      refed = find_referenced(rootpackage, rd.value)
-      feature = eAllStructuralFeatures(rd.object).find{|f| f.name == rd.attribute}
-      raise StandardError.new("StructuralFeature not found: #{rd.attribute}") unless feature
-      if feature.many
-        rd.object.setGeneric(feature.name, refed)
-      else
-        rd.object.setGeneric(feature.name, refed.first)
-      end
-    end
-  end
-  
-  def eAllReferences(element)
-    @eAllReferences ||= {}
-    @eAllReferences[element.class] ||= element.class.ecore.eAllReferences
-  end
-  
-  def eAllAttributes(element)
-    @eAllAttributes ||= {}
-    @eAllAttributes[element.class] ||= element.class.ecore.eAllAttributes
-  end
-  
-  def eAllStructuralFeatures(element)
-    @eAllStructuralFeatures ||= {}
-    @eAllStructuralFeatures[element.class] ||= element.class.ecore.eAllStructuralFeatures
-  end
-  
-  def find_referenced(context, desc)
-    desc.split(/\s+/).collect do |r|
-      if r =~ /^#([^\/]+)$/
-        @element_by_id[$1]
-      elsif r =~ /^#\/\d*\/([\w\/]+)/
-        find_in_context(context, $1.split('/'))
-      elsif r =~ /#\/\/(\w+)$/
-        case $1
-          when "EString";     RGen::ECore::EString
-          when "EInt";        RGen::ECore::EInt
-          when "ELong";       RGen::ECore::ELong
-          when "EBoolean";    RGen::ECore::EBoolean
-          when "EFloat";      RGen::ECore::EFloat
-          when "EJavaObject"; RGen::ECore::EJavaObject
-          when "EJavaClass";  RGen::ECore::EJavaClass
-        end
-      end
-    end.compact
-  end
-  
-  def find_in_context(context, desc_elements)
-    if context.is_a?(EPackage)
-      r = (context.eClassifiers + context.eSubpackages).find{|c| c.name == desc_elements.first}
-    elsif context.is_a?(EClass)
-      r = context.eStructuralFeatures.find{|s| s.name == desc_elements.first}
-    else
-      raise StandardError.new("Don't know how to find #{desc_elements.join('/')} in context #{context}")
-    end
-    if r
-      if desc_elements.size > 1
-        find_in_context(r, desc_elements[1..-1])
-      else
-        r
-      end
-    else
-      log WARN, "Can not follow path, element #{desc_elements.first} not found within #{context}(#{context.name})"
-    end
-  end
-  
-  def log(level, msg)
-    puts %w(INFO WARN ERROR)[level] + ": " + msg if level >= @loglevel
-  end
-end