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

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

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

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

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

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

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