puppet 4.0.0 → 4.9.1

data/lib/puppet/pops/types/p_timestamp_type.rb

@@ -0,0 +1,69 @@
+module Puppet::Pops
+module Types
+  class PTimestampType < PAbstractTimeDataType
+    def self.register_ptype(loader, ir)
+      create_ptype(loader, ir, 'ScalarType',
+        'from' => { KEY_TYPE => POptionalType.new(PTimestampType::DEFAULT), KEY_VALUE => nil },
+        'to' => { KEY_TYPE => POptionalType.new(PTimestampType::DEFAULT), KEY_VALUE => nil }
+      )
+    end
+
+    def self.new_function(_, loader)
+      @new_function ||= Puppet::Functions.create_loaded_function(:new_timestamp, loader) do
+        local_types do
+          type 'Formats = Variant[String[2],Array[String[2]], 1]'
+        end
+
+        dispatch :now do
+        end
+
+        dispatch :from_seconds do
+          param 'Variant[Integer,Float]', :seconds
+        end
+
+        dispatch :from_string do
+          param           'String[1]', :string
+          optional_param  'Formats',   :format
+          optional_param  'String[1]', :timezone
+        end
+
+        dispatch :from_string_hash do
+          param <<-TYPE, :hash_arg
+            Struct[{
+              string => String[1],
+              Optional[format] => Formats,
+              Optional[timezone] => String[1]
+            }]
+          TYPE
+        end
+
+        def now
+          Time::Timestamp.now
+        end
+
+        def from_string(string, format = :default, timezone = nil)
+          Time::Timestamp.parse(string, format, timezone)
+        end
+
+        def from_string_hash(args_hash)
+          Time::Timestamp.from_hash(args_hash)
+        end
+
+        def from_seconds(seconds)
+          Time::Timestamp.new((seconds * Time::NSECS_PER_SEC).to_i)
+        end
+      end
+    end
+
+    def generalize
+      DEFAULT
+    end
+
+    def impl_class
+      Time::Timestamp
+    end
+
+    DEFAULT = PTimestampType.new(nil, nil)
+  end
+end
+end

data/lib/puppet/pops/types/p_type_set_type.rb

@@ -0,0 +1,352 @@
+module Puppet::Pops
+module Types
+
+KEY_NAME_AUTHORITY = 'name_authority'.freeze
+KEY_TYPES = 'types'.freeze
+KEY_ALIAS = 'alias'.freeze
+KEY_VERSION = 'version'.freeze
+KEY_VERSION_RANGE = 'version_range'.freeze
+KEY_REFERENCES = 'references'.freeze
+
+class PTypeSetType < PMetaType
+
+  # A Loader that makes the types known to the TypeSet visible
+  #
+  # @api private
+  class TypeSetLoader < Loader::BaseLoader
+    def initialize(type_set, parent)
+      super(parent, "(TypeSetFirstLoader '#{type_set.name}')")
+      @type_set = type_set
+    end
+
+    def name_authority
+      @type_set.name_authority
+    end
+
+    def find(typed_name)
+      if typed_name.type == :type && typed_name.name_authority == @type_set.name_authority
+        type = @type_set[typed_name.name]
+        return set_entry(typed_name, type) unless type.nil?
+      end
+      nil
+    end
+  end
+
+  TYPE_STRING_OR_VERSION = TypeFactory.variant(PStringType::NON_EMPTY, TypeFactory.sem_ver)
+  TYPE_STRING_OR_RANGE = TypeFactory.variant(PStringType::NON_EMPTY, TypeFactory.sem_ver_range)
+
+  TYPE_TYPE_REFERENCE_I12N = TypeFactory.struct({
+    KEY_NAME => Pcore::TYPE_QUALIFIED_REFERENCE,
+    KEY_VERSION_RANGE => TYPE_STRING_OR_RANGE,
+    TypeFactory.optional(KEY_NAME_AUTHORITY) => Pcore::TYPE_URI,
+    TypeFactory.optional(KEY_ANNOTATIONS) => TYPE_ANNOTATIONS
+  })
+
+  TYPE_TYPESET_I12N = TypeFactory.struct({
+    TypeFactory.optional(Pcore::KEY_PCORE_URI) => Pcore::TYPE_URI,
+    Pcore::KEY_PCORE_VERSION => TYPE_STRING_OR_VERSION,
+    TypeFactory.optional(KEY_NAME_AUTHORITY) => Pcore::TYPE_URI,
+    TypeFactory.optional(KEY_NAME) => Pcore::TYPE_QUALIFIED_REFERENCE,
+    KEY_VERSION => TYPE_STRING_OR_VERSION,
+    TypeFactory.optional(KEY_TYPES) => TypeFactory.hash_kv(Pcore::TYPE_SIMPLE_TYPE_NAME, PType::DEFAULT, PCollectionType::NOT_EMPTY_SIZE),
+    TypeFactory.optional(KEY_REFERENCES) => TypeFactory.hash_kv(Pcore::TYPE_SIMPLE_TYPE_NAME, TYPE_TYPE_REFERENCE_I12N, PCollectionType::NOT_EMPTY_SIZE),
+    TypeFactory.optional(KEY_ANNOTATIONS) => TYPE_ANNOTATIONS,
+  })
+
+
+  attr_reader :pcore_uri
+  attr_reader :pcore_version
+  attr_reader :name_authority
+  attr_reader :name
+  attr_reader :version
+  attr_reader :types
+  attr_reader :references
+  attr_reader :annotations
+
+  # Initialize a TypeSet Type instance. The initialization will use either a name and an initialization
+  # hash expression, or a fully resolved initialization hash.
+  #
+  # @overload initialize(name, i12n_hash_expression)
+  #   Used when the TypeSet type is loaded using a type alias expression. When that happens, it is important that
+  #   the actual resolution of the expression is deferred until all definitions have been made known to the current
+  #   loader. The package will then be resolved when it is loaded by the {TypeParser}. "resolved" here, means that
+  #   the hash expression is fully resolved, and then passed to the {#initialize_from_hash} method.
+  #   @param name [String] The name of the type set
+  #   @param i12n_hash_expression [Model::LiteralHash] The hash describing the TypeSet features
+  #   @param name_authority [String] The default name authority for the type set
+  #
+  # @overload initialize(i12n_hash)
+  #   Used when the package is created by the {TypeFactory}. The i12n_hash must be fully resolved.
+  #   @param i12n_hash [Hash{String=>Object}] The hash describing the TypeSet features
+  #
+  # @api private
+  def initialize(name_or_i12n_hash, i12n_hash_expression = nil, name_authority = nil)
+    @types = EMPTY_HASH
+    @references = EMPTY_HASH
+
+    if name_or_i12n_hash.is_a?(Hash)
+      initialize_from_hash(name_or_i12n_hash)
+    else
+      # Creation using "type XXX = TypeSet[{}]". This means that the name is given
+      @name = TypeAsserter.assert_instance_of('TypeSet name', Pcore::TYPE_QUALIFIED_REFERENCE, name_or_i12n_hash)
+      @name_authority = TypeAsserter.assert_instance_of('TypeSet name_authority', Pcore::TYPE_URI, name_authority, true)
+      @i12n_hash_expression = i12n_hash_expression
+    end
+  end
+
+  # @api private
+  def initialize_from_hash(i12n_hash)
+    TypeAsserter.assert_instance_of('TypeSet initializer', TYPE_TYPESET_I12N, i12n_hash)
+
+    # Name given to the loader have higher precedence than a name declared in the type
+    @name ||= i12n_hash[KEY_NAME].freeze
+    @name_authority ||= i12n_hash[KEY_NAME_AUTHORITY].freeze
+
+    @pcore_version = PSemVerType.convert(i12n_hash[Pcore::KEY_PCORE_VERSION]).freeze
+    unless Pcore::PARSABLE_PCORE_VERSIONS.include?(@pcore_version)
+      raise ArgumentError,
+        "The pcore version for TypeSet '#{@name}' is not understood by this runtime. Expected range #{Pcore::PARSABLE_PCORE_VERSIONS}, got #{@pcore_version}"
+    end
+
+    @pcore_uri = i12n_hash[Pcore::KEY_PCORE_URI].freeze
+    @version = PSemVerType.convert(i12n_hash[KEY_VERSION])
+    @types = i12n_hash[KEY_TYPES] || EMPTY_HASH
+    @types.freeze
+
+    # Map downcase names to their camel-cased equivalent
+    @dc_to_cc_map = {}
+    @types.keys.each { |key| @dc_to_cc_map[key.downcase] = key }
+
+    refs = i12n_hash[KEY_REFERENCES]
+    if refs.nil?
+      @references = EMPTY_HASH
+    else
+      ref_map = {}
+      root_map = Hash.new { |h, k| h[k] = {} }
+      refs.each do |ref_alias, ref|
+        ref = TypeSetReference.new(self, ref)
+
+        # Protect against importing the exact same name_authority/name combination twice if the version ranges intersect
+        ref_name = ref.name
+        ref_na = ref.name_authority || @name_authority
+        na_roots = root_map[ref_na]
+
+        ranges = na_roots[ref_name]
+        if ranges.nil?
+          na_roots[ref_name] = [ref.version_range]
+        else
+          unless ranges.all? { |range| (range & ref.version_range).nil? }
+            raise ArgumentError, "TypeSet '#{@name}' references TypeSet '#{ref_na}/#{ref_name}' more than once using overlapping version ranges"
+          end
+          ranges << ref.version_range
+        end
+
+        if ref_map.has_key?(ref_alias)
+          raise ArgumentError, "TypeSet '#{@name}' references a TypeSet using alias '#{ref_alias}' more than once"
+        end
+        if @types.has_key?(ref_alias)
+          raise ArgumentError, "TypeSet '#{@name}' references a TypeSet using alias '#{ref_alias}'. The alias collides with the name of a declared type"
+        end
+        ref_map[ref_alias] = ref
+
+        @dc_to_cc_map[ref_alias.downcase] = ref_alias
+        ref_map[ref_alias] = ref
+      end
+      @references = ref_map.freeze
+    end
+    @dc_to_cc_map.freeze
+    init_annotatable(i12n_hash)
+  end
+
+  # Produce a hash suitable for the initializer
+  # @return [Hash{String => Object}] the initialization hash
+  #
+  # @api private
+  def i12n_hash
+    result = super()
+    result[Pcore::KEY_PCORE_URI] = @pcore_uri unless @pcore_uri.nil?
+    result[Pcore::KEY_PCORE_VERSION] =  @pcore_version.to_s
+    result[KEY_NAME_AUTHORITY] = @name_authority unless @name_authority.nil?
+    result[KEY_NAME] = @name
+    result[KEY_VERSION] = @version.to_s
+    result[KEY_TYPES] = @types unless @types.empty?
+    result[KEY_REFERENCES] = Hash[@references.map { |ref_alias, ref| [ref_alias, ref.i12n_hash] }] unless @references.empty?
+    result
+  end
+
+  # Resolve a type in this type set using a qualified name. The resolved type may either be a type defined in this type set
+  # or a type defined in a type set that is referenced by this type set (nesting may occur to any level).
+  # The name resolution is case insensitive.
+  #
+  # @param qname [String] the qualified name of the type to resolve
+  # @return [PAnyType,nil] the resolved type, or `nil` in case no type could be found
+  #
+  # @api public
+  def [](qname)
+    type = @types[qname] || @types[@dc_to_cc_map[qname.downcase]]
+    if type.nil? && !@references.empty?
+      segments = qname.split(TypeFormatter::NAME_SEGMENT_SEPARATOR)
+      first = segments[0]
+      type_set_ref = @references[first] || @references[@dc_to_cc_map[first.downcase]]
+      if type_set_ref.nil?
+        nil
+      else
+        type_set = type_set_ref.type_set
+        case segments.size
+        when 1
+          type_set
+        when 2
+          type_set[segments[1]]
+        else
+          segments.shift
+          type_set[segments.join(TypeFormatter::NAME_SEGMENT_SEPARATOR)]
+        end
+      end
+    else
+      type
+    end
+  end
+
+  def defines_type?(t)
+    !@types.key(t).nil?
+  end
+
+  # Returns the name by which the given type is referenced from within this type set
+  # @param t [PAnyType]
+  # @return [String] the name by which the type is referenced within this type set
+  #
+  # @api private
+  def name_for(t, default_name)
+    key = @types.key(t)
+    if key.nil?
+      qname = t.name
+      if @references.empty?
+        default_name
+      else
+        @references.each_pair do |ref_key, ref|
+          ref_name = ref.type_set.name_for(t, nil)
+          return "#{ref_key}::#{ref_name}" unless ref_name.nil?
+        end
+        default_name
+      end
+    else
+      key
+    end
+  end
+
+  def accept(visitor, guard)
+    super
+    @types.each_value { |type| type.accept(visitor, guard) }
+    @references.each_value { |ref| ref.accept(visitor, guard) }
+  end
+
+  # @api private
+  def label
+    "TypeSet '#{@name}'"
+  end
+
+  # @api private
+  def resolve(type_parser, loader)
+    super
+    @references.each_value { |ref| ref.resolve(type_parser, loader) }
+    tsa_loader = TypeSetLoader.new(self, loader)
+    @types.values.each { |type| type.resolve(type_parser, tsa_loader) }
+    self
+  end
+
+  # @api private
+  def resolve_literal_hash(type_parser, loader, i12n_hash_expression)
+    result = {}
+    i12n_hash_expression.entries.each do |entry|
+      key = type_parser.interpret_any(entry.key, loader)
+      if (key == KEY_TYPES || key == KEY_REFERENCES) && entry.value.is_a?(Model::LiteralHash)
+        # Skip type parser interpretation and convert qualified references directly to String keys.
+        hash = {}
+        entry.value.entries.each do |he|
+          kex = he.key
+          name = kex.is_a?(Model::QualifiedReference) ? kex.cased_value : type_parser.interpret_any(kex, loader)
+          hash[name] = key == KEY_TYPES ? he.value : type_parser.interpret_any(he.value, loader)
+        end
+        result[key] = hash
+      else
+        result[key] = type_parser.interpret_any(entry.value, loader)
+      end
+    end
+
+    name_auth = resolve_name_authority(result, loader)
+
+    types = result[KEY_TYPES]
+    if types.is_a?(Hash)
+      types.each do |type_name, value|
+        full_name = "#{@name}::#{type_name}".freeze
+        typed_name = Loader::TypedName.new(:type, full_name.downcase, name_auth)
+        type = Loader::TypeDefinitionInstantiator.create_type(full_name, value, name_auth)
+        loader.set_entry(typed_name, type, Adapters::SourcePosAdapter.adapt(value).to_uri)
+        types[type_name] = type
+      end
+    end
+    result
+  end
+
+  # @api private
+  def resolve_hash(type_parser, loader, i12n_hash)
+    result = Hash[i12n_hash.map do |key, value|
+      key = resolve_type_refs(type_parser, loader, key)
+      value = resolve_type_refs(type_parser, loader, value) unless key == KEY_TYPES && value.is_a?(Hash)
+      [key, value]
+    end]
+    name_auth = resolve_name_authority(result, loader)
+    types = result[KEY_TYPES]
+    if types.is_a?(Hash)
+      types.each do |type_name, value|
+        full_name = "#{@name}::#{type_name}".freeze
+        typed_name = Loader::TypedName.new(:type, full_name.downcase, name_auth)
+        meta_name = value.is_a?(Hash) ? 'Object' : 'TypeAlias'
+        type = Loader::TypeDefinitionInstantiator.create_named_type(full_name, meta_name, value, name_auth)
+        loader.set_entry(typed_name, type)
+        types[type_name] = type
+      end
+    end
+    result
+  end
+
+  def hash
+    @name_authority.hash ^ @name.hash ^ @version.hash
+  end
+
+  def eql?(o)
+    self.class == o.class && @name_authority == o.name_authority && @name == o.name && @version == o.version
+  end
+
+  DEFAULT = self.new({
+    KEY_NAME => 'DefaultTypeSet',
+    KEY_NAME_AUTHORITY => Pcore::RUNTIME_NAME_AUTHORITY,
+    Pcore::KEY_PCORE_URI => Pcore::PCORE_URI,
+    Pcore::KEY_PCORE_VERSION => Pcore::PCORE_VERSION,
+    KEY_VERSION => SemanticPuppet::Version.new(0,0,0)
+  })
+
+  protected
+
+  # @api_private
+  def _assignable?(o, guard)
+    self.class == o.class && (self == DEFAULT || eql?(o))
+  end
+
+  private
+
+  def resolve_name_authority(i12n_hash, loader)
+    name_auth = @name_authority
+    if name_auth.nil?
+      name_auth = i12n_hash[KEY_NAME_AUTHORITY]
+      name_auth = loader.name_authority if name_auth.nil? && loader.is_a?(TypeSetLoader)
+      if name_auth.nil?
+        name = @name || i12n_hash[KEY_NAME]
+        raise ArgumentError, "No 'name_authority' is declared in TypeSet '#{name}' and it cannot be inferred"
+      end
+    end
+    name_auth
+  end
+end
+end
+end

data/lib/puppet/pops/types/puppet_object.rb

@@ -0,0 +1,16 @@
+module Puppet::Pops
+module Types
+
+# Marker module for implementations that are mapped to Object types
+# @api public
+module PuppetObject
+  # Returns the Puppet Type for this instance. The implementing class must
+  # add the {#_ptype} as a class method.
+  #
+  # @return [PObjectType] the type
+  def _ptype
+    self.class._ptype
+  end
+end
+end
+end

data/lib/puppet/pops/types/recursion_guard.rb

@@ -0,0 +1,136 @@
+module Puppet::Pops
+module Types
+# Keeps track of self recursion of conceptual 'this' and 'that' instances using two separate maps and
+# a state. The class is used when tracking self recursion in two objects ('this' and 'that') simultaneously.
+# A typical example of when this is needed is when testing if 'that' Puppet Type is assignable to 'this'
+# Puppet Type since both types may contain self references.
+#
+# All comparisons are made using the `object_id` of the instance rather than the instance itself.
+#
+# @api private
+class RecursionGuard
+  attr_reader :state
+
+  NO_SELF_RECURSION = 0
+  SELF_RECURSION_IN_THIS = 1
+  SELF_RECURSION_IN_THAT = 2
+  SELF_RECURSION_IN_BOTH = 3
+
+  def initialize
+    @state = NO_SELF_RECURSION
+  end
+
+  # Checks if recursion was detected for the given argument in the 'this' context
+  # @param instance [Object] the instance to check
+  # @return [Integer] the resulting state
+  def recursive_this?(instance)
+    instance_variable_defined?(:@recursive_this_map) && @recursive_this_map.has_key?(instance.object_id)
+  end
+
+  # Checks if recursion was detected for the given argument in the 'that' context
+  # @param instance [Object] the instance to check
+  # @return [Integer] the resulting state
+  def recursive_that?(instance)
+    instance_variable_defined?(:@recursive_that_map) && @recursive_that_map.has_key?(instance.object_id)
+  end
+
+  # Add the given argument as 'this' invoke the given block with the resulting state
+  # @param instance [Object] the instance to add
+  # @return [Object] the result of yielding
+  def with_this(instance)
+    if (@state & SELF_RECURSION_IN_THIS) == 0
+      tc = this_count
+      @state = @state | SELF_RECURSION_IN_THIS if this_put(instance)
+      if tc < this_count
+        # recursive state detected
+        result = yield(@state)
+
+        # pop state
+        @state &= ~SELF_RECURSION_IN_THIS
+        @this_map.delete(instance.object_id)
+        return result
+      end
+    end
+    yield(@state)
+  end
+
+  # Add the given argument as 'that' invoke the given block with the resulting state
+  # @param instance [Object] the instance to add
+  # @return [Object] the result of yielding
+  def with_that(instance)
+    if (@state & SELF_RECURSION_IN_THAT) == 0
+      tc = that_count
+      @state = @state | SELF_RECURSION_IN_THAT if that_put(instance)
+      if tc < that_count
+        # recursive state detected
+        result = yield(@state)
+
+        # pop state
+        @state &= ~SELF_RECURSION_IN_THAT
+        @that_map.delete(instance.object_id)
+        return result
+      end
+    end
+    yield(@state)
+  end
+
+  # Add the given argument as 'this' and return the resulting state
+  # @param instance [Object] the instance to add
+  # @return [Integer] the resulting state
+  def add_this(instance)
+    if (@state & SELF_RECURSION_IN_THIS) == 0
+      @state = @state | SELF_RECURSION_IN_THIS if this_put(instance)
+    end
+    @state
+  end
+
+  # Add the given argument as 'that' and return the resulting state
+  # @param instance [Object] the instance to add
+  # @return [Integer] the resulting state
+  def add_that(instance)
+    if (@state & SELF_RECURSION_IN_THAT) == 0
+      @state = @state | SELF_RECURSION_IN_THAT if that_put(instance)
+    end
+    @state
+  end
+
+  # @return the number of objects added to the `this` map
+  def this_count
+    instance_variable_defined?(:@this_map) ? @this_map.size : 0
+  end
+
+  # @return the number of objects added to the `that` map
+  def that_count
+    instance_variable_defined?(:@that_map) ? @that_map.size : 0
+  end
+
+  private
+
+  def this_put(o)
+    id = o.object_id
+    @this_map ||= {}
+    if @this_map.has_key?(id)
+      @recursive_this_map ||= {}
+      @recursive_this_map[id] = true
+      true
+    else
+      @this_map[id] = true
+      false
+    end
+  end
+
+  def that_put(o)
+    id = o.object_id
+    @that_map ||= {}
+    if @that_map.has_key?(id)
+      @recursive_that_map ||= {}
+      @recursive_that_map[id] = true
+      true
+    else
+      @that_map[id] = true
+      false
+    end
+  end
+end
+end
+end