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

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

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

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

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

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

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