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

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

@@ -1,174 +0,0 @@
-# RGen Framework
-# (c) Martin Thiede, 2006
-
-require 'rgen/util/name_helper'
-
-module RGen
-
-module MetamodelBuilder
-
-# This module is mixed into MetamodelBuilder::MMBase.
-# The methods provided by this module are used by the methods generated
-# by the class methods of MetamodelBuilder::BuilderExtensions
-module BuilderRuntime
-	include Util::NameHelper
-	
-	def is_a?(c)
-    return super unless c.const_defined?(:ClassModule)
-    kind_of?(c::ClassModule)
-	end
-	
-	def addGeneric(role, value, index=-1)
-		send("add#{firstToUpper(role.to_s)}",value, index)
-	end
-	
-	def removeGeneric(role, value)
-		send("remove#{firstToUpper(role.to_s)}",value)
-	end
-	
-	def setGeneric(role, value)
-		send("set#{firstToUpper(role.to_s)}",value)
-	end
-
-  def hasManyMethods(role)
-    respond_to?("add#{firstToUpper(role.to_s)}")
-  end
-
-  def setOrAddGeneric(role, value)
-    if hasManyMethods(role)
-      addGeneric(role, value)
-    else
-      setGeneric(role, value)
-    end
-  end
-
-  def setNilOrRemoveGeneric(role, value)
-    if hasManyMethods(role)
-      removeGeneric(role, value)
-    else
-      setGeneric(role, nil)
-    end
-  end
-
-  def setNilOrRemoveAllGeneric(role)
-    if hasManyMethods(role)
-      setGeneric(role, [])
-    else
-      setGeneric(role, nil)
-    end
-  end
-
-	def getGeneric(role)
-		send("get#{firstToUpper(role.to_s)}")
-	end
-
-  def getGenericAsArray(role)
-    result = getGeneric(role)
-    result = [result].compact unless result.is_a?(Array)
-    result
-  end
-
-  def eIsSet(role)
-    eval("defined? @#{role}") != nil
-  end
-
-  def eUnset(role)
-    if respond_to?("add#{firstToUpper(role.to_s)}")
-      setGeneric(role, [])
-    else
-      setGeneric(role, nil)
-    end
-    remove_instance_variable("@#{role}")
-  end
-
-  def eContainer
-    @_container
-  end
-
-  def eContainingFeature
-    @_containing_feature_name
-  end
-
-  # returns the contained elements in no particular order
-  def eContents
-    if @_contained_elements
-      @_contained_elements.dup
-    else
-      []
-    end
-  end
-
-  # if a block is given, calls the block on every contained element in depth first order. 
-  # if the block returns :prune, recursion will stop at this point.
-  #
-  # if no block is given builds and returns a list of all contained elements.
-  #
-  def eAllContents(&block)
-    if block
-      if @_contained_elements
-        @_contained_elements.each do |e|
-          res = block.call(e)
-          e.eAllContents(&block) if res != :prune
-        end
-      end
-      nil
-    else
-      result = []
-      if @_contained_elements
-        @_contained_elements.each do |e|
-          result << e
-          result.concat(e.eAllContents)
-        end
-      end
-      result
-    end
-  end
-
-  def disconnectContainer
-    eContainer.setNilOrRemoveGeneric(eContainingFeature, self) if eContainer
-  end
-
-  def _set_container(container, containing_feature_name)
-    # if a new container is set, make sure to disconnect from the old one.
-    # note that _set_container will never be called for the container and the role
-    # which are currently set because the accessor methods in BuilderExtensions
-    # block setting/adding a value which is already present.
-    # (it may be called for the same container with a different role, a different container
-    # with the same role and a different container with a different role, though)
-    # this ensures, that disconnecting for the current container doesn't break
-    # a new connection which has just been set up in the accessor methods.
-    disconnectContainer if container
-    @_container._remove_contained_element(self) if @_container
-    container._add_contained_element(self) if container
-    @_container = container
-    @_containing_feature_name = containing_feature_name
-  end
-
-  def _add_contained_element(element)
-    @_contained_elements ||= []
-    @_contained_elements << element
-  end
-
-  def _remove_contained_element(element)
-    @_contained_elements.delete(element) if @_contained_elements
-  end
-
-	def _assignmentTypeError(target, value, expected)
-		text = ""
-		if target
-			targetId = target.class.name
-			targetId += "(" + target.name + ")" if target.respond_to?(:name) and target.name
-			text += "In #{targetId} : "
-		end
-		valueId = value.class.name
-		valueId += "(" + value.name + ")" if value.respond_to?(:name) and value.name
-		valueId += "(:" + value.to_s + ")" if value.is_a?(Symbol)
-		text += "Can not use a #{valueId} where a #{expected} is expected"
-		StandardError.new(text)
-	end
-
-end
-
-end
-
-end

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

@@ -1,89 +0,0 @@
-module RGen
-
-module MetamodelBuilder
-
-# The purpose of the ConstantOrderHelper is to capture the definition order of RGen metamodel builder 
-# classes, modules and enums. The problem is that Ruby doesn't seem to track the order of
-# constants being created in a module. However the order is important because it defines the order
-# of eClassifiers and eSubpackages in a EPackage.
-#
-# It would be helpful here if Ruby provided a +const_added+ callback, but this is not the case up to now.
-#
-# The idea for capturing is that all events of creating a RGen class, module or enum are reported to the
-# ConstantOrderHelper singleton.
-# For classes and modules it tries to add their names to the parent's +_constantOrder+ array.
-# The parent module is derived from the class's or module's name. However, the new name is only added
-# if the respective parent module has a new constant (which is not yet in +_constantOrder+) which
-# points to the new class or module.
-# For enums it is a bit more complicated, because at the time the enum is created, the parent
-# module does not yet contain the constant to which the enum is assigned. Therefor, the enum is remembered
-# and it is tried to be stored on the next event (class, module or enum) within the module which was
-# created last (which was last extended with ModuleExtension). If it can not be found in that module,
-# all parent modules of the last module are searched. This way it should also be correctly entered in
-# case it was defined outside of the last created module. 
-# Note that an enum is not stored to the constant order array unless another event occurs. That's why
-# it is possible that one enum is missing at the enum. This needs to be taken care of by the ECore transformer.
-#
-# This way of capturing should be sufficient for the regular use cases of the RGen metamodel builder language.
-# However, it is possible to write code which messes this up, see unit tests for details.
-# In the worst case, the new classes, modules or enums will just not be found in a parent module and thus be ignored.
-#
-ConstantOrderHelper = Class.new do
-
-  def initialize
-    @currentModule = nil
-    @pendingEnum = nil
-  end
-
-  def classCreated(c)
-    handlePendingEnum
-    cont = containerModule(c)
-    name = (c.name || "").split("::").last
-    return unless cont.respond_to?(:_constantOrder) && !cont._constantOrder.include?(name)
-    cont._constantOrder << name
-  end
-
-  def moduleCreated(m)
-    handlePendingEnum
-    cont = containerModule(m)
-    name = (m.name || "").split("::").last
-    return unless cont.respond_to?(:_constantOrder) && !cont._constantOrder.include?(name)
-    cont._constantOrder << name
-    @currentModule = m
-  end
-
-  def enumCreated(e)
-    handlePendingEnum
-    @pendingEnum = e
-  end
-
-  private
-
-  def containerModule(m)
-    containerName = (m.name || "").split("::")[0..-2].join("::")
-    containerName.empty? ? nil : eval(containerName, TOPLEVEL_BINDING)
-  end 
-
-  def handlePendingEnum
-    return unless @pendingEnum
-    m = @currentModule
-    while m
-      if m.respond_to?(:_constantOrder)
-        newConstants = m.constants - m._constantOrder
-        const = newConstants.find{|c| m.const_get(c).object_id == @pendingEnum.object_id}
-        if const
-          m._constantOrder << const.to_s
-          break
-        end
-      end
-      m = containerModule(m)
-    end
-    @pendingEnum = nil
-  end
-      
-end.new
-
-end
-
-end
-

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

@@ -1,77 +0,0 @@
-module RGen
-
-module MetamodelBuilder
-
-module DataTypes
-
-  # An enum object is used to describe possible attribute values within a 
-  # MetamodelBuilder attribute definition. An attribute defined this way can only
-  # take the values specified when creating the Enum object. 
-  # Literal values can only be symbols or true or false.
-  # Optionally a name may be specified for the enum object.
-  # 
-  # Examples:
-  # 
-  # 	Enum.new(:name => "AnimalEnum", :literals => [:cat, :dog])
-  # 	Enum.new(:literals => [:cat, :dog])
-  # 	Enum.new([:cat, :dog])
-  # 
-	class Enum
-	  attr_reader :name, :literals
-	  
-	  # Creates a new named enum type object consisting of the elements passed as arguments.
-	  def initialize(params)
-      MetamodelBuilder::ConstantOrderHelper.enumCreated(self)
-	  	if params.is_a?(Array)
-		    @literals = params
-	  		@name = "anonymous"
-	  	elsif params.is_a?(Hash)
-	  		raise StandardError.new("Hash entry :literals is missing") unless params[:literals]
-	  		@literals = params[:literals]
-	  		@name = params[:name] || "anonymous"
-	  	else
-	  		raise StandardError.new("Pass an Array or a Hash")
-	  	end
-	  end
-
-		# This method can be used to check if an object can be used as value for
-		# variables having this enum object as type.	  
-	  def validLiteral?(l)
-	    literals.include?(l)
-	  end
-	  
-	  def literals_as_strings
-	  	literals.collect do |l|
-	  		if l.is_a?(Symbol)
-          if l.to_s =~ /^\d|\W/
-            ":'"+l.to_s+"'"
-          else
-            ":"+l.to_s
-          end
-	  		elsif l.is_a?(TrueClass) || l.is_a?(FalseClass)
-	  			l.to_s
-	  		else
-	  			raise StandardError.new("Literal values can only be symbols or true/false")
-	  		end
-	  	end
-	  end
-	  
-	  def to_s # :nodoc:
-	  	name
-	  end
-	end
-	
-	# Boolean is a predefined enum object having Ruby's true and false singletons
-	# as possible values.
-	Boolean = Enum.new(:name => "Boolean", :literals => [true, false])
-
-	# Long represents a 64-bit Integer
-  # This constant is merely a marker for keeping this information in the Ruby version of the metamodel,
-  # values of this type will always be instances of Integer or Bignum;
-  # Setting it to a string value ensures that it responds to "to_s" which is used in the metamodel generator
-	Long = "Long"
-end
-
-end
-
-end

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

@@ -1,30 +0,0 @@
-module RGen
-
-module MetamodelBuilder
-
-module Intermediate
-
-class Annotation
-  attr_reader :details, :source
-  
-  def initialize(hash)
-    if hash[:source] || hash[:details]
-      restKeys = hash.keys - [:source, :details]
-      raise "Hash key #{restKeys.first} not allowed." unless restKeys.empty?
-      raise "Details not provided, key :details is missing" unless hash[:details]
-      raise "Details must be provided as a hash" unless hash[:details].is_a?(Hash)
-      @details = hash[:details]
-      @source = hash[:source]
-    else
-      raise "Details must be provided as a hash" unless hash.is_a?(Hash)
-      @details = hash
-    end
-  end
-  
-end
-
-end
-
-end
-
-end

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

@@ -1,168 +0,0 @@
-require 'rgen/metamodel_builder/data_types'
-
-module RGen
-
-module MetamodelBuilder
-
-module Intermediate
-
-class Feature
-  attr_reader :etype, :impl_type
-
-  def value(prop)
-    @props[prop]
-  end
-  
-  def annotations
-    @annotations ||= []
-  end
-
-  def many?
-    value(:upperBound) > 1 || value(:upperBound) == -1
-  end
-
-  def reference?
-    is_a?(Reference)
-  end
-
-  protected
-
-  def check(props)
-    @props.keys.each do |p|
-      kind = props[p]
-      raise StandardError.new("invalid property #{p}") unless kind
-      raise StandardError.new("property '#{p}' not set") if value(p).nil? && kind == :required
-    end
-  end
-
-end
-
-class Attribute < Feature
-
-  Properties = { 
-    :name => :required, 
-    :ordered => :required, 
-    :unique => :required,
-    :changeable => :required,
-    :volatile => :required,
-    :transient => :required,
-    :unsettable => :required,
-    :derived => :required,
-    :lowerBound => :required,
-    :upperBound => :required,
-    :defaultValueLiteral => :optional
-  }
-
-  Defaults = {
-    :ordered => true,
-    :unique => true,
-    :changeable => true,
-    :volatile => false,
-    :transient => false,
-    :unsettable => false,
-    :derived => false,
-    :lowerBound => 0
-  }
-
-  Types = { 
-    String => :EString,
-    Integer => :EInt,
-    RGen::MetamodelBuilder::DataTypes::Long => :ELong,
-    Float => :EFloat,
-    RGen::MetamodelBuilder::DataTypes::Boolean => :EBoolean,
-    Object => :ERubyObject,
-    Class => :ERubyClass 
-  }
-
-  def self.default_value(prop)
-    Defaults[prop]
-  end
-  
-  def self.properties
-    Properties.keys.sort{|a,b| a.to_s <=> b.to_s}
-  end
-
-  def initialize(type, props)
-    @props = Defaults.merge(props)
-    type ||= String
-    @etype = Types[type]
-    if @etype
-      @impl_type = type
-    elsif type.is_a?(RGen::MetamodelBuilder::DataTypes::Enum)
-      @etype = :EEnumerable
-      @impl_type = type
-    else
-      raise ArgumentError.new("invalid type '#{type}'")
-    end
-    if @props[:derived]
-      @props[:changeable] = false
-      @props[:volatile] = true
-      @props[:transient] = true
-    end    
-    check(Properties)
-  end
-
-end
-
-class Reference < Feature
-  attr_accessor :opposite
-
-  Properties = { 
-    :name => :required, 
-    :ordered => :required, 
-    :unique => :required,
-    :changeable => :required,
-    :volatile => :required,
-    :transient => :required,
-    :unsettable => :required,
-    :derived => :required,
-    :lowerBound => :required,
-    :upperBound => :required,
-    :resolveProxies => :required,
-    :containment => :required
-  }
-
-  Defaults = {
-    :ordered => true,
-    :unique => true,
-    :changeable => true,
-    :volatile => false,
-    :transient => false,
-    :unsettable => false,
-    :derived => false,
-    :lowerBound => 0,
-    :resolveProxies => true
-  }
-
-  def self.default_value(prop)
-    Defaults[prop]
-  end
-  
-  def self.properties
-    Properties.keys.sort{|a,b| a.to_s <=> b.to_s}
-  end
-
-  def initialize(type, props)
-    @props = Defaults.merge(props)
-    if type.respond_to?(:_metamodel_description) 
-      @etype = nil
-      @impl_type = type
-    else
-      raise ArgumentError.new("'#{type}' (#{type.class}) is not a MMBase in reference #{props[:name]}")
-    end
-    if @props[:derived]
-      @props[:changeable] = false
-      @props[:volatile] = true
-      @props[:transient] = true
-    end    
-    check(Properties)
-  end
-
-end
-
-end
-
-end
-
-end
-