bolt 0.8.0 → 0.9.0

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

@@ -170,6 +170,10 @@ class AbstractReader
       # are written as binary data.
       read_payload(data) { |ep| Types::PBinaryType::Binary.new(ep.read) }
     end
+
+    register_type(Extension::URI) do |data|
+      read_payload(data) { |ep| URI(ep.read) }
+    end
   end
 end
 end

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

@@ -201,6 +201,12 @@ class AbstractWriter
         build_payload { |ep| ep.write(o.to_s) }
       end
     end
+
+    URI.scheme_list.values.each do |uri_class|
+      register_type(Extension::URI, uri_class) do |o|
+        build_payload { |ep| ep.write(o.to_s) }
+      end
+    end
   end
 
   def to_s

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

@@ -30,6 +30,7 @@ module Extension
   VERSION_RANGE = 0x36
   BINARY = 0x37
   BASE64 = 0x38
+  URI    = 0x39
 
   # Marker module indicating whether or not an instance is tabulated or not
   module NotTabulated; end

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

@@ -108,7 +108,8 @@ module Serialization
           value.instance_of?(SemanticPuppet::VersionRange),
           value.instance_of?(Time::Timestamp),
           value.instance_of?(Time::Timespan),
-          value.instance_of?(Types::PBinaryType::Binary)
+          value.instance_of?(Types::PBinaryType::Binary),
+          value.is_a?(URI)
         push_written(value)
         @writer.write(value)
       when value.instance_of?(Array)

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

@@ -104,6 +104,14 @@ module Types
       @result_hash
     end
 
+    def eql?(o)
+      self.class == o.class && self.result_hash == o.result_hash
+    end
+
+    def ==(o)
+      eql?(o)
+    end
+
     private
 
     def convert_errors(result_hash)

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

@@ -89,6 +89,8 @@ module Puppet::Pops::Types
         o.finite_range? ? IntegerRangeIterator.new(o) : nil
       when PEnumType
         Iterator.new(o, o.values.each)
+      when PTypeAliasType
+        on(o.resolved_type)
       when Range
         min = o.min
         max = o.max

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

@@ -1,4 +1,5 @@
 require_relative 'ruby_generator'
+require_relative 'type_with_members'
 
 module Puppet::Pops
 module Types
@@ -17,6 +18,7 @@ KEY_TYPE_PARAMETERS = 'type_parameters'.freeze
 
 # @api public
 class PObjectType < PMetaType
+  include TypeWithMembers
 
   ATTRIBUTE_KIND_CONSTANT = 'constant'.freeze
   ATTRIBUTE_KIND_DERIVED = 'derived'.freeze
@@ -89,6 +91,7 @@ class PObjectType < PMetaType
   # @api public
   class PAnnotatedMember
     include Annotatable
+    include InvocableMember
 
     # @return [PObjectType] the object type containing this member
     # @api public

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

@@ -7,6 +7,8 @@ module Types
 #
 # @api public
 class PObjectTypeExtension < PAnyType
+  include TypeWithMembers
+
   def self.register_ptype(loader, ir)
     create_ptype(loader, ir, 'AnyType',
       'base_type' => {
@@ -26,6 +28,10 @@ class PObjectTypeExtension < PAnyType
     impl_class.new(base_type, init_parameters)
   end
 
+  def [](name)
+    @base_type[name]
+  end
+
   # @api private
   def initialize(base_type, init_parameters)
     pts = base_type.type_parameters(true)

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

@@ -0,0 +1,191 @@
+module Puppet::Pops
+module Types
+class PURIType < PAnyType
+
+  # Tell evaluator that an members of instances of this type can be invoked using dot notation
+  include TypeWithMembers
+
+  SCHEME = 'scheme'.freeze
+  USERINFO = 'userinfo'.freeze
+  HOST = 'host'.freeze
+  PORT = 'port'.freeze
+  PATH = 'path'.freeze
+  QUERY = 'query'.freeze
+  FRAGMENT = 'fragment'.freeze
+  OPAQUE = 'opaque'.freeze
+
+  URI_MEMBERS = {
+    SCHEME => AttrReader.new(SCHEME),
+    USERINFO => AttrReader.new(USERINFO),
+    HOST => AttrReader.new(HOST),
+    PORT => AttrReader.new(PORT),
+    PATH => AttrReader.new(PATH),
+    QUERY => AttrReader.new(QUERY),
+    FRAGMENT => AttrReader.new(FRAGMENT),
+    OPAQUE => AttrReader.new(OPAQUE),
+  }
+
+  TYPE_URI_INIT_HASH = TypeFactory.struct(
+    TypeFactory.optional(SCHEME) => PStringType::NON_EMPTY,
+    TypeFactory.optional(USERINFO) => PStringType::NON_EMPTY,
+    TypeFactory.optional(HOST) => PStringType::NON_EMPTY,
+    TypeFactory.optional(PORT) => PIntegerType.new(0),
+    TypeFactory.optional(PATH) => PStringType::NON_EMPTY,
+    TypeFactory.optional(QUERY) => PStringType::NON_EMPTY,
+    TypeFactory.optional(FRAGMENT) => PStringType::NON_EMPTY,
+    TypeFactory.optional(OPAQUE) => PStringType::NON_EMPTY,
+  )
+
+  TYPE_STRING_PARAM = TypeFactory.optional(PVariantType.new([
+    PStringType::NON_EMPTY,
+    PRegexpType::DEFAULT,
+    TypeFactory.type_type(PPatternType::DEFAULT),
+    TypeFactory.type_type(PEnumType::DEFAULT),
+    TypeFactory.type_type(PNotUndefType::DEFAULT),
+    TypeFactory.type_type(PUndefType::DEFAULT),
+  ]))
+
+  TYPE_INTEGER_PARAM = TypeFactory.optional(PVariantType.new([
+    PIntegerType.new(0),
+    TypeFactory.type_type(PNotUndefType::DEFAULT),
+    TypeFactory.type_type(PUndefType::DEFAULT),
+  ]))
+
+  TYPE_URI_PARAM_HASH_TYPE = TypeFactory.struct(
+    TypeFactory.optional(SCHEME) => TYPE_STRING_PARAM,
+    TypeFactory.optional(USERINFO) => TYPE_STRING_PARAM,
+    TypeFactory.optional(HOST) => TYPE_STRING_PARAM,
+    TypeFactory.optional(PORT) => TYPE_INTEGER_PARAM,
+    TypeFactory.optional(PATH) => TYPE_STRING_PARAM,
+    TypeFactory.optional(QUERY) => TYPE_STRING_PARAM,
+    TypeFactory.optional(FRAGMENT) => TYPE_STRING_PARAM,
+    TypeFactory.optional(OPAQUE) => TYPE_STRING_PARAM,
+  )
+
+  TYPE_URI_PARAM_TYPE = PVariantType.new([PStringType::NON_EMPTY, TYPE_URI_PARAM_HASH_TYPE])
+
+  def self.register_ptype(loader, ir)
+    create_ptype(loader, ir, 'AnyType',
+      {
+        'parameters' => { KEY_TYPE => TypeFactory.optional(TYPE_URI_PARAM_TYPE), KEY_VALUE => nil }
+      }
+    )
+  end
+
+  def self.new_function(type)
+    @new_function ||= Puppet::Functions.create_loaded_function(:new_error, type.loader) do
+      dispatch :create do
+        param 'String[1]', :uri
+      end
+
+      dispatch :from_hash do
+        param TYPE_URI_INIT_HASH, :hash
+      end
+
+      def create(uri)
+        URI.parse(uri)
+      end
+
+      def from_hash(init_hash)
+        sym_hash = {}
+        init_hash.each_pair { |k, v| sym_hash[k.to_sym] = v }
+        scheme = sym_hash[:scheme]
+        scheme_class = scheme.nil? ? URI::Generic : (URI.scheme_list[scheme.upcase] || URI::Generic)
+        scheme_class.build(sym_hash)
+      end
+    end
+  end
+
+  attr_reader :parameters
+
+  def initialize(parameters = nil)
+    if parameters.is_a?(String)
+      parameters = TypeAsserter.assert_instance_of('URI-Type parameter', Pcore::TYPE_URI, parameters, true)
+      @parameters = uri_to_hash(URI.parse(parameters))
+    elsif parameters.is_a?(URI)
+      @parameters = uri_to_hash(parameters)
+    elsif parameters.is_a?(Hash)
+      params = TypeAsserter.assert_instance_of('URI-Type parameter', TYPE_URI_PARAM_TYPE, parameters, true)
+      @parameters = params.empty? ? nil : params
+    end
+  end
+
+  def eql?(o)
+    self.class == o.class && @parameters == o.parameters
+  end
+
+  def ==(o)
+    eql?(o)
+  end
+
+  def [](key)
+    URI_MEMBERS[key]
+  end
+
+  def generalize
+    DEFAULT
+  end
+
+  def hash
+    self.class.hash ^ @parameters.hash
+  end
+
+  def instance?(o, guard = nil)
+    return false unless o.is_a?(URI)
+    return true if @parameters.nil?
+
+    eval = Parser::EvaluatingParser.singleton.evaluator
+    @parameters.keys.all? { |pn| eval.match?(o.send(pn), @parameters[pn]) }
+  end
+
+  def roundtrip_with_string?
+    true
+  end
+
+  def _pcore_init_hash
+    @parameters == nil? ? EMPTY_HASH : { 'parameters' => @parameters }
+  end
+
+  protected
+
+  def _assignable?(o, guard = nil)
+    return false unless o.class == self.class
+    return true if @parameters.nil?
+    params = @parameters
+    o_params = o.parameters || EMPTY_HASH
+
+    eval = Parser::EvaluatingParser.singleton.evaluator
+    @parameters.keys.all? do |pn|
+      if o_params.include?(pn)
+        a = o_params[pn]
+        b = @parameters[pn]
+        eval.match?(a, b) || a.is_a?(PAnyType) && b.is_a?(PAnyType) && b.assignable?(a)
+      else
+        false
+      end
+    end
+  end
+
+  private
+
+  def uri_to_hash(uri)
+    result = {}
+    scheme = uri.scheme
+    unless scheme.nil?
+      scheme = scheme.downcase
+      result[SCHEME] = scheme
+    end
+    result[USERINFO] = uri.userinfo unless uri.userinfo.nil?
+    result[HOST] = uri.host.downcase unless uri.host.nil?
+    result[PORT] = uri.port.to_s unless uri.port.nil? || uri.port == 80 && 'http' == scheme || uri.port == 443 && 'https' == scheme
+    result[PATH] = uri.path unless uri.path.nil? || uri.path.empty?
+    result[QUERY] = uri.query unless uri.query.nil?
+    result[FRAGMENT] = uri.fragment unless uri.fragment.nil?
+    result[OPAQUE] = uri.opaque unless uri.opaque.nil?
+    result.empty? ? nil : result
+  end
+
+  DEFAULT = PURIType.new(nil)
+end
+end
+end

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

@@ -1089,6 +1089,23 @@ class StringConverter
     end
   end
 
+  # @api private
+  def string_PURIType(val_type, val, format_map, indentation)
+    f = get_format(val_type, format_map)
+    case f.format
+    when :p
+      fmt = TypeFormatter.singleton
+      indentation = indentation.indenting(f.alt? || indentation.is_indenting?)
+      fmt = fmt.indented(indentation.level, 2) if indentation.is_indenting?
+      fmt.string(val)
+    when :s
+      str_val = val.to_s
+      Kernel.format(f.orig_fmt, f.alt? ? puppet_quote(str_val) : str_val)
+    else
+      raise FormatError.new('URI', f.format, 'sp')
+    end
+  end
+
   # Maps the inferred type of o to a formatting rule
   def get_format(val_t, format_options)
     fmt = format_options.find {|k,_| k.assignable?(val_t) }

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

@@ -622,6 +622,11 @@ class TypeCalculator
     PBooleanType::FALSE
   end
 
+  # @api private
+  def infer_URI(o)
+    PURIType.new(o)
+  end
+
   # @api private
   # A Puppet::Parser::Resource, or Puppet::Resource
   #

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

@@ -528,6 +528,13 @@ module TypeFactory
     @target_t ||= TypeParser.singleton.parse('Target')
   end
 
+  # Produces a type for URI[String or Hash]
+  # @api public
+  #
+  def self.uri(string_uri_or_hash = nil)
+    string_uri_or_hash.nil? ? PURIType::DEFAULT : PURIType.new(string_uri_or_hash)
+  end
+
   # Produce a type corresponding to the class of given unless given is a
   # String, Class or a PAnyType.  When a String is given this is taken as
   # a classname.

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

@@ -330,24 +330,6 @@ class TypeFormatter
     append_array('Pattern', t.patterns.empty?) { append_strings(t.patterns.map(&:regexp)) }
   end
 
-  def append_error_param(ep)
-    case ep
-    when PStringType
-      if ep.value.nil?
-        append_string(ep)
-      else
-        append_string(ep.value)
-      end
-    when PPatternType
-      if ep.patterns.size != 1
-        append_string(ep)
-      else
-        append_string(ep.patterns[0].regexp)
-      end
-    else
-      append_string(ep)
-    end
-  end
 
   # @api private
   def string_PCollectionType(t)
@@ -366,6 +348,22 @@ class TypeFormatter
     @bld << ')'
   end
 
+  # @api private
+  def string_PURIType(t)
+    append_array('URI', t.parameters.nil?) { append_string(t._pcore_init_hash['parameters']) }
+  end
+
+  def string_URI(t)
+    @bld << 'URI('
+    if @indent
+      append_indented_string(t.to_s, @indent, @indent_width, true)
+      @bld.chomp!
+    else
+      append_string(t.to_s)
+    end
+    @bld << ')'
+  end
+
   # @api private
   def string_PUnitType(_)
     @bld << 'Unit'

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

@@ -286,8 +286,8 @@ module Types
           a = detailed_actual_to_s(e, a)
           e = e.map { |t| t.to_alias_expanded_s }
         else
-          e = e.map { |t| t.simple_name }.uniq
-          a = a.simple_name
+          e = e.map { |t| short_name(t) }.uniq
+          a = short_name(a)
         end
         e.insert(0, 'Undef') if optional
         case e.size
@@ -305,8 +305,8 @@ module Types
           a = detailed_actual_to_s(e, a)
           e = e.to_alias_expanded_s
         else
-          e = e.simple_name
-          a = a.simple_name
+          e = short_name(e)
+          a = short_name(a)
         end
         if optional
           e = "Undef or #{e}"
@@ -326,6 +326,16 @@ module Types
 
     private
 
+    def short_name(t)
+      # Ensure that Optional, NotUndef, Sensitive, and Type are reported with included
+      # type parameter.
+      if t.is_a?(PTypeWithContainedType) && !(t.type.nil? || t.type.class == PAnyType)
+        "#{t.name}[#{t.type.name}]"
+      else
+        t.name.nil? ? t.simple_name : t.name
+      end
+    end
+
     # Answers the question if `e` is a specialized type of `a`
     # @param e [PAnyType] the expected type
     # @param a [PAnyType] the actual type
@@ -430,7 +440,7 @@ module Types
 
     def actual_string
       a = actual
-      a.is_a?(PStringType) && !a.value.nil? ? "'#{a.value}'" : a.simple_name
+      a.is_a?(PStringType) && !a.value.nil? ? "'#{a.value}'" : short_name(a)
     end
   end