puppet 4.10.0 → 5.0.0

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

@@ -51,7 +51,7 @@ class StringConverter
 
   # Format represents one format specification that is textually represented by %<flags><width>.<precision><format>
   # Format parses and makes the individual parts available when an instance is created.
-  # 
+  #
   # @api private
   #
   class Format
@@ -163,6 +163,11 @@ class StringConverter
       unless lower && higher
         return lower || higher
       end
+
+      # drop all formats in lower than is more generic in higher. Lower must never
+      # override higher
+      lower = lower.reject { |lk, _| higher.keys.any? { |hk| hk != lk && hk.assignable?(lk) }}
+
       merged = (lower.keys + higher.keys).uniq.map do |k|
         [k, merge(lower[k], higher[k])]
       end
@@ -172,7 +177,7 @@ class StringConverter
     # Sorts format based on generality of types - most specific types before general
     #
     def self.sort_formats(format_map)
-      format_map = format_map.sort do |(a,_),(b,_)| 
+      format_map = format_map.sort do |(a,_),(b,_)|
         ab = b.assignable?(a)
         ba = a.assignable?(b)
         if a == b
@@ -219,7 +224,7 @@ class StringConverter
     end
     # Returns an array with a delimiter pair derived from the format.
     # If format does not contain a delimiter specification the given default is returned
-    # 
+    #
     # @param [Array<String>] the default delimiters
     # @returns [Array<String>] a tuple with left, right delimiters
     #
@@ -275,6 +280,7 @@ class StringConverter
   DEFAULT_ARRAY_DELIMITERS                      = ['[', ']'].freeze
 
   DEFAULT_STRING_FORMATS = {
+    PObjectType::DEFAULT   => Format.new('%p').freeze,    # call with initialization hash
     PFloatType::DEFAULT    => Format.new('%f').freeze,    # float
     PNumericType::DEFAULT  => Format.new('%d').freeze,    # decimal number
     PArrayType::DEFAULT    => DEFAULT_ARRAY_FORMAT.freeze,
@@ -283,13 +289,20 @@ class StringConverter
     PAnyType::DEFAULT      => Format.new('%s').freeze,    # unquoted string
   }.freeze
 
+  DEFAULT_PARAMETER_FORMAT = {
+    PCollectionType::DEFAULT => '%#p',
+    PObjectType::DEFAULT => '%#p',
+    PBinaryType::DEFAULT => '%p',
+    PStringType::DEFAULT => '%p',
+    PRuntimeType::DEFAULT => '%p'
+  }.freeze
 
   # Converts the given value to a String, under the direction of formatting rules per type.
   #
   # When converting to string it is possible to use a set of built in conversion rules.
   #
   # A format is specified on the form:
-  # 
+  #
   # ´´´
   # %[Flags][Width][.Precision]Format
   # ´´´
@@ -348,9 +361,9 @@ class StringConverter
   # Defaults to `s` at top level and `p` inside array or hash.
   #
   # ### Boolean
-  # 
+  #
   # | Format    | Boolean Formats
-  # | ----      | -------------------   
+  # | ----      | -------------------
   # | t T       | 'true'/'false' or 'True'/'False' , first char if alternate form is used (i.e. 't'/'f' or 'T'/'F').
   # | y Y       | 'yes'/'no', 'Yes'/'No', 'y'/'n' or 'Y'/'N' if alternative flag # is used
   # | dxXobB    | numeric value 0/1 in accordance with the given format which must be valid integer format
@@ -379,7 +392,7 @@ class StringConverter
   # | u         | 'undef', or 'undefined' if alternative # flag is used
   #
   # ### Default (value)
-  # 
+  #
   # | Format    | Default formats
   # | ------    | ---------------
   # | d D       | 'default' or 'Default', alternative form # causes value to be quoted
@@ -420,18 +433,18 @@ class StringConverter
   #
   # | Format    | Hash/Struct Formats
   # | ------    | -------------
-  # | h         | formats with `{ }` delimiters, `,` element separator and ` => ` inner element separator unless overridden by flags 
+  # | h         | formats with `{ }` delimiters, `,` element separator and ` => ` inner element separator unless overridden by flags
   # | s         | same as h
   # | p         | same as h
   # | a         | converts the hash to an array of [k,v] tuples and formats it using array rule(s)
-  # 
+  #
   # See "Flags" `<[({\|` for formatting of delimiters, and "Additional parameters for containers; Array and Hash" for
   # more information about options.
   #
   # The alternate form flag `#` will format each hash key/value entry indented on a separate line.
   #
   # ### Type
-  # 
+  #
   # | Format    | Array/Tuple Formats
   # | ------    | -------------
   # | s        | The same as p, quoted if alternative flag # is used
@@ -439,7 +452,7 @@ class StringConverter
   #
   # ### Flags
   #
-  # | Flag     | Effect 
+  # | Flag     | Effect
   # | ------   | ------
   # | (space)  | space instead of + for numeric output (- is shown), for containers skips delimiters
   # | #        | alternate format; prefix 0x/0x, 0 (octal) and 0b/0B for binary, Floats force decimal '.'. For g/G keep trailing 0.
@@ -448,7 +461,7 @@ class StringConverter
   # | 0        | pad with 0 instead of space for widths larger than value
   # | <[({\|   | defines an enclosing pair <> [] () {} or \| \| when used with a container type
   #
-  # 
+  #
   # ### Additional parameters for containers; Array and Hash
   #
   # For containers (Array and Hash), the format is specified by a hash where the following keys can be set:
@@ -456,7 +469,7 @@ class StringConverter
   # * `'separator'` - the separator string to use between elements, should not contain padding space at the end
   # * `'separator2'` - the separator string to use between association of hash entries key/value
   # * `'string_formats'´ - a map of type to format for elements contained in the container
-  # 
+  #
   # Note that the top level format applies to Array and Hash objects contained/nested in an Array or a Hash.
   #
   # Given format mappings are merged with (default) formats and a format specified for a narrower type
@@ -538,28 +551,48 @@ class StringConverter
   end
   private :validate_container_input
 
-  def string_PRuntimeType(val_type, val, format_map)
-    case (f = get_format(val_type, format_map))
+  def string_PObjectType(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
       val.to_s
     when :q
-      val.to_s.inspect
-    when :puppet
-      puppet_safe(val.to_s)
-    when :i, :d, :x, :o, :f, :puppet
-      converted = convert(o, PNumericType) # rest is default
-      "%#{f}" % converted
+      val.inspect
     else
-      throw(:failed_conversion, [o, PStringType::DEFAULT, f])
+      raise FormatError.new('Object', f.format, 'spq')
     end
   end
 
-  # Given an unsafe string make it safe for puppet
-  def puppet_safe(str)
-    str = str.inspect # all specials are now quoted
-    # all $ variables must be quoted
-    str.gsub!("\$", "\\\$")
-    str
+  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
+    # a hash or an array. If it can, then that representation is used instead.
+    if val.is_a?(Hash)
+      hash = val.to_hash
+      # Ensure that the returned value isn't derived from Hash
+      return string_PHashType(val_type, hash, format_map, indent) if hash.instance_of?(Hash)
+    elsif val.is_a?(Array)
+      array = val.to_a
+      # Ensure that the returned value isn't derived from Array
+      return string_PArrayType(val_type, array, format_map, indent) if array.instance_of?(Array)
+    end
+
+    f = get_format(val_type, format_map)
+    case f.format
+    when :s
+      val.to_s
+    when :p
+      puppet_quote(val.to_s)
+    when :q
+      val.inspect
+    else
+      raise FormatError.new('Runtime', f.format, 'spq')
+    end
   end
 
   # Basically string_PAnyType converts the value to a String and then formats it according
@@ -802,35 +835,65 @@ class StringConverter
   #
   # @api public
   def puppet_quote(str)
-    if str.ascii_only? && (str =~ /(?:'|\$|\p{Cntrl}|\\)/).nil?
-      "'#{str}'"
-    else
-      bld = '"'
-      str.codepoints do |codepoint|
-        case codepoint
-        when 0x09
-          bld << '\\t'
-        when 0x0a
-          bld << '\\n'
-        when 0x0d
-          bld << '\\r'
-        when 0x22
-          bld << '\\"'
-        when 0x24
-          bld << '\\$'
-        when 0x5c
-          bld << '\\\\'
+    # Assume that the string can be single quoted
+    bld = '\''
+    bld.force_encoding(str.encoding)
+    escaped = false
+    str.each_codepoint do |codepoint|
+      # Control characters and non-ascii characters cannot be present in a single quoted string
+      return puppet_double_quote(str) if codepoint < 0x20
+
+      if escaped
+        bld << 0x5c << codepoint
+        escaped = false
+      else
+        if codepoint == 0x27
+          bld << 0x5c << codepoint
+        elsif codepoint == 0x5c
+          escaped = true
+        elsif codepoint <= 0x7f
+          bld << codepoint
         else
-          if codepoint < 0x20 || codepoint > 0x7f
-            bld << sprintf('\\u{%X}', codepoint)
-          else
-            bld.concat(codepoint)
-          end
+          bld << [codepoint].pack('U')
         end
       end
-      bld << '"'
-      bld
     end
+
+    # If string ended with a backslash, then that backslash must be escaped
+    bld << 0x5c if escaped
+
+    bld << '\''
+    bld
+  end
+
+  def puppet_double_quote(str)
+    bld = '"'
+    str.each_codepoint do |codepoint|
+      case codepoint
+      when 0x09
+        bld << '\\t'
+      when 0x0a
+        bld << '\\n'
+      when 0x0d
+        bld << '\\r'
+      when 0x22
+        bld << '\\"'
+      when 0x24
+        bld << '\\$'
+      when 0x5c
+        bld << '\\\\'
+      else
+        if codepoint < 0x20
+          bld << sprintf('\\u{%X}', codepoint)
+        elsif codepoint <= 0x7f
+          bld << codepoint
+        else
+          bld << [codepoint].pack('U')
+        end
+      end
+    end
+    bld << '"'
+    bld
   end
 
   # @api private
@@ -838,13 +901,16 @@ class StringConverter
     f = get_format(val_type, format_map)
     case f.format
     when :p
-      Kernel.format(f.orig_fmt, val)
+      rx_s = val.options == 0 ? val.source : val.to_s
+      rx_s = rx_s.gsub(/\//, '\/') unless Gem::Version.new(RUBY_VERSION.dup) < Gem::Version.new('2.0.0')
+      str_regexp = "/#{rx_s}/"
+      f.orig_fmt == '%p' ? str_regexp : Kernel.format(f.orig_fmt.gsub('p', 's'), str_regexp)
     when :s
-      str_regexp = val.inspect
-      str_regexp = f.alt? ? "\"#{str_regexp[1..-2]}\"" : str_regexp
-      Kernel.format(f.orig_fmt, str_regexp)
+      str_regexp = val.options == 0 ? val.source : val.to_s
+      str_regexp = puppet_quote(str_regexp) if f.alt?
+      f.orig_fmt == '%s' ? str_regexp : Kernel.format(f.orig_fmt, str_regexp)
     else
-      raise FormatError.new('Regexp', f.format, 'rsp')
+      raise FormatError.new('Regexp', f.format, 'sp')
     end
   end
 
@@ -931,7 +997,7 @@ class StringConverter
 
   def is_container?(t)
     case t
-    when PArrayType, PHashType, PStructType, PTupleType
+    when PArrayType, PHashType, PStructType, PTupleType, PObjectType
       true
     else
       false

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

@@ -115,17 +115,6 @@ class TypeCalculator
     singleton.callable?(callable, args)
   end
 
-  # 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
-  #
-  # @api public
-  #
-  def self.string(t)
-    Puppet.deprecation_warning('TypeCalculator.string is deprecated. Use TypeFormatter')
-    TypeFormatter.string(t)
-  end
-
   # @api public
   def self.infer(o)
     singleton.infer(o)
@@ -141,18 +130,6 @@ class TypeCalculator
     singleton.infer_set(o)
   end
 
-  # @api public
-  def self.debug_string(t)
-    Puppet.deprecation_warning('TypeCalculator.debug_string is deprecated. Use TypeFormatter')
-    TypeFormatter.debug_string(t)
-  end
-
-  # @api public
-  def self.enumerable(t)
-    Puppet.deprecation_warning('TypeCalculator.enumerable is deprecated. Use iterable')
-    singleton.iterable(t)
-  end
-
   # @api public
   def self.iterable(t)
     singleton.iterable(t)
@@ -172,29 +149,6 @@ class TypeCalculator
     @@extract_visitor ||= Visitor.new(nil, 'extract',0,0)
   end
 
-  # Answers the question 'is it possible to inject an instance of the given class'
-  # A class is injectable if it has a special *assisted inject* class method called `inject` taking
-  # an injector and a scope as argument, or if it has a zero args `initialize` method.
-  #
-  # @param klazz [Class, PRuntimeType] the class/type to check if it is injectable
-  # @return [Class, nil] the injectable Class, or nil if not injectable
-  # @api public
-  #
-  def injectable_class(klazz)
-    # Handle case when we get a PType instead of a class
-    if klazz.is_a?(PRuntimeType)
-      klazz = ClassLoader.provide(klazz)
-    end
-
-    # data types can not be injected (check again, it is not safe to assume that given RubyRuntime klazz arg was ok)
-    return false unless type(klazz).is_a?(PRuntimeType)
-    if (klazz.respond_to?(:inject) && klazz.method(:inject).arity == -4) || klazz.instance_method(:initialize).arity == 0
-      klazz
-    else
-      nil
-    end
-  end
-
   # Answers 'can an instance of type t2 be assigned to a variable of type t'.
   # Does not accept nil/undef unless the type accepts it.
   #
@@ -260,11 +214,11 @@ class TypeCalculator
     when c == Class
       type = PType::DEFAULT
     when c == Array
-      # Assume array of data values
-      type = PArrayType::DATA
+      # Assume array of any
+      type = PArrayType::DEFAULT
     when c == Hash
-      # Assume hash with scalar keys and data values
-      type = PHashType::DATA
+      # Assume hash of any
+      type = PHashType::DEFAULT
    else
       type = PRuntimeType.new(:ruby, c.name)
     end
@@ -283,16 +237,16 @@ class TypeCalculator
   #
   def infer(o)
     # Optimize the most common cases into direct calls.
-    case o
-    when String
+    # Explicit if/elsif/else is faster than case
+    if o.is_a?(String)
       infer_String(o)
-    when Integer
+    elsif o.is_a?(Integer) # need subclasses for Ruby < 2.4
       infer_Integer(o)
-    when Array
+    elsif o.is_a?(Array)
       infer_Array(o)
-    when Hash
+    elsif o.is_a?(Hash)
       infer_Hash(o)
-    when Evaluator::PuppetProc
+    elsif o.is_a?(Evaluator::PuppetProc)
       infer_PuppetProc(o)
     else
       @@infer_visitor.visit_this_0(self, o)
@@ -307,15 +261,14 @@ class TypeCalculator
   # @api public
   #
   def infer_set(o)
-    case o
-      when Array
-        infer_set_Array(o)
-      when Hash
-        infer_set_Hash(o)
-      when SemanticPuppet::Version
-        infer_set_Version(o)
-      else
-        infer_set_Object(o)
+    if o.instance_of?(Array)
+      infer_set_Array(o)
+    elsif o.instance_of?(Hash)
+      infer_set_Hash(o)
+    elsif o.instance_of?(SemanticPuppet::Version)
+      infer_set_Version(o)
+    else
+      infer(o)
     end
   end
 
@@ -461,12 +414,16 @@ class TypeCalculator
       return PNumericType::DEFAULT
     end
 
+    if common_scalar_data?(t1, t2)
+      return PScalarDataType::DEFAULT
+    end
+
     if common_scalar?(t1, t2)
       return PScalarType::DEFAULT
     end
 
     if common_data?(t1,t2)
-      return PDataType::DEFAULT
+      return TypeFactory.data
     end
 
     # Meta types Type[Integer] + Type[String] => Type[Data]
@@ -474,6 +431,10 @@ class TypeCalculator
       return PType.new(common_type(t1.type, t2.type))
     end
 
+    if common_rich_data?(t1,t2)
+      return TypeFactory.rich_data
+    end
+
     # If both are Runtime types
     if t1.is_a?(PRuntimeType) && t2.is_a?(PRuntimeType)
       if t1.runtime == t2.runtime && t1.runtime_type_name == t2.runtime_type_name
@@ -509,23 +470,6 @@ class TypeCalculator
     result
   end
 
-  # Produces a string representing the type
-  # @api public
-  #
-  def string(t)
-    Puppet.deprecation_warning('TypeCalculator.string is deprecated. Use TypeFormatter')
-    TypeFormatter.singleton.string(t)
-  end
-
-  # Produces a debug string representing the type (possibly with more information that the regular string format)
-  # @api public
-  #
-  def debug_string(t)
-    Puppet.deprecation_warning('TypeCalculator.debug_string is deprecated. Use TypeFormatter')
-    TypeFormatter.singleton.debug_string(t)
-  end
-
-
   # Reduces an enumerable of types to a single common type.
   # @api public
   #
@@ -565,7 +509,7 @@ class TypeCalculator
   # @api private
   def infer_Object(o)
     if o.is_a?(PuppetObject)
-      o._ptype
+      o._pcore_type
     else
       name = o.class.name
       ir = Loaders.implementation_registry
@@ -690,10 +634,14 @@ class TypeCalculator
 
   # @api private
   def infer_Array(o)
-    if o.empty?
-      PArrayType::EMPTY
+    if o.instance_of?(Array)
+      if o.empty?
+        PArrayType::EMPTY
+      else
+        PArrayType.new(infer_and_reduce_type(o), size_as_type(o))
+      end
     else
-      PArrayType.new(infer_and_reduce_type(o), size_as_type(o))
+      infer_Object(o)
     end
   end
 
@@ -714,12 +662,16 @@ class TypeCalculator
 
   # @api private
   def infer_Hash(o)
-    if o.empty?
-      PHashType::EMPTY
+    if o.instance_of?(Hash)
+      if o.empty?
+        PHashType::EMPTY
+      else
+        ktype = infer_and_reduce_type(o.keys)
+        etype = infer_and_reduce_type(o.values)
+        PHashType.new(ktype, etype, size_as_type(o))
+      end
     else
-      ktype = infer_and_reduce_type(o.keys)
-      etype = infer_and_reduce_type(o.values)
-      PHashType.new(ktype, etype, size_as_type(o))
+      infer_Object(o)
     end
   end
 
@@ -819,8 +771,18 @@ class TypeCalculator
 
   private
 
+  def common_rich_data?(t1, t2)
+    d = TypeFactory.rich_data
+    d.assignable?(t1) && d.assignable?(t2)
+  end
+
   def common_data?(t1, t2)
-    PDataType::DEFAULT.assignable?(t1) && PDataType::DEFAULT.assignable?(t2)
+    d = TypeFactory.data
+    d.assignable?(t1) && d.assignable?(t2)
+  end
+
+  def common_scalar_data?(t1, t2)
+    PScalarDataType::DEFAULT.assignable?(t1) && PScalarDataType::DEFAULT.assignable?(t2)
   end
 
   def common_scalar?(t1, t2)

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

@@ -85,7 +85,7 @@ module TypeFactory
       size_type_or_value.nil? ? PStringType::DEFAULT : PStringType.new(size_type_or_value)
     else
       if Puppet[:strict] != :off
-        Puppet.warn_once(:deprecatation, "TypeFactory#string_multi_args", "Passing more than one argument to TypeFactory#string is deprecated")
+        Puppet.warn_once('deprecations', "TypeFactory#string_multi_args", "Passing more than one argument to TypeFactory#string is deprecated")
       end
       deprecated_second_argument.size == 1 ? PStringType.new(deprecated_second_argument[0]) : PEnumType.new(*deprecated_second_argument)
     end
@@ -252,13 +252,20 @@ module TypeFactory
     PPatternType.new(patterns)
   end
 
-  # Produces the Literal type
+  # Produces the Scalar type
   # @api public
   #
   def self.scalar
     PScalarType::DEFAULT
   end
 
+  # Produces the ScalarData type
+  # @api public
+  #
+  def self.scalar_data
+    PScalarDataType::DEFAULT
+  end
+
   # Produces a CallableType matching all callables
   # @api public
   #
@@ -325,7 +332,14 @@ module TypeFactory
   # @api public
   #
   def self.data
-    PDataType::DEFAULT
+    @data_t ||= TypeParser.singleton.parse('Data', Loaders.static_loader)
+  end
+
+  # Produces the RichData type
+  # @api public
+  #
+  def self.rich_data
+    @rich_data_t ||= TypeParser.singleton.parse('RichData', Loaders.static_loader)
   end
 
   # Creates an instance of the Undef type
@@ -422,18 +436,32 @@ module TypeFactory
     PHashType.new(key_type, value_type, size_type)
   end
 
+  # Produces a type for Array[Any]
+  # @api public
+  #
+  def self.array_of_any
+    PArrayType::DEFAULT
+  end
+
   # Produces a type for Array[Data]
   # @api public
   #
   def self.array_of_data
-    PArrayType::DATA
+    @array_of_data_t = PArrayType.new(data)
+  end
+
+  # Produces a type for Hash[Any,Any]
+  # @api public
+  #
+  def self.hash_of_any
+    PHashType::DEFAULT
   end
 
-  # Produces a type for Hash[Scalar, Data]
+  # Produces a type for Hash[String,Data]
   # @api public
   #
   def self.hash_of_data
-    PHashType::DATA
+    @hash_of_data_t = PHashType.new(string, data)
   end
 
   # Produces a type for NotUndef[T]