bolt 0.7.0 → 0.8.0

data/vendored/puppet/lib/puppet/pops/pcore.rb

@@ -42,6 +42,15 @@ module Pcore
     if Puppet[:tasks]
       require_relative 'types/task'
       require_relative 'types/execution_result'
+
+      add_object_type('Target', <<-PUPPET, loader)
+      {
+        attributes => {
+          host => String[1],
+          options => { type => Hash[String[1], Data], value => {} }
+        }
+      }
+      PUPPET
     end
     Types::TypedModelObject.register_ptypes(loader, ir)
 

data/vendored/puppet/lib/puppet/pops/serialization/from_data_converter.rb

@@ -1,5 +1,57 @@
 module Puppet::Pops
 module Serialization
+  class Builder
+    def initialize(values)
+      @values = values
+      @resolved = true
+    end
+
+    def [](key)
+      @values[key]
+    end
+
+    def []=(key, value)
+      @values[key] = value
+      @resolved = false if value.is_a?(Builder)
+    end
+
+    def resolve
+      unless @resolved
+        @resolved = true
+        if @values.is_a?(Array)
+          @values.each_with_index { |v, idx| @values[idx] = v.resolve if v.is_a?(Builder) }
+        elsif @values.is_a?(Hash)
+          @values.each_pair { |k, v| @values[k] = v.resolve if v.is_a?(Builder) }
+        end
+      end
+      @values
+    end
+  end
+
+  class ObjectHashBuilder < Builder
+    def initialize(instance)
+      super({})
+      @instance = instance
+    end
+
+    def resolve
+      @instance._pcore_init_from_hash(super)
+      @instance
+    end
+  end
+
+  class ObjectArrayBuilder < Builder
+    def initialize(instance)
+      super({})
+      @instance = instance
+    end
+
+    def resolve
+      @instance.send(:initialize, *super.values)
+      @instance
+    end
+  end
+
   # Class that can process the `Data` produced by the {ToDataConverter} class and reassemble
   # the objects that were converted.
   #
@@ -137,9 +189,16 @@ module Serialization
     end
 
     def build(value, &block)
-      @current[@key] = value unless @current.nil?
-      with_value(value, &block) if block_given?
-      value
+      vx = Builder.new(value)
+      @current[@key] = vx unless @current.nil?
+      with_value(vx, &block) if block_given?
+      vx.resolve
+    end
+
+    def build_object(builder, &block)
+      @current[@key] = builder unless @current.nil?
+      with_value(builder, &block) if block_given?
+      builder.resolve
     end
 
     def pcore_type_hash_to_value(pcore_type, value)
@@ -148,14 +207,9 @@ module Serialization
         if value.empty?
           build(pcore_type.create)
         elsif pcore_type.implementation_class.respond_to?(:_pcore_init_from_hash)
-          build(pcore_type.allocate) do
-            @current._pcore_init_from_hash(with_value({}) { value.each_pair { |key, elem| with(key) { convert(elem) } } })
-          end
+          build_object(ObjectHashBuilder.new(pcore_type.allocate)) { value.each_pair { |key, elem| with(key) { convert(elem) } } }
         else
-          build(pcore_type.allocate) do
-            args = with_value([]) { value.values.each_with_index { |elem, idx| with(idx) { convert(elem) }}}
-            @current.send(:initialize, *args)
-          end
+          build_object(ObjectArrayBuilder.new(pcore_type.allocate)) { value.each_pair { |key, elem| with(key) { convert(elem) } } }
         end
       elsif value.is_a?(String)
         build(pcore_type.create(value))

data/vendored/puppet/lib/puppet/pops/serialization/json_path.rb

@@ -47,7 +47,8 @@ module JsonPath
     #
     def resolve(context, path)
       factory = @parser.parse_string(path)
-      resolve_any(factory.model.body, context, path)
+      v = resolve_any(factory.model.body, context, path)
+      v.is_a?(Builder) ? v.resolve : v
     end
 
     def resolve_any(ast, context, path)

data/vendored/puppet/lib/puppet/pops/types/execution_result.rb

@@ -62,7 +62,8 @@ module Types
 
     def error_nodes
       result = {}
-      @result_hash.each_pair { |k, v| result[k] = v if v.is_a?(PErrorType::Error) }
+      t = TypeFactory.error
+      @result_hash.each_pair { |k, v| result[k] = v if t.instance?(v) }
       self.class.new(result)
     end
 
@@ -75,13 +76,15 @@ module Types
     end
 
     def ok
-      !@result_hash.values.any? { |v| v.is_a?(PErrorType::Error) }
+      t = TypeFactory.error
+      !@result_hash.values.any? { |v| t.instance?(v) }
     end
     alias_method :ok?, :ok
 
     def ok_nodes
       result = {}
-      @result_hash.each_pair { |k, v| result[k] = v unless v.is_a?(PErrorType::Error) }
+      t = TypeFactory.error
+      @result_hash.each_pair { |k, v| result[k] = v unless t.instance?(v) }
       self.class.new(result)
     end
 
@@ -116,7 +119,7 @@ module Types
       if error.nil?
         value
       else
-        PErrorType::Error.new(error['msg'], error['kind'], error['issue_code'] || PErrorType::DEFAULT_ISSUE_CODE, value, error['details'])
+        TypeFactory.error.create(error['msg'], error['kind'], error['issue_code'], value, error['details'])
       end
     end
 

data/vendored/puppet/lib/puppet/pops/types/p_binary_type.rb

@@ -2,8 +2,15 @@ require 'base64'
 module Puppet::Pops
 module Types
 
-# A Puppet Language Type that exposes the {{SemanticPuppet::Version}} and {{SemanticPuppet::VersionRange}}.
-# The version type is parameterized with version ranges.
+# A Puppet Language Type that represents binary data content (a sequence of 8-bit bytes).
+# Instances of this data type can be created from `String` and `Array[Integer[0,255]]`
+# values. Also see the `binary_file` function for reading binary content from a file.
+#
+# A `Binary` can be converted to `String` and `Array` form - see function `new` for
+# the respective target data type for more information.
+#
+# Instances of this data type serialize as base 64 encoded strings when the serialization
+# format is textual, and as binary content when a serialization format supports this.
 #
 # @api public
 class PBinaryType < PAnyType

data/vendored/puppet/lib/puppet/pops/types/p_init_type.rb

@@ -156,7 +156,7 @@ class PInitType < PTypeWithContainedType
     rescue ArgumentError
       raise ArgumentError, _("Creation of new instance of type '%{type_name}' is not supported") % { type_name: @type.to_s }
     end
-    param_tuples = new_func.dispatcher.dispatchers.map { |closure| closure.type.param_types }
+    param_tuples = new_func.dispatcher.signatures.map { |closure| closure.type.param_types }
 
     # An instance of the contained type is always a match to this type.
     single_types = [@type]

data/vendored/puppet/lib/puppet/pops/types/p_meta_type.rb

@@ -78,6 +78,10 @@ class PMetaType < PAnyType
     end
   end
 
+  def resolved?
+    @init_hash_expression.nil?
+  end
+
   # Returns the expanded string the form of the alias, e.g. <alias name> = <resolved type>
   #
   # @return [String] the expanded form of this alias

data/vendored/puppet/lib/puppet/pops/types/p_object_type.rb

@@ -13,6 +13,7 @@ KEY_FUNCTIONS = 'functions'.freeze
 KEY_KIND = 'kind'.freeze
 KEY_OVERRIDE = 'override'.freeze
 KEY_PARENT = 'parent'.freeze
+KEY_TYPE_PARAMETERS = 'type_parameters'.freeze
 
 # @api public
 class PObjectType < PMetaType
@@ -34,8 +35,14 @@ class PObjectType < PMetaType
     TypeFactory.optional(KEY_ANNOTATIONS) => TYPE_ANNOTATIONS
   })
 
+  TYPE_PARAMETER = TypeFactory.struct({
+    KEY_TYPE => PTypeType::DEFAULT,
+    TypeFactory.optional(KEY_ANNOTATIONS) => TYPE_ANNOTATIONS
+  })
+
   TYPE_CONSTANTS = TypeFactory.hash_kv(Pcore::TYPE_MEMBER_NAME, PAnyType::DEFAULT)
   TYPE_ATTRIBUTES = TypeFactory.hash_kv(Pcore::TYPE_MEMBER_NAME, TypeFactory.not_undef)
+  TYPE_PARAMETERS = TypeFactory.hash_kv(Pcore::TYPE_MEMBER_NAME, TypeFactory.not_undef)
   TYPE_ATTRIBUTE_CALLABLE = TypeFactory.callable(0,0)
 
   TYPE_FUNCTION_TYPE = PTypeType.new(PCallableType::DEFAULT)
@@ -55,6 +62,7 @@ class PObjectType < PMetaType
   TYPE_OBJECT_I12N = TypeFactory.struct({
     TypeFactory.optional(KEY_NAME) => TYPE_OBJECT_NAME,
     TypeFactory.optional(KEY_PARENT) => PTypeType::DEFAULT,
+    TypeFactory.optional(KEY_TYPE_PARAMETERS) => TYPE_PARAMETERS,
     TypeFactory.optional(KEY_ATTRIBUTES) => TYPE_ATTRIBUTES,
     TypeFactory.optional(KEY_CONSTANTS) => TYPE_CONSTANTS,
     TypeFactory.optional(KEY_FUNCTIONS) => TYPE_FUNCTIONS,
@@ -335,6 +343,22 @@ class PObjectType < PMetaType
     end
   end
 
+  class PTypeParameter < PAttribute
+    # @return [Hash{String=>Object}] the hash
+    # @api private
+    def _pcore_init_hash
+      hash = super
+      hash[KEY_TYPE] = hash[KEY_TYPE].type
+      hash.delete(KEY_VALUE) if hash.include?(KEY_VALUE) && hash[KEY_VALUE].nil?
+      hash
+    end
+
+    # @api private
+    def self.feature_type
+      'type_parameter'
+    end
+  end
+
   # Describes a named Function in an Object type
   # @api public
   class PFunction < PAnnotatedMember
@@ -359,8 +383,6 @@ class PObjectType < PMetaType
 
   attr_reader :name
   attr_reader :parent
-  attr_reader :attributes
-  attr_reader :functions
   attr_reader :equality
   attr_reader :checks
   attr_reader :annotations
@@ -387,6 +409,7 @@ class PObjectType < PMetaType
       _pcore_init_from_hash(_pcore_init_hash)
       @loader = init_hash_expression unless init_hash_expression.nil?
     else
+      @type_parameters = EMPTY_HASH
       @attributes = EMPTY_HASH
       @functions = EMPTY_HASH
       @name = TypeAsserter.assert_instance_of('object name', TYPE_OBJECT_NAME, _pcore_init_hash)
@@ -595,6 +618,7 @@ class PObjectType < PMetaType
   # @api private
   def _pcore_init_from_hash(init_hash)
     TypeAsserter.assert_instance_of('object initializer', TYPE_OBJECT_I12N, init_hash)
+    @type_parameters = EMPTY_HASH
     @attributes = EMPTY_HASH
     @functions = EMPTY_HASH
 
@@ -605,6 +629,7 @@ class PObjectType < PMetaType
     @parent = init_hash[KEY_PARENT]
 
     parent_members = EMPTY_HASH
+    parent_type_params = EMPTY_HASH
     parent_object_type = nil
     unless @parent.nil?
       check_self_recursion(self)
@@ -613,6 +638,24 @@ class PObjectType < PMetaType
       if rp.is_a?(PObjectType)
         parent_object_type = rp
         parent_members = rp.members(true)
+        parent_type_params = rp.type_parameters(true)
+      end
+    end
+
+    type_parameters = init_hash[KEY_TYPE_PARAMETERS]
+    unless type_parameters.nil? || type_parameters.empty?
+      @type_parameters = {}
+      type_parameters.each do |key, param_spec|
+        param_value = :undef
+        if param_spec.is_a?(Hash)
+          param_type = param_spec[KEY_TYPE]
+          param_value = param_spec[KEY_VALUE] if param_spec.include?(KEY_VALUE)
+        else
+          param_type = TypeAsserter.assert_instance_of(nil, PTypeType::DEFAULT, param_spec) { "type_parameter #{label}[#{key}]" }
+        end
+        param_type = POptionalType.new(param_type) unless param_type.is_a?(POptionalType)
+        type_param = PTypeParameter.new(key, self, KEY_TYPE => param_type, KEY_VALUE => param_value).assert_override(parent_type_params)
+        @type_parameters[key] = type_param
       end
     end
 
@@ -634,7 +677,7 @@ class PObjectType < PMetaType
           KEY_KIND => ATTRIBUTE_KIND_CONSTANT
         }
         # Indicate override if parent member exists. Type check etc. will take place later on.
-        attr_spec[KEY_OVERRIDE] = true if parent_members.include?(key)
+        attr_spec[KEY_OVERRIDE] = parent_members.include?(key)
         attr_specs[key] = attr_spec
       end
     end
@@ -715,6 +758,7 @@ class PObjectType < PMetaType
     guarded_recursion(guard, nil) do |g|
       super(visitor, g)
       @parent.accept(visitor, g) unless parent.nil?
+      @type_parameters.values.each { |p| p.accept(visitor, g) }
       @attributes.values.each { |a| a.accept(visitor, g) }
       @functions.values.each { |f| f.accept(visitor, g) }
     end
@@ -771,6 +815,7 @@ class PObjectType < PMetaType
     result = super()
     result[KEY_NAME] = @name if include_name && !@name.nil?
     result[KEY_PARENT] = @parent unless @parent.nil?
+    result[KEY_TYPE_PARAMETERS] = compressed_members_hash(@type_parameters) unless @type_parameters.empty?
     unless @attributes.empty?
       # Divide attributes into constants and others
       tc = TypeCalculator.singleton
@@ -795,6 +840,7 @@ class PObjectType < PMetaType
     self.class == o.class &&
       @name == o.name &&
       @parent == o.parent &&
+      @type_parameters == o.type_parameters &&
       @attributes == o.attributes &&
       @functions == o.functions &&
       @equality == o.equality &&
@@ -802,7 +848,7 @@ class PObjectType < PMetaType
   end
 
   def hash
-    @name.nil? ? [@parent, @attributes, @functions].hash : @name.hash
+    @name.nil? ? [@parent, @type_parameters, @attributes, @functions].hash : @name.hash
   end
 
   def kind_of_callable?(optional=true, guard = nil)
@@ -817,6 +863,14 @@ class PObjectType < PMetaType
     @parent.nil? ? false : @parent.iterable_type(guard)
   end
 
+  def parameterized?
+    if @type_parameters.empty?
+      @parent.is_a?(PObjectType) ? @parent.parameterized? : false
+    else
+      true
+    end
+  end
+
   # Returns the members (attributes and functions) of this `Object` type. If _include_parent_ is `true`, then all
   # inherited members will be included in the returned `Hash`.
   #
@@ -891,6 +945,18 @@ class PObjectType < PMetaType
     label.split(DOUBLE_COLON).last
   end
 
+  # Returns the type_parameters of this `Object` type. If _include_parent_ is `true`, then all
+  # inherited type_parameters will be included in the returned `Hash`.
+  #
+  # @param include_parent [Boolean] `true` if inherited type_parameters should be included
+  # @return [Hash{String=>PTypeParameter}] a hash with the type_parameters
+  # @api public
+  def type_parameters(include_parent = false)
+    all = {}
+    collect_type_parameters(all, include_parent)
+    all
+  end
+
   protected
 
   # An Object type is only assignable from another Object type. The other type
@@ -903,6 +969,8 @@ class PObjectType < PMetaType
         op = o.parent
         op.nil? ? false : assignable?(op, guard)
       end
+    elsif o.is_a?(PObjectTypeExtension)
+      assignable?(o.base_type, guard)
     else
       false
     end
@@ -936,6 +1004,15 @@ class PObjectType < PMetaType
     nil
   end
 
+  def collect_type_parameters(collector, include_parent)
+    if include_parent
+      parent = resolved_parent
+      parent.collect_type_parameters(collector, include_parent) if parent.is_a?(PObjectType)
+    end
+    collector.merge!(@type_parameters)
+    nil
+  end
+
   private
 
   def compressed_members_hash(features)

data/vendored/puppet/lib/puppet/pops/types/p_object_type_extension.rb

@@ -0,0 +1,213 @@
+module Puppet::Pops
+module Types
+
+# Base class for Parameterized Object implementations. The wrapper impersonates the base
+# object and extends it with methods to filter assignable types and instances based on parameter
+# values.
+#
+# @api public
+class PObjectTypeExtension < PAnyType
+  def self.register_ptype(loader, ir)
+    create_ptype(loader, ir, 'AnyType',
+      'base_type' => {
+        KEY_TYPE => PTypeType::DEFAULT
+      },
+      'init_parameters' => {
+        KEY_TYPE => PArrayType::DEFAULT
+      }
+    )
+  end
+
+  attr_reader :base_type, :parameters
+
+  # @api private
+  def self.create(base_type, init_parameters)
+    impl_class = Loaders.implementation_registry.module_for_type("#{base_type.name}TypeExtension") || self
+    impl_class.new(base_type, init_parameters)
+  end
+
+  # @api private
+  def initialize(base_type, init_parameters)
+    pts = base_type.type_parameters(true)
+    raise Puppet::ParseError, _('The %{label}-Type cannot be parameterized using []') % { label: base_type.label } if pts.empty?
+    @base_type = base_type
+
+    named_args = false
+    if init_parameters.is_a?(PuppetObject)
+      init_parameters = parameters_from_instance(init_parameters, pts)
+    else
+      named_args = init_parameters.size == 1 && init_parameters[0].is_a?(Hash)
+      if named_args
+        # Catch case when first parameter is an assignable Hash
+        named_args = pts.size >= 1 && !pts.values[0].type.instance?(init_parameters[0])
+      end
+    end
+
+    by_name = {}
+    if named_args
+      hash = init_parameters[0]
+      hash.each_pair do |pn, pv|
+        tp = pts[pn]
+        if tp.nil?
+          raise Puppet::ParseError, _("'%{pn}' is not a known type parameter for %{label}-Type") % { pn: pn, label: base_type.label }
+        end
+        by_name[pn] = check_param(tp, pv) unless pv == :default
+      end
+    else
+      pts.values.each_with_index do |tp, idx|
+        if idx < init_parameters.size
+          pv = init_parameters[idx]
+          by_name[tp.name] = check_param(tp, pv) unless pv == :default
+        end
+      end
+    end
+    if by_name.empty?
+      raise Puppet::ParseError, _('The %{label}-Type cannot be parameterized using an empty parameter list') % { label: base_type.label }
+    end
+    @parameters = by_name
+  end
+
+  def check_param(type_param, v)
+    TypeAsserter.assert_instance_of(nil, type_param.type, v) { type_param.label }
+  end
+
+  # Return the parameter values as positional arguments with unset values as :default. The
+  # array is stripped from trailing :default values
+  # @return [Array] the parameter values
+  # @api private
+  def init_parameters
+    pts = @base_type.type_parameters(true)
+    if pts.size > 2
+      @parameters
+    else
+      result = pts.values.map do |tp|
+        pn = tp.name
+        @parameters.include?(pn) ? @parameters[pn] : :default
+      end
+      # Remove trailing defaults
+      result.pop while result.last == :default
+      result
+    end
+  end
+
+  # @api private
+  def eql?(o)
+    super(o) && @base_type.eql?(o.base_type) && @parameters.eql?(o.parameters)
+  end
+
+  # @api private
+  def generalize
+    @base_type
+  end
+
+  # @api private
+  def hash
+    @base_type.hash ^ @parameters.hash
+  end
+
+  # @api private
+  def loader
+    @base_type.loader
+  end
+
+  # @api private
+  def check_self_recursion(originator)
+    @base_type.check_self_recursion(originator)
+  end
+
+  # @api private
+  def create(*args)
+    @base_type.create(*args)
+  end
+
+  # @api private
+  def instance?(o, guard = nil)
+    @base_type.instance?(o, guard) && test_instance?(o, guard)
+  end
+
+  # @api private
+  def new_function
+    @base_type.new_function
+  end
+
+  # @api private
+  def simple_name
+    @base_type.simple_name
+  end
+
+  protected
+
+  # Creates an array of type parameters from the attributes that matches the
+  # type parameters by name. Type parameters for which there is no matching attribute
+  # will have `nil` in their corresponding position on the array.
+  #
+  # @return [Array] array of values from instance that maps to type parameters
+  def parameters_from_instance(instance, type_parameters)
+    attrs = @base_type.attributes(true)
+    type_parameters.keys.map do |pn|
+      attr = attrs[pn]
+      attr.nil? ? nil : instance.send(pn)
+    end
+  end
+
+  # Checks that the given `param_values` hash contains all keys present in the `parameters` of
+  # this instance and that each keyed value is a match for the given parameter. The match is done
+  # using case expression semantics.
+  #
+  # This method is only called when a given type is found to be assignable to the base type of
+  # this extension.
+  #
+  # @param param_values[Hash] the parameter values of the assignable type
+  # @param guard[RecursionGuard] guard against endless recursion
+  # @return [Boolean] true or false to indicate assignability
+  # @api public
+  def test_assignable?(param_values, guard)
+    # Default implementation performs case expression style matching of all parameter values
+    # provided that the value exist (this should always be the case, since all defaults have
+    # been assigned at this point)
+    eval = Parser::EvaluatingParser.singleton.evaluator
+    @parameters.keys.all? do |pn|
+      if param_values.include?(pn)
+        a = param_values[pn]
+        b = @parameters[pn]
+        eval.match?(a, b) || a.is_a?(PAnyType) && b.is_a?(PAnyType) && b.assignable?(a)
+      else
+        false
+      end
+    end
+  end
+
+  # Checks that the given instance `o` has one attribute for each key present in the `parameters` of
+  # this instance and that each attribute value is a match for the given parameter. The match is done
+  # using case expression semantics.
+  #
+  # This method is only called when the given value is found to be an instance of the base type of
+  # this extension.
+  #
+  # @param o [Object] the instance to test
+  # @param guard[RecursionGuard] guard against endless recursion
+  # @return [Boolean] true or false to indicate if the value is an instance or not
+  # @api public
+  def test_instance?(o, guard)
+    eval = Parser::EvaluatingParser.singleton.evaluator
+    @parameters.keys.all? do |pn|
+      begin
+        m = o.public_method(pn)
+        m.arity == 0 ? eval.match?(m.call, @parameters[pn]) : false
+      rescue NameError
+        false
+      end
+    end
+  end
+
+  # @api private
+  def _assignable?(o, guard = nil)
+    if o.is_a?(PObjectTypeExtension)
+      @base_type.assignable?(o.base_type, guard) && test_assignable?(o.parameters, guard)
+    else
+      @base_type.assignable?(o, guard) && test_assignable?(EMPTY_HASH, guard)
+    end
+  end
+end
+end
+end