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

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

@@ -0,0 +1,97 @@
+require 'rgen/instantiator/reference_resolver'
+
+module RGen
+
+module Instantiator
+
+# This is a resolver resolving element identifiers which are qualified names.
+class QualifiedNameResolver
+
+  attr_reader :nameAttribute
+  attr_reader :separator
+  attr_reader :leadingSeparator
+
+  def initialize(rootElements, options={})
+    @rootElements = rootElements
+    @nameAttribute = options[:nameAttribute] || "name"
+    @separator = options[:separator] || "/"
+    @leadingSeparator = options.has_key?(:leadingSeparator) ? options[:leadingSeparator] : true
+    @elementByQName = {}
+    @visitedQName = {}
+    @childReferences = {}
+    @resolverDelegate = ReferenceResolver.new(:identifier_resolver => method(:resolveIdentifier))
+  end
+
+  def resolveIdentifier(qualifiedName)
+    return @elementByQName[qualifiedName] if @elementByQName.has_key?(qualifiedName)
+    path = qualifiedName.split(separator).reject{|s| s == ""}
+    if path.size > 1
+      parentQName = (leadingSeparator ? separator : "") + path[0..-2].join(separator)
+      parents = resolveIdentifier(parentQName)
+      parents = [parents].compact unless parents.is_a?(Array)
+      children = parents.collect{|p| allNamedChildren(p)}.flatten
+    elsif path.size == 1
+      parentQName = ""
+      children = allRootNamedChildren
+    else
+      return @elementByQName[qualifiedName] = nil
+    end
+    # if the parent was already visited all matching elements are the hash 
+    if !@visitedQName[parentQName]
+      children.each do |c|
+        name = c.send(nameAttribute)
+        if name
+          qname = parentQName + ((parentQName != "" || leadingSeparator) ? separator : "") + name
+          existing = @elementByQName[qname]
+          if existing 
+            @elementByQName[qname] = [existing] unless existing.is_a?(Array)
+            @elementByQName[qname] << c
+          else
+            @elementByQName[qname] = c 
+          end
+        end
+      end
+      # all named children of praent have been checked and hashed
+      @visitedQName[parentQName] = true
+    end
+    @elementByQName[qualifiedName] ||= nil
+  end
+
+  def resolveReferences(unresolvedReferences, problems=[])
+    @resolverDelegate.resolve(unresolvedReferences, :problems => problems)
+  end
+
+  private
+
+  def allNamedChildren(element)
+    childReferences(element.class).collect do |r|
+      element.getGenericAsArray(r.name).collect do |c|
+        if c.respond_to?(nameAttribute)
+          c
+        else
+          allNamedChildren(c)
+        end
+      end
+    end.flatten
+  end
+
+  def allRootNamedChildren
+    @rootElements.collect do |e|
+      if e.respond_to?(nameAttribute)
+        e
+      else
+        allNamedChildren(e)
+      end
+    end.flatten
+  end
+
+  def childReferences(clazz)
+    @childReferences[clazz] ||= clazz.ecore.eAllReferences.select{|r| r.containment}
+  end
+
+end
+
+end
+
+end
+

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

@@ -0,0 +1,128 @@
+require 'rgen/instantiator/resolution_helper'
+
+module RGen
+
+module Instantiator
+
+# The ReferenceResolver can be used to resolve unresolved references, i.e. instances
+# of class UnresolvedReference
+#
+# There are two ways how this can be used:
+#  1. the identifiers and associated model elements are added upfront using +add_identifier+
+#  2. register an :identifier_resolver with the constructor, which will be invoked 
+#     for every unresolved identifier
+#
+class ReferenceResolver
+ 
+  # Instances of this class represent information about not yet resolved references.
+  # This consists of the +element+ and metamodel +feature_name+ which hold/is to hold the 
+  # reference and the +proxy+ object which is the placeholder for the reference.
+  # If the reference could not be resolved because the target type does not match the
+  # feature type, the flag +target_type_error+ will be set.
+  #
+  class UnresolvedReference 
+    attr_reader :feature_name, :proxy
+    attr_accessor :element, :target_type_error
+    def initialize(element, feature_name, proxy)
+      @element = element
+      @feature_name = feature_name
+      @proxy = proxy
+    end
+  end
+
+  # Create a reference resolver, options:
+  #
+  #  :identifier_resolver:
+  #    a proc which is called with an identifier and which should return the associated element
+  #    in case the identifier is not uniq, the proc may return multiple values
+  #    default: lookup element in internal map
+  #
+  def initialize(options={})
+    @identifier_resolver = options[:identifier_resolver]
+    @identifier_map = {}
+  end
+
+  # Add an +identifer+ / +element+ pair which will be used for looking up unresolved identifers
+  def add_identifier(ident, element)
+    map_entry = @identifier_map[ident]
+    if map_entry 
+      if map_entry.is_a?(Array)
+        map_entry << element
+      else
+        @identifier_map[ident] = [map_entry, element]
+      end
+    else 
+      @identifier_map[ident] = element
+    end
+  end
+
+  # Tries to resolve the given +unresolved_refs+. If resolution is successful, the proxy object
+  # will be removed, otherwise there will be an error description in the problems array.
+  # In case the resolved target element's type is not valid for the given feature, the 
+  # +target_type_error+ flag will be set on the unresolved reference.
+  # Returns an array of the references which are still unresolved. Options:
+  # 
+  #  :problems
+  #    an array to which problems will be appended
+  #
+  #  :on_resolve
+  #    a proc which will be called for every sucessful resolution, receives the unresolved
+  #    reference as well as to new target element
+  #
+  #  :use_target_type
+  #    use the expected target type to narrow the set of possible targets 
+  #    (i.e. ignore targets with wrong type)
+  #
+  #  :failed_resolutions
+  #    a Hash which will receive an entry for each failed resolution for which at least one
+  #    target element was found (wrong target type, or target not unique).
+  #    hash key is the uref, hash value is the target element or the Array of target elements
+  #
+  def resolve(unresolved_refs, options={})
+    problems = options[:problems] || []
+    still_unresolved_refs = []
+    failed_resolutions = options[:failed_resolutions] || {}
+    unresolved_refs.each do |ur|
+      if @identifier_resolver
+        target = @identifier_resolver.call(ur.proxy.targetIdentifier)
+      else
+        target = @identifier_map[ur.proxy.targetIdentifier]
+      end
+      target = [target].compact unless target.is_a?(Array)
+      if options[:use_target_type] 
+        feature = ur.element.class.ecore.eAllReferences.find{|r| r.name == ur.feature_name}
+        target = target.select{|e| e.is_a?(feature.eType.instanceClass)}
+      end
+      if target.size == 1
+        status = ResolutionHelper.set_uref_target(ur, target[0])
+        if status == :success
+          options[:on_resolve] && options[:on_resolve].call(ur, target[0])
+        elsif status == :type_error
+          ur.target_type_error = true
+          problems << type_error_message(target[0])
+          still_unresolved_refs << ur
+          failed_resolutions[ur] = target[0]
+        end
+      elsif target.size > 1
+        problems << "identifier #{ur.proxy.targetIdentifier} not uniq"
+        still_unresolved_refs << ur
+        failed_resolutions[ur] = target
+      else
+        problems << "identifier #{ur.proxy.targetIdentifier} not found"
+        still_unresolved_refs << ur
+      end
+    end
+    still_unresolved_refs
+  end   
+
+  private
+
+  def type_error_message(target)
+    "invalid target type #{target.class}"
+  end
+
+end
+
+end
+
+end

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

@@ -0,0 +1,47 @@
+module RGen
+module Instantiator
+
+module ResolutionHelper
+
+# sets the target of an unresolved reference in the model
+# returns :type_error if the target is of wrong type, otherwise :success
+#
+def self.set_uref_target(uref, target)
+  refs = uref.element.getGeneric(uref.feature_name)
+  if refs.is_a?(Array) 
+    index = refs.index(uref.proxy)
+    uref.element.removeGeneric(uref.feature_name, uref.proxy)
+    begin
+      uref.element.addGeneric(uref.feature_name, target, index)
+    rescue StandardError => e
+      if is_type_error?(e)
+        uref.element.addGeneric(uref.feature_name, uref.proxy, index)
+        return :type_error
+      else
+        raise
+      end
+    end
+  else
+    begin
+      # this will replace the proxy
+      uref.element.setGeneric(uref.feature_name, target)
+    rescue StandardError => e
+      if is_type_error?(e)
+        return :type_error
+      else
+        raise
+      end
+    end
+  end
+  :success
+end
+
+def self.is_type_error?(e)
+  e.message =~ /Can not use a .* where a .* is expected/
+end
+
+end
+
+end
+end
+

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

@@ -0,0 +1,168 @@
+require 'rgen/ecore/ecore'
+require 'rgen/instantiator/abstract_xml_instantiator'
+require 'rgen/array_extensions'
+
+class XMI11Instantiator < AbstractXMLInstantiator
+  
+  include RGen::ECore
+
+  ResolverDescription = Struct.new(:object, :attribute, :value, :many)
+  
+  INFO = 0
+  WARN = 1
+  ERROR = 2
+  
+  def initialize(env, fix_map={}, loglevel=ERROR)
+    @env = env
+    @fix_map = fix_map
+    @loglevel = loglevel
+    @rolestack = []
+    @elementstack = []
+  end
+   
+  def add_metamodel(ns, mod)
+    @ns_module_map ||={}
+    @ns_module_map[ns] = mod
+  end  
+
+  def instantiate(str)
+    @resolver_descs = []
+    @element_by_id = {}
+    super(str, 1000)
+    @resolver_descs.each do |rd|
+      if rd.many
+        newval = rd.value.split(" ").collect{|v| @element_by_id[v]}
+      else
+        newval = @element_by_id[rd.value]
+      end
+      log WARN, "Could not resolve reference #{rd.attribute} on #{rd.object}" unless newval
+      begin
+        rd.object.setGeneric(rd.attribute,newval)
+      rescue Exception
+        log WARN, "Could not set reference #{rd.attribute} on #{rd.object}"
+      end
+    end
+  end
+
+  def start_tag(prefix, tag, namespaces, attributes)
+    if tag =~ /\w+\.(\w+)/
+      # XMI role
+      role_name = map_feature_name($1) || $1
+      eRef = @elementstack.last && eAllReferences(@elementstack.last).find{|r|r.name == role_name}
+      log WARN, "No reference found for #{role_name} on #{@elementstack.last}" unless eRef
+      @rolestack.push eRef
+    elsif attributes["xmi.idref"]
+      # reference
+      rd = ResolverDescription.new
+      rd.object = @elementstack.last
+      rd.attribute = @rolestack.last.name
+      rd.value = attributes["xmi.idref"]
+      rd.many = @rolestack.last.many      
+      @resolver_descs << rd
+      @elementstack.push nil
+    else
+      # model element
+      value = map_tag(tag, attributes) || tag
+      if value.is_a?(String)
+        mod = @ns_module_map[namespaces[prefix]]
+        unless mod
+          log WARN, "Ignoring tag #{tag}"
+          return
+        end
+        value = mod.const_get(value).new
+      end
+      @env << value
+      eRef = @rolestack.last
+      if eRef && eRef.many
+        @elementstack.last.addGeneric(eRef.name, value)
+      elsif eRef
+        @elementstack.last.setGeneric(eRef.name, value)
+      end
+      @elementstack.push value
+    end
+  end
+  
+  def end_tag(prefix, tag)
+    if tag =~ /\w+\.(\w+)/
+      @rolestack.pop
+    else
+      @elementstack.pop
+    end
+  end  
+  
+  def set_attribute(attr, value)
+    return unless @elementstack.last
+    if attr == "xmi.id"
+      @element_by_id[value] = @elementstack.last
+    else
+      attr_name = map_feature_name(attr) || attr
+      eFeat = eAllStructuralFeatures(@elementstack.last).find{|a| a.name == attr_name}
+      unless eFeat
+        log WARN, "No structural feature found for #{attr_name} on #{@elementstack.last}"
+        return
+      end
+      if eFeat.is_a?(RGen::ECore::EReference)
+        if map_feature_value(attr_name, value).is_a?(eFeat.eType.instanceClass)
+          @elementstack.last.setGeneric(attr_name, map_feature_value(attr_name, value))
+        else
+          rd = ResolverDescription.new
+          rd.object = @elementstack.last
+          rd.attribute = attr_name
+          rd.value = value
+          rd.many = eFeat.many
+          @resolver_descs << rd
+        end
+      else
+        value = map_feature_value(attr_name, value) || value
+        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
+        value = value.to_f if eFeat.eType == EFloat
+        value = value.to_sym if eFeat.eType.is_a?(EEnum)
+        @elementstack.last.setGeneric(attr_name, value)
+      end
+    end
+  end
+  
+  private
+  
+  def map_tag(tag, attributes)
+    tag_map = @fix_map[:tags] || {}
+    value = tag_map[tag]
+    if value.is_a?(Proc)
+      value.call(tag, attributes)
+    else
+      value
+    end 
+  end
+        
+  def map_feature_name(name)
+    name_map = @fix_map[:feature_names] || {}
+    name_map[name]
+  end
+  
+  def map_feature_value(attr_name, value)
+    value_map = @fix_map[:feature_values] || {}
+    map = value_map[attr_name]
+    if map.is_a?(Hash)
+      map[value]
+    elsif map.is_a?(Proc)
+      map.call(value)
+    end
+  end
+  
+  def log(level, msg)
+    puts %w(INFO WARN ERROR)[level] + ": " + msg if level >= @loglevel
+  end
+
+  def eAllReferences(element)
+    @eAllReferences ||= {}
+    @eAllReferences[element.class] ||= element.class.ecore.eAllReferences
+  end
+    
+  def eAllStructuralFeatures(element)
+    @eAllStructuralFeatures ||= {}
+    @eAllStructuralFeatures[element.class] ||= element.class.ecore.eAllStructuralFeatures
+  end
+  
+end

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

@@ -0,0 +1,224 @@
+# RGen Framework
+# (c) Martin Thiede, 2006
+
+require 'rgen/metamodel_builder/constant_order_helper'
+require 'rgen/metamodel_builder/builder_runtime'
+require 'rgen/metamodel_builder/builder_extensions'
+require 'rgen/metamodel_builder/module_extension'
+require 'rgen/metamodel_builder/data_types'
+require 'rgen/metamodel_builder/mm_multiple'
+require 'rgen/ecore/ecore_interface'
+
+module RGen
+
+# MetamodelBuilder can be used to create a metamodel, i.e. Ruby classes which
+# act as metamodel elements.
+# 
+# To create a new metamodel element, create a Ruby class which inherits from
+# MetamodelBuilder::MMBase
+# 
+# 	class Person < RGen::MetamodelBuilder::MMBase
+# 	end
+# 
+# This way a couple of class methods are made available to the new class.
+# These methods can be used to:
+# * add attributes to the class
+# * add associations with other classes
+# 
+# Here is an example:
+# 
+# 	class Person < RGen::MetamodelBuilder::MMBase
+# 		has_attr 'name', String
+# 		has_attr 'age', Integer
+# 	end
+# 
+# 	class House < RGen::MetamodelBuilder::MMBase
+# 		has_attr 'address' # String is default
+# 	end
+# 
+# 	Person.many_to_many 'homes', House, 'inhabitants'
+# 
+# See BuilderExtensions for details about the available class methods.
+# 
+# =Attributes
+# 
+# The example above creates two classes 'Person' and 'House'. Person has the attributes
+# 'name' and 'age', House has the attribute 'address'. The attributes can be 
+# accessed on instances of the classes in the following way:
+# 
+# 	p = Person.new
+# 	p.name = "MyName"
+# 	p.age = 22
+# 	p.name	# => "MyName"
+# 	p.age 	# => 22
+# 
+# Note that the class Person takes care of the type of its attributes. As 
+# declared above, a 'name' can only be a String, an 'age' must be an Integer.
+# So the following would return an exception:
+# 
+# 	p.name = :myName	# => exception: can not put a Symbol where a String is expected
+# 
+# If the type of an attribute should be left undefined, use Object as type.
+#
+# =Associations
+# 
+# As well as attributes show up as instance methods, associations bring their own
+# accessor methods. For the Person-to-House association this would be:
+# 
+# 	h1 = House.new
+# 	h1.address = "Street1"
+# 	h2 = House.new
+# 	h2.address = "Street2"
+# 	p.addHomes(h1)
+# 	p.addHomes(h2)
+# 	p.removeHomes(h1)
+# 	p.homes	# => [ h2 ]
+# 
+# The Person-to-House association is _bidirectional_. This means that with the 
+# addition of a House to a Person, the Person is also added to the House. Thus:
+# 
+# 	h1.inhabitants	# => []
+# 	h2.inhabitants	# => [ p ]
+# 	
+# Note that the association is defined between two specific classes, instances of
+# different classes can not be added. Thus, the following would result in an 
+# exception:
+# 
+# 	p.addHomes(:justASymbol) # => exception: can not put a Symbol where a House is expected
+#
+# =ECore Metamodel description
+# 
+# The class methods described above are used to create a Ruby representation of the metamodel
+# we have in mind in a very simple and easy way. We don't have to care about all the details
+# of a metamodel at this point (e.g. multiplicities, changeability, etc).
+# 
+# At the same time however, an instance of the ECore metametamodel (i.e. a ECore based
+# description of our metamodel) is provided for all the Ruby classes and modules we create.
+# Since we did not provide the nitty-gritty details of the metamodel, defaults are used to
+# fully complete the ECore metamodel description.
+#
+# In order to access the ECore metamodel description, just call the +ecore+ method on a
+# Ruby class or module object belonging to your metamodel.
+# 
+# Here is the example continued from above:
+# 
+# 	Person.ecore.eAttributes.name # => ["name", "age"]
+# 	h2pRef = House.ecore.eReferences.first
+# 	h2pRef.eType                  # => Person
+# 	h2pRef.eOpposite.eType        # => House
+# 	h2pRef.lowerBound             # => 0
+# 	h2pRef.upperBound             # => -1
+# 	h2pRef.many                   # => true
+# 	h2pRef.containment            # => false
+# 
+# Note that the use of array_extensions.rb is assumed here to make model navigation convenient.
+# 
+# The following metamodel builder methods are supported, see individual method description
+# for details:
+# 
+# Attributes:
+# * BuilderExtensions#has_attr
+# 
+# Unidirectional references:
+# * BuilderExtensions#has_one
+# * BuilderExtensions#has_many
+# * BuilderExtensions#contains_one_uni
+# * BuilderExtensions#contains_many_uni
+# 
+# Bidirectional references:
+# * BuilderExtensions#one_to_one
+# * BuilderExtensions#one_to_many
+# * BuilderExtensions#many_to_one
+# * BuilderExtensions#many_to_many
+# * BuilderExtensions#contains_one
+# * BuilderExtensions#contains_many
+# 
+# Every builder command can optionally take a specification of further ECore properties.
+# Additional properties for Attributes and References are (with defaults in brackets):
+# * :ordered (true), 
+# * :unique (true),
+# * :changeable (true),
+# * :volatile (false),
+# * :transient (false),
+# * :unsettable (false),
+# * :derived (false),
+# * :lowerBound (0),
+# * :resolveProxies (true) <i>references only</i>,
+# 
+# Using these additional properties, the above example can be refined as follows:
+# 
+# 	class Person < RGen::MetamodelBuilder::MMBase
+# 		has_attr 'name', String, :lowerBound => 1
+# 		has_attr 'yearOfBirth', Integer,
+# 		has_attr 'age', Integer, :derived => true
+# 		def age_derived
+# 			Time.now.year - yearOfBirth
+# 		end
+# 	end
+# 
+# 	Person.many_to_many 'homes', House, 'inhabitants', :upperBound => 5
+# 
+# 	Person.ecore.eReferences.find{|r| r.name == 'homes'}.upperBound # => 5
+# 
+# This way we state that there must be a name for each person, we introduce a new attribute
+# 'yearOfBirth' and make 'age' a derived attribute. We also say that a person can 
+# have at most 5 houses in our metamodel.
+# 
+# ==Derived attributes and references
+# 
+# If the attribute 'derived' of an attribute or reference is set to true, a method +attributeName_derived+
+# has to be provided. This method is called whenever the original attribute is accessed. The
+# original attribute can not be written if it is derived.
+# 
+#
+module MetamodelBuilder	
+
+	# Use this class as a start for new metamodel elements (i.e. Ruby classes)
+	# by inheriting for it.
+	# 
+	# See MetamodelBuilder for an example.
+	class MMBase
+		include BuilderRuntime
+		include DataTypes
+		extend BuilderExtensions
+		extend ModuleExtension
+		extend RGen::ECore::ECoreInterface
+		
+		def initialize(arg=nil)
+			raise StandardError.new("Class #{self.class} is abstract") if self.class._abstract_class 
+	    arg.each_pair { |k,v| setGeneric(k, v) } if arg.is_a?(Hash)
+		end
+
+    # Object#inspect causes problems on most models 
+    def inspect
+      self.class.name
+    end
+    
+	  def self.method_added(m)
+	    raise "Do not add methods to model classes directly, add them to the ClassModule instead"
+	  end
+	end
+	
+  # Instances of MMGeneric can be used as values of any attribute are reference
+  class MMGeneric
+    # empty implementation so we don't have to check if a value is a MMGeneriv before setting the container
+    def _set_container(container, containing_feature_name)
+    end
+  end
+
+  # MMProxy objects can be used instead of real target elements in case references should be resolved later on
+  class MMProxy < MMGeneric
+    # The +targetIdentifer+ is an object identifying the element the proxy represents
+    attr_accessor :targetIdentifier
+    # +data+ is optional additional information to be associated with the proxy
+    attr_accessor :data
+
+    def initialize(ident=nil, data=nil)
+      @targetIdentifier = ident
+      @data = data
+    end
+  end
+
+end
+
+end