puppet 5.3.4 → 6.29.0

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

@@ -158,7 +158,7 @@ class RubyGenerator < TypeFormatter
       ir = Loaders.implementation_registry
       impl_name = ir.module_name_for_type(type)
       raise Puppet::Error, "Unable to create an instance of #{type.name}. No mapping exists to runtime object" if impl_name.nil?
-      impl_name[0]
+      impl_name
     end
   end
 
@@ -179,9 +179,8 @@ class RubyGenerator < TypeFormatter
     unless obj.parent.nil?
       if impl_subst.empty?
         ir = Loaders.implementation_registry
-        parent_impl = ir.module_name_for_type(obj.parent)
-        raise Puppet::Error, "Unable to create an instance of #{obj.parent.name}. No mapping exists to runtime object" if parent_impl.nil?
-        parent_name = parent_impl[0]
+        parent_name = ir.module_name_for_type(obj.parent)
+        raise Puppet::Error, "Unable to create an instance of #{obj.parent.name}. No mapping exists to runtime object" if parent_name.nil?
       else
         parent_name = obj.parent.name.gsub(*impl_subst)
       end
@@ -226,56 +225,56 @@ class RubyGenerator < TypeFormatter
       eq_names = obj.equality
     end
 
-    unless obj.parent.is_a?(PObjectType) && obj_attrs.empty?
-      # Output type safe hash constructor
-      bld << "\n  def self.from_hash(init_hash)\n"
-      bld << '    from_asserted_hash(' << namespace_relative(segments, TypeAsserter.name) << '.assert_instance_of('
-      bld << "'" << obj.label << " initializer', _pcore_type.init_hash_type, init_hash))\n  end\n\n  def self.from_asserted_hash(init_hash)\n    new"
-      unless non_opt.empty? && opt.empty?
-        bld << "(\n"
-        non_opt.each { |ip| bld << "      init_hash['" << ip.name << "'],\n" }
-        opt.each do |ip|
-          if ip.value.nil?
-            bld << "      init_hash['" << ip.name << "'],\n"
-          else
-            bld << "      init_hash.fetch('" << ip.name << "') { "
-            default_string(bld, ip)
-            bld << " },\n"
-          end
+    # Output type safe hash constructor
+    bld << "\n  def self.from_hash(init_hash)\n"
+    bld << '    from_asserted_hash(' << namespace_relative(segments, TypeAsserter.name) << '.assert_instance_of('
+    bld << "'" << obj.label << " initializer', _pcore_type.init_hash_type, init_hash))\n  end\n\n  def self.from_asserted_hash(init_hash)\n    new"
+    unless non_opt.empty? && opt.empty?
+      bld << "(\n"
+      non_opt.each { |ip| bld << "      init_hash['" << ip.name << "'],\n" }
+      opt.each do |ip|
+        if ip.value.nil?
+          bld << "      init_hash['" << ip.name << "'],\n"
+        else
+          bld << "      init_hash.fetch('" << ip.name << "') { "
+          default_string(bld, ip)
+          bld << " },\n"
         end
-        bld.chomp!(",\n")
-        bld << ')'
       end
-      bld << "\n  end\n"
+      bld.chomp!(",\n")
+      bld << ')'
+    end
+    bld << "\n  end\n"
 
-      # Output type safe constructor
-      bld << "\n  def self.create"
-      if init_params.empty?
-        bld << "\n    new"
-      else
-        bld << '('
-        non_opt.each { |ip| bld << rname(ip.name) << ', ' }
-        opt.each do |ip|
-          bld << rname(ip.name) << ' = '
-          default_string(bld, ip)
-          bld << ', '
-        end
-        bld.chomp!(', ')
-        bld << ")\n"
-        bld << '    ta = ' << namespace_relative(segments, TypeAsserter.name) << "\n"
-        bld << "    attrs = _pcore_type.attributes(true)\n"
-        init_params.each do |a|
-          bld << "    ta.assert_instance_of('" << a.container.name << '[' << a.name << ']'
-          bld << "', attrs['" << a.name << "'].type, " << rname(a.name) << ")\n"
-        end
-        bld << '    new('
-        non_opt.each { |a| bld << rname(a.name) << ', ' }
-        opt.each { |a| bld << rname(a.name) << ', ' }
-        bld.chomp!(', ')
-        bld << ')'
+    # Output type safe constructor
+    bld << "\n  def self.create"
+    if init_params.empty?
+      bld << "\n    new"
+    else
+      bld << '('
+      non_opt.each { |ip| bld << rname(ip.name) << ', ' }
+      opt.each do |ip|
+        bld << rname(ip.name) << ' = '
+        default_string(bld, ip)
+        bld << ', '
+      end
+      bld.chomp!(', ')
+      bld << ")\n"
+      bld << '    ta = ' << namespace_relative(segments, TypeAsserter.name) << "\n"
+      bld << "    attrs = _pcore_type.attributes(true)\n"
+      init_params.each do |a|
+        bld << "    ta.assert_instance_of('" << a.container.name << '[' << a.name << ']'
+        bld << "', attrs['" << a.name << "'].type, " << rname(a.name) << ")\n"
       end
-      bld << "\n  end\n"
+      bld << '    new('
+      non_opt.each { |a| bld << rname(a.name) << ', ' }
+      opt.each { |a| bld << rname(a.name) << ', ' }
+      bld.chomp!(', ')
+      bld << ')'
+    end
+    bld << "\n  end\n"
 
+    unless obj.parent.is_a?(PObjectType) && obj_attrs.empty?
       # Output attr_readers
       unless obj_attrs.empty?
         bld << "\n"
@@ -335,9 +334,7 @@ class RubyGenerator < TypeFormatter
       end
     end
 
-    if obj_attrs.empty?
-      bld << "\n  def _pcore_init_hash\n    {}\n  end\n" unless obj.parent.is_a?(PObjectType)
-    else
+    unless obj_attrs.empty? && obj.parent.nil?
       bld << "\n  def _pcore_init_hash\n"
       bld << '    result = '
       bld << (obj.parent.nil? ? '{}' : 'super')
@@ -384,12 +381,6 @@ class RubyGenerator < TypeFormatter
       bld << "    path.pop\n  end\n"
     end
 
-    unless obj.parent.is_a?(PObjectType)
-      bld << "\n  def to_s\n"
-      bld << '    ' << namespace_relative(segments, TypeFormatter.name) << ".string(self)\n"
-      bld << "  end\n"
-    end
-
     # Output function placeholders
     obj.functions(false).each_value do |func|
       code_annotation = RubyMethod.annotate(func)

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

@@ -1,3 +1,5 @@
+require 'puppet/concurrent/thread_local_singleton'
+
 module Puppet::Pops
 module Types
 
@@ -238,22 +240,17 @@ class StringConverter
     end
   end
 
+  extend Puppet::Concurrent::ThreadLocalSingleton
+
   # @api public
   def self.convert(value, string_formats = :default)
     singleton.convert(value, string_formats)
   end
 
-  # @return [TypeConverter] the singleton instance
-  #
-  # @api public
-  def self.singleton
-    @tconv_instance ||= new
-  end
-
   # @api private
   #
   def initialize
-    @@string_visitor   ||= Visitor.new(self, "string", 3, 3)
+    @string_visitor = Visitor.new(self, "string", 3, 3)
   end
 
   DEFAULT_INDENTATION = Indentation.new(0, true, false).freeze
@@ -484,8 +481,17 @@ class StringConverter
 
     value_type = TypeCalculator.infer_set(value)
     if string_formats.is_a?(String)
-      # add the format given for the exact type
-      string_formats = { value_type => string_formats }
+      # For Array and Hash, the format is given as a Hash where 'format' key is the format for the collection itself
+      if Puppet::Pops::Types::PArrayType::DEFAULT.assignable?(value_type)
+        # add the format given for the exact type
+        string_formats = { Puppet::Pops::Types::PArrayType::DEFAULT => {'format' => string_formats }}
+      elsif Puppet::Pops::Types::PHashType::DEFAULT.assignable?(value_type)
+          # add the format given for the exact type
+          string_formats = { Puppet::Pops::Types::PHashType::DEFAULT => {'format' => string_formats }}
+      else
+        # add the format given for the exact type
+        string_formats = { value_type => string_formats }
+      end
     end
 
     case string_formats
@@ -514,7 +520,7 @@ class StringConverter
 #  end
 
   def _convert(val_type, value, format_map, indentation)
-    @@string_visitor.visit_this_3(self, val_type, value, format_map, indentation)
+    @string_visitor.visit_this_3(self, val_type, value, format_map, indentation)
   end
   private :_convert
 
@@ -569,6 +575,10 @@ class StringConverter
     end
   end
 
+  def string_PObjectTypeExtension(val_type, val, format_map, indentation)
+    string_PObjectType(val_type.base_type, val, format_map, indentation)
+  end
+
   def string_PRuntimeType(val_type, val, format_map, indent)
     # Before giving up on this, and use a string representation of the unknown
     # object, a check is made to see if the object can present itself as
@@ -715,7 +725,7 @@ class StringConverter
     when :c
       char = [val].pack("U")
       char = f.alt? ? "\"#{char}\"" : char
-      char = Kernel.format(f.orig_fmt.gsub('c','s'), char)
+      Kernel.format(f.orig_fmt.tr('c','s'), char)
 
     when :s
       fmt = f.alt? ? 'p' : 's'
@@ -768,7 +778,7 @@ class StringConverter
 
     when :p
       # width & precision applied to string, not the the name of the type
-      "Binary(\"#{Kernel.format(f.orig_fmt.gsub('p', 's'), val.to_s)}\")"
+      "Binary(\"#{Kernel.format(f.orig_fmt.tr('p', 's'), val.to_s)}\")"
 
     when :b
       Kernel.format(f.orig_fmt.gsub('b', substitute), val.relaxed_to_s)
@@ -800,27 +810,27 @@ class StringConverter
       Kernel.format(f.orig_fmt, val)
 
     when :p
-      apply_string_flags(f, puppet_quote(val))
+      apply_string_flags(f, puppet_quote(val, f.alt?))
 
     when :c
       c_val = val.capitalize
-      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.gsub('c', 's'), c_val)
+      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.tr('c', 's'), c_val)
 
     when :C
       c_val = val.split('::').map {|s| s.capitalize }.join('::')
-      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.gsub('C', 's'), c_val)
+      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.tr('C', 's'), c_val)
 
     when :u
       c_val = val.upcase
-      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.gsub('u', 's'), c_val)
+      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.tr('u', 's'), c_val)
 
     when :d
       c_val = val.downcase
-      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.gsub('d', 's'), c_val)
+      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.tr('d', 's'), c_val)
 
     when :t  # trim
       c_val = val.strip
-      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.gsub('t', 's'), c_val)
+      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.tr('t', 's'), c_val)
 
     else
       raise FormatError.new('String', f.format, 'cCudspt')
@@ -832,10 +842,15 @@ class StringConverter
   # strings will be quoted using double quotes.
   #
   # @param [String] str the string that should be formatted
+  # @param [Boolean] enforce_double_quotes if true the result will be double quoted (even if single quotes would be possible)
   # @return [String] the formatted string
   #
   # @api public
-  def puppet_quote(str)
+  def puppet_quote(str, enforce_double_quotes = false)
+    if enforce_double_quotes
+      return puppet_double_quote(str)
+    end
+
     # Assume that the string can be single quoted
     bld = '\''
     bld.force_encoding(str.encoding)
@@ -903,7 +918,7 @@ class StringConverter
     case f.format
     when :p
       str_regexp = PRegexpType.regexp_to_s_with_delimiters(val)
-      f.orig_fmt == '%p' ? str_regexp : Kernel.format(f.orig_fmt.gsub('p', 's'), str_regexp)
+      f.orig_fmt == '%p' ? str_regexp : Kernel.format(f.orig_fmt.tr('p', 's'), str_regexp)
     when :s
       str_regexp = PRegexpType.regexp_to_s(val)
       str_regexp = puppet_quote(str_regexp) if f.alt?
@@ -1080,15 +1095,32 @@ class StringConverter
     f = get_format(val_type, format_map)
     case f.format
     when :s
-      str_val = f.alt? ? "\"#{val.to_s}\"" : val.to_s
+      str_val = f.alt? ? "\"#{val}\"" : val.to_s
       Kernel.format(f.orig_fmt, str_val)
     when :p
-      Kernel.format(f.orig_fmt.gsub('p', 's'), val.to_s)
+      Kernel.format(f.orig_fmt.tr('p', 's'), val.to_s)
     else
       raise FormatError.new('Type', f.format, 'sp')
     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/lib/puppet/pops/types/tree_iterators.rb

@@ -67,7 +67,7 @@ class TreeIterator
     false
   end
 
-  def to_array
+  def to_a
     result = []
     loop do
       result << self.next
@@ -75,6 +75,10 @@ class TreeIterator
     result
   end
 
+  def to_array
+    to_a
+  end
+
   def reverse_each(&block)
     r = Iterator.new(PAnyType::DEFAULT, to_array.reverse_each)
     block_given? ? r.each(&block) : r

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

@@ -10,7 +10,7 @@ module Types
 #
 module TypeAcceptor
   # @param type [PAnyType] the type that we accept a visit from
-  # @param quard [RecursionGuard] the guard against self recursion
+  # @param guard [RecursionGuard] the guard against self recursion
   def visit(type, guard)
   end
 end

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

@@ -1,3 +1,5 @@
+require 'puppet/concurrent/thread_local_singleton'
+
 module Puppet::Pops
 module Types
 # The TypeCalculator can answer questions about puppet types.
@@ -99,6 +101,7 @@ module Types
 # @api public
 #
 class TypeCalculator
+  extend Puppet::Concurrent::ThreadLocalSingleton
 
   # @api public
   def self.assignable?(t1, t2)
@@ -108,7 +111,7 @@ class TypeCalculator
   # Answers, does the given callable accept the arguments given in args (an array or a tuple)
   # @param callable [PCallableType] - the callable
   # @param args [PArrayType, PTupleType] args optionally including a lambda callable at the end
-  # @return [Boolan] true if the callable accepts the arguments
+  # @return [Boolean] true if the callable accepts the arguments
   #
   # @api public
   def self.callable?(callable, args)
@@ -120,6 +123,30 @@ class TypeCalculator
     singleton.infer(o)
   end
 
+  # Infers a type if given object may have callable members, else returns nil.
+  # Caller must check for nil or if returned type supports members.
+  # This is a much cheaper call than doing a call to the general infer(o) method.
+  #
+  # @api private
+  def self.infer_callable_methods_t(o)
+    # If being a value that cannot have Pcore based methods callable from Puppet Language
+    if (o.is_a?(String) ||
+      o.is_a?(Numeric) ||
+      o.is_a?(TrueClass) ||
+      o.is_a?(FalseClass) ||
+      o.is_a?(Regexp) ||
+      o.instance_of?(Array) ||
+      o.instance_of?(Hash) ||
+      Types::PUndefType::DEFAULT.instance?(o)
+      )
+      return nil
+    end
+    # For other objects (e.g. PObjectType instances, and runtime types) full inference needed, since that will
+    # cover looking into the runtime type registry.
+    #
+    infer(o)
+  end
+
   # @api public
   def self.generalize(o)
     singleton.generalize(o)
@@ -135,18 +162,11 @@ class TypeCalculator
     singleton.iterable(t)
   end
 
-  # @return [TypeCalculator] the singleton instance
-  #
-  # @api private
-  def self.singleton
-    @tc_instance ||= new
-  end
-
   # @api public
   #
   def initialize
-    @@infer_visitor ||= Visitor.new(nil, 'infer',0,0)
-    @@extract_visitor ||= Visitor.new(nil, 'extract',0,0)
+    @infer_visitor = Visitor.new(nil, 'infer',0,0)
+    @extract_visitor = Visitor.new(nil, 'extract',0,0)
   end
 
   # Answers 'can an instance of type t2 be assigned to a variable of type t'.
@@ -159,7 +179,7 @@ class TypeCalculator
       t = type(t)
     end
     t.is_a?(PAnyType) ? t.assignable?(t2) : false
- end
+  end
 
   # Returns an iterable if the t represents something that can be iterated
   def enumerable(t)
@@ -250,7 +270,7 @@ class TypeCalculator
     elsif o.is_a?(Evaluator::PuppetProc)
       infer_PuppetProc(o)
     else
-      @@infer_visitor.visit_this_0(self, o)
+      @infer_visitor.visit_this_0(self, o)
     end
   end
 
@@ -464,7 +484,7 @@ class TypeCalculator
   # Produces the superclasses of the given class, including the class
   def superclasses(c)
     result = [c]
-    while s = c.superclass
+    while s = c.superclass #rubocop:disable Lint/AssignmentInCondition
       result << s
       c = s
     end
@@ -516,7 +536,11 @@ class TypeCalculator
       return PRuntimeType.new(:ruby, nil) if name.nil? # anonymous class that doesn't implement PuppetObject is impossible to infer
       ir = Loaders.implementation_registry
       type = ir.nil? ? nil : ir.type_for_module(name)
-      type.nil? ? PRuntimeType.new(:ruby, name) : type
+      return PRuntimeType.new(:ruby, name) if type.nil?
+      if type.is_a?(PObjectType) && type.parameterized?
+        type = PObjectTypeExtension.create_from_instance(type, o)
+      end
+      type
     end
   end
 
@@ -615,12 +639,17 @@ class TypeCalculator
 
   # @api private
   def infer_TrueClass(o)
-    PBooleanType::DEFAULT
+    PBooleanType::TRUE
   end
 
   # @api private
   def infer_FalseClass(o)
-    PBooleanType::DEFAULT
+    PBooleanType::FALSE
+  end
+
+  # @api private
+  def infer_URI(o)
+    PURIType.new(o)
   end
 
   # @api private

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

@@ -6,6 +6,19 @@ module Types
 module TypeFactory
   @type_calculator = TypeCalculator.singleton
 
+  # Clears caches - used when testing
+  def self.clear
+    # these types are cached and needs to be nulled as the representation may change if loaders are cleared
+    @data_t = nil
+    @rich_data_t = nil
+    @rich_data_key_t = nil
+    @array_of_data_t = nil
+    @hash_of_data_t = nil
+    @error_t = nil
+    @task_t = nil
+    @deferred_t = nil
+  end
+
   # Produces the Integer type
   # @api public
   #
@@ -129,7 +142,13 @@ module TypeFactory
   # @api public
   #
   def self.enum(*values)
-    PEnumType.new(values)
+    last = values.last
+    case_insensitive = false
+    if last == true || last == false
+      case_insensitive = last
+      values = values[0...-1]
+    end
+    PEnumType.new(values, case_insensitive)
   end
 
   # Produces the Variant type, optionally with the "one of" types
@@ -192,8 +211,8 @@ module TypeFactory
   # @param hash [{String=>Object}] the hash of feature groups
   # @return [PObjectType] the created type
   #
-  def self.object(hash = nil)
-    hash.nil? || hash.empty? ? PObjectType::DEFAULT : PObjectType.new(hash)
+  def self.object(hash = nil, loader = nil)
+    hash.nil? || hash.empty? ? PObjectType::DEFAULT : PObjectType.new(hash, loader)
   end
 
   def self.type_set(hash = nil)
@@ -204,8 +223,6 @@ module TypeFactory
     case args.size
     when 0
       PTimestampType::DEFAULT
-    when 1
-      PTimestampType.new(args[0], args[0])
     else
       PTimestampType.new(*args)
     end
@@ -215,8 +232,6 @@ module TypeFactory
     case args.size
     when 0
       PTimespanType::DEFAULT
-    when 1
-      PTimespanType.new(args[0], args[0])
     else
       PTimespanType.new(*args)
     end
@@ -229,8 +244,8 @@ module TypeFactory
   # Produces the Boolean type
   # @api public
   #
-  def self.boolean
-    PBooleanType::DEFAULT
+  def self.boolean(value = nil)
+    value.nil? ? PBooleanType::DEFAULT : (value ? PBooleanType::TRUE : PBooleanType::FALSE)
   end
 
   # Produces the Any type
@@ -513,6 +528,28 @@ module TypeFactory
     inst_type.nil? ? PTypeType::DEFAULT : PTypeType.new(inst_type)
   end
 
+  # Produces a type for Error
+  # @api public
+  #
+  def self.error
+    @error_t ||= TypeParser.singleton.parse('Error', Loaders.loaders.puppet_system_loader)
+  end
+
+  def self.task
+    @task_t ||= TypeParser.singleton.parse('Task')
+  end
+
+  def self.deferred
+    @deferred_t ||= TypeParser.singleton.parse('Deferred')
+  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.