puppet 5.3.4 → 6.29.0

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

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+require 'puppet/concurrent/thread_local_singleton'
+
 module Puppet::Pops
 module Types
 # String
@@ -7,6 +10,8 @@ module Types
 # @api public
 #
 class TypeFormatter
+  extend Puppet::Concurrent::ThreadLocalSingleton
+
   # Produces a String representation of the given type.
   # @param t [PAnyType] the type to produce a string form
   # @return [String] the type in string form
@@ -14,14 +19,11 @@ class TypeFormatter
   # @api public
   #
   def self.string(t)
-    @singleton.string(t)
+    singleton.string(t)
   end
 
-  # @return [TypeCalculator] the singleton instance
-  #
-  # @api private
-  def self.singleton
-    @singleton
+  def initialize
+    @string_visitor = Visitor.new(nil, 'string', 0, 0)
   end
 
   def expanded
@@ -48,7 +50,7 @@ class TypeFormatter
   # @api public
   #
   def string(t)
-    @bld = ''
+    @bld = ''.dup
     append_string(t)
     @bld
   end
@@ -62,7 +64,7 @@ class TypeFormatter
   #
   # @api public
   def indented_string(t, indent = 0, indent_width = 2)
-    @bld = ''
+    @bld = ''.dup
     append_indented_string(t, indent, indent_width)
     @bld
   end
@@ -105,13 +107,13 @@ class TypeFormatter
       @ruby = false
       begin
         @bld << @ref_ctor << '('
-        @@string_visitor.visit_this_0(self, TypeFormatter.new.string(t))
+        @string_visitor.visit_this_0(self, TypeFormatter.new.string(t))
         @bld << ')'
       ensure
         @ruby = true
       end
     else
-      @@string_visitor.visit_this_0(self, t)
+      @string_visitor.visit_this_0(self, t)
     end
   end
 
@@ -149,7 +151,9 @@ class TypeFormatter
   def string_PDefaultType(_) ; @bld << 'Default' ; end
 
   # @api private
-  def string_PBooleanType(_) ; @bld << 'Boolean' ; end
+  def string_PBooleanType(t)
+    append_array('Boolean', t.value.nil?) { append_string(t.value) }
+  end
 
   # @api private
   def string_PScalarType(_)  ; @bld << 'Scalar'  ; end
@@ -213,7 +217,13 @@ class TypeFormatter
 
   # @api private
   def string_PEnumType(t)
-    append_array('Enum', t.values.empty?) { append_strings(t.values) }
+    append_array('Enum', t.values.empty?) do
+      append_strings(t.values)
+      if t.case_insensitive?
+        @bld << COMMA_SEP
+        append_string(true)
+      end
+    end
   end
 
   # @api private
@@ -322,12 +332,34 @@ class TypeFormatter
     append_array('Pattern', t.patterns.empty?) { append_strings(t.patterns.map(&:regexp)) }
   end
 
+
   # @api private
   def string_PCollectionType(t)
     range = range_array_part(t.size_type)
     append_array('Collection', range.empty? ) { append_elements(range) }
   end
 
+  def string_Object(t)
+    type = TypeCalculator.infer(t)
+    if type.is_a?(PObjectTypeExtension)
+      type = type.base_type
+    end
+    if type.is_a?(PObjectType)
+      init_hash = type.extract_init_hash(t)
+      @bld << type.name << '('
+      if @indent
+        append_indented_string(init_hash, @indent, @indent_width, true)
+        @bld.chomp!
+      else
+        append_string(init_hash)
+      end
+      @bld << ')'
+    else
+      @bld << 'Instance of '
+      append_string(type)
+    end
+  end
+
   def string_PuppetObject(t)
     @bld << t._pcore_type.name << '('
     if @indent
@@ -339,6 +371,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'
@@ -460,6 +508,17 @@ class TypeFormatter
     end
   end
 
+  def string_PObjectTypeExtension(t)
+    append_array(@type_set ? @type_set.name_for(t, t.name) : t.name, false) do
+      ips = t.init_parameters
+      if ips.is_a?(Array)
+        append_strings(ips)
+      else
+        append_string(ips)
+      end
+    end
+  end
+
   # @api private
   def string_PSensitiveType(t)
     append_array('Sensitive', PAnyType::DEFAULT == t.type) { append_string(t.type) }
@@ -539,7 +598,7 @@ class TypeFormatter
   end
 
   # @api private
-  def string_NilClass(t)     ; @bld << (@ruby ? 'nil' : '?') ; end
+  def string_NilClass(t)     ; @bld << (@ruby ? 'nil' : 'undef') ; end
 
   # @api private
   def string_Numeric(t)      ; @bld << t.to_s    ; end
@@ -623,7 +682,13 @@ class TypeFormatter
   end
 
   def range_array_part(t)
-    t.nil? || t.unbounded? ? EMPTY_ARRAY : [t.from.nil? ? 'default' : t.from.to_s , t.to.nil? ? 'default' : t.to.to_s ]
+    if t.nil? || t.unbounded?
+      EMPTY_ARRAY
+    else
+      result = [t.from.nil? ? 'default' : t.from.to_s]
+      result << t.to.to_s unless t.to.nil?
+      result
+    end
   end
 
   def append_object_hash(hash)
@@ -731,9 +796,6 @@ class TypeFormatter
   def chomp_list
     @bld.chomp!(COMMA_SEP)
   end
-
-  @singleton = new
-  @@string_visitor = Visitor.new(nil, 'string',0,0)
 end
 end
 end

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

@@ -19,7 +19,7 @@ module Types
     def eql?(o)
       self == o
     end
-   end
+  end
 
   # @api private
   class SubjectPathElement < TypePathElement
@@ -640,7 +640,7 @@ module Types
           result = ["#{label} expects (#{signature_string(sig)})"]
           result.concat(error_arrays[0].map { |e| "  rejected:#{e.chop_path(0).format}" })
         else
-          result = ["#{label} expects one of:"]
+          result = ["The function #{label} was called with arguments it does not accept. It expects one of:"]
           signatures.each_with_index do |sg, index|
             result << "  (#{signature_string(sg)})"
             result.concat(error_arrays[index].map { |e| "    rejected:#{e.chop_path(0).format}" })
@@ -753,7 +753,7 @@ module Types
     end
 
     def describe_POptionalType(expected, original, actual, path)
-      return EMPTY_ARRAY if actual.is_a?(PUndefType)
+      return EMPTY_ARRAY if actual.is_a?(PUndefType) || expected.optional_type.nil?
       internal_describe(expected.optional_type, original.is_a?(PTypeAliasType) ? original : expected, actual, path)
     end
 

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

@@ -1,3 +1,5 @@
+require 'puppet/concurrent/thread_local_singleton'
+
 # This class provides parsing of Type Specification from a string into the Type
 # Model that is produced by the TypeFactory.
 #
@@ -8,9 +10,7 @@
 module Puppet::Pops
 module Types
 class TypeParser
-  def self.singleton
-    @singleton ||= TypeParser.new
-  end
+  extend Puppet::Concurrent::ThreadLocalSingleton
 
   # @api public
   def initialize
@@ -33,6 +33,11 @@ class TypeParser
   # @api public
   #
   def parse(string, context = nil)
+    # quick "peephole" optimization of common data types
+    t = self.class.opt_type_map[string]
+    if t
+      return t
+    end
     model = @parser.parse_string(string)
     interpret(model.model.body, context)
   end
@@ -200,14 +205,80 @@ class TypeParser
         'semver'       => TypeFactory.sem_ver,
         'semverrange'  => TypeFactory.sem_ver_range,
         'timestamp'    => TypeFactory.timestamp,
-        'timespan'     => TypeFactory.timespan
+        'timespan'     => TypeFactory.timespan,
+        'uri'          => TypeFactory.uri,
+    }.freeze
+  end
+
+  # @api private
+  def self.opt_type_map
+    # Map of common (and simple to optimize) data types in string form
+    # (Note that some types are the result of evaluation even if they appear to be simple
+    # - for example 'Data' and they cannot be optimized this way since the factory calls
+    # back to the parser for evaluation).
+    #
+    @opt_type_map ||= {
+        'Integer'      => TypeFactory.integer,
+        'Float'        => TypeFactory.float,
+        'Numeric'      => TypeFactory.numeric,
+
+        'String'       => TypeFactory.string,
+        'String[1]'    => TypeFactory.string(TypeFactory.range(1, :default)),
+
+        'Binary'       => TypeFactory.binary,
+
+        'Boolean'      => TypeFactory.boolean,
+        'Boolean[true]'  => TypeFactory.boolean(true),
+        'Boolean[false]' => TypeFactory.boolean(false),
+
+        'Array'        => TypeFactory.array_of_any,
+        'Array[1]'     => TypeFactory.array_of(TypeFactory.any, TypeFactory.range(1, :default)),
+
+        'Hash'         => TypeFactory.hash_of_any,
+        'Collection'   => TypeFactory.collection,
+        'Scalar'       => TypeFactory.scalar,
+
+        'Scalardata'   => TypeFactory.scalar_data,
+        'ScalarData'   => TypeFactory.scalar_data,
+
+        'Catalogentry' => TypeFactory.catalog_entry,
+        'CatalogEntry' => TypeFactory.catalog_entry,
+
+        'Undef'        => TypeFactory.undef,
+        'Default'      => TypeFactory.default,
+        'Any'          => TypeFactory.any,
+        'Type'         => TypeFactory.type_type,
+        'Callable'     => TypeFactory.all_callables,
+
+        'Semver'       => TypeFactory.sem_ver,
+        'SemVer'       => TypeFactory.sem_ver,
+
+        'Semverrange'  => TypeFactory.sem_ver_range,
+        'SemVerRange'  => TypeFactory.sem_ver_range,
+
+        'Timestamp'    => TypeFactory.timestamp,
+        'TimeStamp'    => TypeFactory.timestamp,
+
+        'Timespan'     => TypeFactory.timespan,
+        'TimeSpan'     => TypeFactory.timespan,
+
+        'Uri'          => TypeFactory.uri,
+        'URI'          => TypeFactory.uri,
+
+        'Optional[Integer]'      => TypeFactory.optional(TypeFactory.integer),
+        'Optional[String]'       => TypeFactory.optional(TypeFactory.string),
+        'Optional[String[1]]'    => TypeFactory.optional(TypeFactory.string(TypeFactory.range(1, :default))),
+        'Optional[Array]'        => TypeFactory.optional(TypeFactory.array_of_any),
+        'Optional[Hash]'         => TypeFactory.optional(TypeFactory.hash_of_any),
+
     }.freeze
   end
 
   # @api private
   def interpret_QualifiedReference(name_ast, context)
     name = name_ast.value
-    if found = self.class.type_map[name]
+    found = self.class.type_map[name]
+    if found
       found
     else
       loader = loader_from_context(name_ast, context)
@@ -221,7 +292,14 @@ class TypeParser
 
   # @api private
   def loader_from_context(ast, context)
-    Adapters::LoaderAdapter.loader_for_model_object(ast, nil, context)
+    model_loader = Adapters::LoaderAdapter.loader_for_model_object(ast, nil, context)
+    if context.is_a?(PTypeSetType::TypeSetLoader)
+      # Only swap a given TypeSetLoader for another loader when the other loader is different
+      # from the one associated with the TypeSet expression
+      context.model_loader.equal?(model_loader.parent) ? context : model_loader
+    else
+      model_loader
+    end
   end
 
   # @api private
@@ -340,16 +418,27 @@ class TypeParser
       TypeFactory.regexp(parameters[0])
 
     when 'enum'
-      # 1..m parameters being strings
+      # 1..m parameters being string
+      last = parameters.last
+      case_insensitive = false
+      if last == true || last == false
+        parameters = parameters[0...-1]
+        case_insensitive = last
+      end
       raise_invalid_parameters_error('Enum', '1 or more', parameters.size) unless parameters.size >= 1
       parameters.each { |p| raise Puppet::ParseError, _('Enum parameters must be identifiers or strings') unless p.is_a?(String) }
-      TypeFactory.enum(*parameters)
+      PEnumType.new(parameters, case_insensitive)
 
     when 'pattern'
       # 1..m parameters being strings or regular expressions
       raise_invalid_parameters_error('Pattern', '1 or more', parameters.size) unless parameters.size >= 1
       TypeFactory.pattern(*parameters)
 
+    when 'uri'
+      # 1 parameter which is a string or a URI
+      raise_invalid_parameters_error('URI', '1', parameters.size) unless parameters.size == 1
+      TypeFactory.uri(parameters[0])
+
     when 'variant'
       # 1..m parameters being strings or regular expressions
       raise_invalid_parameters_error('Variant', '1 or more', parameters.size) unless parameters.size >= 1
@@ -393,6 +482,12 @@ class TypeParser
       raise_invalid_type_specification_error(ast) unless h.is_a?(Hash)
       TypeFactory.struct(h)
 
+    when 'boolean'
+      raise_invalid_parameters_error('Boolean', '1', parameters.size) unless parameters.size == 1
+      p = parameters[0]
+      raise Puppet::ParseError, 'Boolean parameter must be true or false' unless p == true || p == false
+      TypeFactory.boolean(p)
+
     when 'integer'
       if parameters.size == 1
         case parameters[0]
@@ -403,9 +498,9 @@ class TypeParser
         end
       elsif parameters.size != 2
         raise_invalid_parameters_error('Integer', '1 or 2', parameters.size)
-     else
-       TypeFactory.range(parameters[0] == :default ? nil : parameters[0], parameters[1] == :default ? nil : parameters[1])
-     end
+      else
+        TypeFactory.range(parameters[0] == :default ? nil : parameters[0], parameters[1] == :default ? nil : parameters[1])
+      end
 
     when 'object'
       raise_invalid_parameters_error('Object', 1, parameters.size) unless parameters.size == 1
@@ -443,9 +538,9 @@ class TypeParser
         end
       elsif parameters.size != 2
         raise_invalid_parameters_error('Float', '1 or 2', parameters.size)
-     else
-       TypeFactory.float_range(parameters[0] == :default ? nil : parameters[0], parameters[1] == :default ? nil : parameters[1])
-     end
+      else
+        TypeFactory.float_range(parameters[0] == :default ? nil : parameters[0], parameters[1] == :default ? nil : parameters[1])
+      end
 
     when 'string'
       size_type =
@@ -485,7 +580,7 @@ class TypeParser
       assert_type(ast, param) unless param.is_a?(String)
       TypeFactory.optional(param)
 
-    when 'any', 'data', 'catalogentry', 'boolean', 'scalar', 'undef', 'numeric', 'default', 'semverrange'
+    when 'any', 'data', 'catalogentry', 'scalar', 'undef', 'numeric', 'default', 'semverrange'
       raise_unparameterized_type_error(qref)
 
     when 'notundef'
@@ -536,6 +631,8 @@ class TypeParser
       elsif type.is_a?(PResourceType)
         raise_invalid_parameters_error(qref.cased_value, 1, parameters.size) unless parameters.size == 1
         TypeFactory.resource(type.type_name, parameters[0])
+      elsif type.is_a?(PObjectType)
+        PObjectTypeExtension.create(type, parameters)
       else
         # Must be a type alias. They can't use parameters (yet)
         raise_unparameterized_type_error(qref)

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

@@ -0,0 +1,43 @@
+module Puppet::Pops
+module Types
+
+# Interface implemented by a type that has InvocableMembers
+module TypeWithMembers
+  # @return [InvocableMember,nil] An invocable member if it exists, or `nil`
+  def [](member_name)
+    raise NotImplementedError, "'#{self.class.name}' should implement #[]"
+  end
+end
+
+# Interface implemented by attribute and function members
+module InvocableMember
+  # Performs type checking of arguments and invokes the method that corresponds to this
+  # method. The result of the invocation is returned
+  #
+  # @param receiver [Object] The receiver of the call
+  # @param scope [Puppet::Parser::Scope] The caller scope
+  # @param args [Array] Array of arguments.
+  # @return [Object] The result returned by the member function or attribute
+  #
+  # @api private
+  def invoke(receiver, scope, args, &block)
+    raise NotImplementedError, "'#{self.class.name}' should implement #invoke"
+  end
+end
+
+# Plays the same role as an PAttribute in the PObjectType. Provides
+# access to known attr_readers and plain reader methods.
+class AttrReader
+  include InvocableMember
+
+  def initialize(message)
+    @message = message.to_sym
+  end
+
+  def invoke(receiver, scope, args, &block)
+    receiver.send(@message)
+  end
+end
+end
+end
+