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

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

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

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

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

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

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