puppet 4.10.12-x64-mingw32 → 5.0.0-x64-mingw32

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

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

@@ -1,126 +0,0 @@
-require 'rgen/instantiator/qualified_name_resolver'
-require 'rgen/instantiator/json_parser'
-
-module RGen
-
-module Instantiator
-
-# JsonInstantiator is used to create RGen models from JSON.
-#
-# Each JSON object needs to have an attribute "_class" which is used to find
-# the metamodel class to instantiate. The value of "_class" should be the 
-# the relative qualified class name within the root package as a string. 
-#
-# If the option "short_class_names" is set to true, unqualified class names can be used.
-# In this case, metamodel classes are searched in the metamodel root package first.
-# If this search is not successful, all subpackages will be searched for the class name.
-#
-class JsonInstantiator
-
-  # Model elements will be created in evironment +env+,
-  # classes are looked for in metamodel package module +mm+,
-  # +options+ include:
-  #   short_class_names: if true subpackages will be searched for unqualifed class names (default: true)
-  #   ignore_keys:       an array of json object key names which are to be ignored (default: none)
-  #
-  # The options are also passed to the underlying QualifiedNameResolver.
-  #
-  def initialize(env, mm, options={})
-    @env = env
-    @mm = mm
-    @options = options
-    @short_class_names = !@options.has_key?(:short_class_names) || @options[:short_class_names]
-    @ignore_keys = @options[:ignore_keys] || []
-    @unresolvedReferences = []
-    @classes = {}
-    @classes_flat = {}
-    mm.ecore.eAllClasses.each do |c|
-      @classes[c.instanceClass.name.sub(mm.name+"::","")] = c
-      @classes_flat[c.name] = c
-    end
-    @parser = JsonParser.new(self)
-  end
-
-  # Creates the elements described by the json string +str+.
-  # Returns an array of ReferenceResolver::UnresolvedReference
-  # describing the references which could not be resolved
-  #
-  # Options:
-  #   :root_elements: if an array is provided, it will be filled with the root elements
-  #
-  def instantiate(str, options={})
-    root = @parser.parse(str)
-    if options[:root_elements].is_a?(Array)
-      options[:root_elements].clear
-      root.each{|r| options[:root_elements] << r}
-    end
-    resolver = QualifiedNameResolver.new(root, @options)
-    resolver.resolveReferences(@unresolvedReferences)
-  end
-
-  def createObject(hash)
-    className = hash["_class"]
-    # hashes without a _class key are returned as is
-    return hash unless className
-    if @classes[className]
-      clazz = @classes[className].instanceClass
-    elsif @short_class_names && @classes_flat[className]
-      clazz = @classes_flat[className].instanceClass
-    else 
-      raise "class not found: #{className}"
-    end
-    hash.delete("_class")
-    @ignore_keys.each do |k|
-      hash.delete(k)
-    end
-    urefs = []
-    hash.keys.each do |k|
-      f = eFeature(k, clazz)
-      hash[k] = [hash[k]] if f.many && !hash[k].is_a?(Array)
-      if f.is_a?(RGen::ECore::EReference) && !f.containment
-        if f.many
-          idents = hash[k]
-          hash[k] = idents.collect do |i|
-            proxy = RGen::MetamodelBuilder::MMProxy.new(i)
-            urefs << ReferenceResolver::UnresolvedReference.new(nil, k, proxy)
-            proxy
-          end
-        else
-          ident = hash[k]
-          ident = ident.first if ident.is_a?(Array)
-          proxy = RGen::MetamodelBuilder::MMProxy.new(ident)
-          hash[k] = proxy
-          urefs << ReferenceResolver::UnresolvedReference.new(nil, k, proxy)
-        end
-      elsif f.eType.is_a?(RGen::ECore::EEnum)
-        hash[k] = hash[k].to_sym
-      elsif f.eType.instanceClassName == "Float"
-        hash[k] = hash[k].to_f
-      end
-    end  
-    obj = @env.new(clazz, hash)
-    urefs.each do |r|
-      r.element = obj
-      @unresolvedReferences << r 
-    end
-    obj
-  end
-
-  private
-  
-  def eFeature(name, clazz) 
-    @eFeature ||= {}
-    @eFeature[clazz] ||= {}
-    unless @eFeature[clazz][name] 
-      feature = clazz.ecore.eAllStructuralFeatures.find{|f| f.name == name}
-      raise "feature '#{name}' not found in class '#{clazz}'" unless feature
-    end
-    @eFeature[clazz][name] ||= feature
-  end
-  
-end
-
-end
-
-end
-