puppet 5.3.7-universal-darwin → 5.4.0-universal-darwin

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

@@ -9,7 +9,17 @@ module PuppetObject
   #
   # @return [PObjectType] the type
   def _pcore_type
-    self.class._pcore_type
+    t = self.class._pcore_type
+    if t.parameterized?
+      unless instance_variable_defined?(:@_cached_ptype)
+        # Create a parameterized type based on the values of this instance that
+        # contains a parameter value for each type parameter that matches an
+        # attribute by name and type of value
+        @_cached_ptype = PObjectTypeExtension.create_from_instance(t, self)
+      end
+      t = @_cached_ptype
+    end
+    t
   end
 
   def _pcore_all_contents(path, &block)
@@ -21,6 +31,10 @@ module PuppetObject
   def _pcore_init_hash
     {}
   end
+
+  def to_s
+    TypeFormatter.string(self)
+  end
 end
 end
 end

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

@@ -226,56 +226,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 +335,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 +382,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

@@ -569,6 +569,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 +719,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.gsub('c','s'), char)
 
     when :s
       fmt = f.alt? ? 'p' : 's'
@@ -1089,6 +1093,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/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

@@ -108,7 +108,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)
@@ -516,7 +516,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 +619,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

@@ -129,7 +129,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 +198,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)
@@ -229,8 +235,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 +519,24 @@ 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
+
+  # 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/lib/puppet/pops/types/type_formatter.rb

@@ -149,7 +149,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 +215,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 +330,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 +369,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 +506,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 +596,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 +680,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)

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

@@ -33,6 +33,10 @@ class TypeParser
   # @api public
   #
   def parse(string, context = nil)
+    # quick "peephole" optimization of common data types
+    if t = self.class.opt_type_map[string]
+      return t
+    end
     model = @parser.parse_string(string)
     interpret(model.model.body, context)
   end
@@ -200,7 +204,72 @@ 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
 
@@ -340,16 +409,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 +473,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]
@@ -485,7 +571,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 +622,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)