puppet 8.2.0-x64-mingw32 → 8.4.0-x64-mingw32

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Types
-
 KEY_NAME_AUTHORITY = 'name_authority'
 KEY_TYPES = 'types'
 KEY_ALIAS = 'alias'
@@ -10,7 +10,6 @@ KEY_VERSION_RANGE = 'version_range'
 KEY_REFERENCES = 'references'
 
 class PTypeSetType < PMetaType
-
   # A Loader that makes the types known to the TypeSet visible
   #
   # @api private
@@ -40,23 +39,27 @@ class PTypeSetType < PMetaType
   TYPE_STRING_OR_VERSION = TypeFactory.variant(PStringType::NON_EMPTY, TypeFactory.sem_ver)
   TYPE_STRING_OR_RANGE = TypeFactory.variant(PStringType::NON_EMPTY, TypeFactory.sem_ver_range)
 
-  TYPE_TYPE_REFERENCE_I12N = TypeFactory.struct({
-    KEY_NAME => Pcore::TYPE_QUALIFIED_REFERENCE,
-    KEY_VERSION_RANGE => TYPE_STRING_OR_RANGE,
-    TypeFactory.optional(KEY_NAME_AUTHORITY) => Pcore::TYPE_URI,
-    TypeFactory.optional(KEY_ANNOTATIONS) => TYPE_ANNOTATIONS
-  })
-
-  TYPE_TYPESET_I12N = TypeFactory.struct({
-    TypeFactory.optional(Pcore::KEY_PCORE_URI) => Pcore::TYPE_URI,
-    Pcore::KEY_PCORE_VERSION => TYPE_STRING_OR_VERSION,
-    TypeFactory.optional(KEY_NAME_AUTHORITY) => Pcore::TYPE_URI,
-    TypeFactory.optional(KEY_NAME) => Pcore::TYPE_QUALIFIED_REFERENCE,
-    TypeFactory.optional(KEY_VERSION) => TYPE_STRING_OR_VERSION,
-    TypeFactory.optional(KEY_TYPES) => TypeFactory.hash_kv(Pcore::TYPE_SIMPLE_TYPE_NAME, PVariantType.new([PTypeType::DEFAULT, PObjectType::TYPE_OBJECT_I12N]), PCollectionType::NOT_EMPTY_SIZE),
-    TypeFactory.optional(KEY_REFERENCES) => TypeFactory.hash_kv(Pcore::TYPE_SIMPLE_TYPE_NAME, TYPE_TYPE_REFERENCE_I12N, PCollectionType::NOT_EMPTY_SIZE),
-    TypeFactory.optional(KEY_ANNOTATIONS) => TYPE_ANNOTATIONS,
-  })
+  TYPE_TYPE_REFERENCE_I12N =
+    TypeFactory
+      .struct({
+                KEY_NAME => Pcore::TYPE_QUALIFIED_REFERENCE,
+                KEY_VERSION_RANGE => TYPE_STRING_OR_RANGE,
+                TypeFactory.optional(KEY_NAME_AUTHORITY) => Pcore::TYPE_URI,
+                TypeFactory.optional(KEY_ANNOTATIONS) => TYPE_ANNOTATIONS
+              })
+
+  TYPE_TYPESET_I12N =
+    TypeFactory
+      .struct({
+                TypeFactory.optional(Pcore::KEY_PCORE_URI) => Pcore::TYPE_URI,
+                Pcore::KEY_PCORE_VERSION => TYPE_STRING_OR_VERSION,
+                TypeFactory.optional(KEY_NAME_AUTHORITY) => Pcore::TYPE_URI,
+                TypeFactory.optional(KEY_NAME) => Pcore::TYPE_QUALIFIED_REFERENCE,
+                TypeFactory.optional(KEY_VERSION) => TYPE_STRING_OR_VERSION,
+                TypeFactory.optional(KEY_TYPES) => TypeFactory.hash_kv(Pcore::TYPE_SIMPLE_TYPE_NAME, PVariantType.new([PTypeType::DEFAULT, PObjectType::TYPE_OBJECT_I12N]), PCollectionType::NOT_EMPTY_SIZE),
+                TypeFactory.optional(KEY_REFERENCES) => TypeFactory.hash_kv(Pcore::TYPE_SIMPLE_TYPE_NAME, TYPE_TYPE_REFERENCE_I12N, PCollectionType::NOT_EMPTY_SIZE),
+                TypeFactory.optional(KEY_ANNOTATIONS) => TYPE_ANNOTATIONS,
+              })
 
   def self.register_ptype(loader, ir)
     create_ptype(loader, ir, 'AnyType', '_pcore_init_hash' => TYPE_TYPESET_I12N.resolve(loader))
@@ -113,7 +116,7 @@ class PTypeSetType < PMetaType
     @pcore_version = PSemVerType.convert(init_hash[Pcore::KEY_PCORE_VERSION]).freeze
     unless Pcore::PARSABLE_PCORE_VERSIONS.include?(@pcore_version)
       raise ArgumentError,
-        "The pcore version for TypeSet '#{@name}' is not understood by this runtime. Expected range #{Pcore::PARSABLE_PCORE_VERSIONS}, got #{@pcore_version}"
+            "The pcore version for TypeSet '#{@name}' is not understood by this runtime. Expected range #{Pcore::PARSABLE_PCORE_VERSIONS}, got #{@pcore_version}"
     end
 
     @pcore_uri = init_hash[Pcore::KEY_PCORE_URI].freeze
@@ -146,6 +149,7 @@ class PTypeSetType < PMetaType
           unless ranges.all? { |range| (range & ref.version_range).nil? }
             raise ArgumentError, "TypeSet '#{@name}' references TypeSet '#{ref_na}/#{ref_name}' more than once using overlapping version ranges"
           end
+
           ranges << ref.version_range
         end
 
@@ -155,6 +159,7 @@ class PTypeSetType < PMetaType
         if @types.has_key?(ref_alias)
           raise ArgumentError, "TypeSet '#{@name}' references a TypeSet using alias '#{ref_alias}'. The alias collides with the name of a declared type"
         end
+
         ref_map[ref_alias] = ref
 
         @dc_to_cc_map[ref_alias.downcase] = ref_alias
@@ -173,7 +178,7 @@ class PTypeSetType < PMetaType
   def _pcore_init_hash
     result = super()
     result[Pcore::KEY_PCORE_URI] = @pcore_uri unless @pcore_uri.nil?
-    result[Pcore::KEY_PCORE_VERSION] =  @pcore_version.to_s
+    result[Pcore::KEY_PCORE_VERSION] = @pcore_version.to_s
     result[KEY_NAME_AUTHORITY] = @name_authority unless @name_authority.nil?
     result[KEY_NAME] = @name
     result[KEY_VERSION] = @version.to_s unless @version.nil?
@@ -193,6 +198,7 @@ class PTypeSetType < PMetaType
   def [](qname)
     if qname.is_a?(Loader::TypedName)
       return nil unless qname.type == :type && qname.name_authority == @name_authority
+
       qname = qname.name
     end
 
@@ -354,13 +360,15 @@ class PTypeSetType < PMetaType
     o.is_a?(PTypeSetType)
   end
 
-  DEFAULT = self.new({
-    KEY_NAME => 'DefaultTypeSet',
-    KEY_NAME_AUTHORITY => Pcore::RUNTIME_NAME_AUTHORITY,
-    Pcore::KEY_PCORE_URI => Pcore::PCORE_URI,
-    Pcore::KEY_PCORE_VERSION => Pcore::PCORE_VERSION,
-    KEY_VERSION => SemanticPuppet::Version.new(0,0,0)
-  })
+  DEFAULT =
+    self
+      .new({
+             KEY_NAME => 'DefaultTypeSet',
+             KEY_NAME_AUTHORITY => Pcore::RUNTIME_NAME_AUTHORITY,
+             Pcore::KEY_PCORE_URI => Pcore::PCORE_URI,
+             Pcore::KEY_PCORE_VERSION => Pcore::PCORE_VERSION,
+             KEY_VERSION => SemanticPuppet::Version.new(0,0,0)
+           })
 
   protected
 

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
+
 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
 
@@ -37,20 +37,26 @@ class PURIType < PAnyType
     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_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,
@@ -67,9 +73,9 @@ class PURIType < PAnyType
 
   def self.register_ptype(loader, ir)
     create_ptype(loader, ir, 'AnyType',
-      {
-        'parameters' => { KEY_TYPE => TypeFactory.optional(TYPE_URI_PARAM_TYPE), KEY_VALUE => nil }
-      }
+                 {
+                   'parameters' => { KEY_TYPE => TypeFactory.optional(TYPE_URI_PARAM_TYPE), KEY_VALUE => nil }
+                 }
     )
   end
 
@@ -152,6 +158,7 @@ class PURIType < PAnyType
   def _assignable?(o, guard = nil)
     return false unless o.class == self.class
     return true if @parameters.nil?
+
     o_params = o.parameters || EMPTY_HASH
 
     eval = Parser::EvaluatingParser.singleton.evaluator

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Types
-
 # Marker module for implementations that are mapped to Object types
 # @api public
 module PuppetObject

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Types
 # Keeps track of self recursion of conceptual 'this' and 'that' instances using two separate maps and
@@ -8,6 +9,10 @@ module Types
 #
 # All comparisons are made using the `object_id` of the instance rather than the instance itself.
 #
+# Hash#compare_by_identity is intentionally not used since we only need to keep
+# track of object ids we've seen before, based on object_id, so we don't store
+# entire objects in memory.
+#
 # @api private
 class RecursionGuard
   attr_reader :state
@@ -25,14 +30,14 @@ class RecursionGuard
   # @param instance [Object] the instance to check
   # @return [Integer] the resulting state
   def recursive_this?(instance)
-    instance_variable_defined?(:@recursive_this_map) && @recursive_this_map.has_key?(instance.object_id)
+    instance_variable_defined?(:@recursive_this_map) && @recursive_this_map.has_key?(instance.object_id) # rubocop:disable Lint/HashCompareByIdentity
   end
 
   # Checks if recursion was detected for the given argument in the 'that' context
   # @param instance [Object] the instance to check
   # @return [Integer] the resulting state
   def recursive_that?(instance)
-    instance_variable_defined?(:@recursive_that_map) && @recursive_that_map.has_key?(instance.object_id)
+    instance_variable_defined?(:@recursive_that_map) && @recursive_that_map.has_key?(instance.object_id) # rubocop:disable Lint/HashCompareByIdentity
   end
 
   # Add the given argument as 'this' invoke the given block with the resulting state

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

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Types
-
 # @api private
 class RubyGenerator < TypeFormatter
-
   RUBY_RESERVED_WORDS = {
     'alias' => '_alias',
     'begin' => '_begin',
@@ -45,6 +44,7 @@ class RubyGenerator < TypeFormatter
     segments = name.split(TypeFormatter::NAME_SEGMENT_SEPARATOR)
     namespace_segments.size.times do |idx|
       break if segments.empty? || namespace_segments[idx] != segments[0]
+
       segments.shift
     end
     segments
@@ -60,7 +60,7 @@ class RubyGenerator < TypeFormatter
       if cls.nil?
         rp = key.resolved_parent
         parent_class = rp.is_a?(PObjectType) ? rp.implementation_class : Object
-        class_def = String.new
+        class_def = ''.dup
         class_body(key, EMPTY_ARRAY, class_def)
         cls = Class.new(parent_class)
         cls.class_eval(class_def)
@@ -70,6 +70,7 @@ class RubyGenerator < TypeFormatter
       hash[key] = cls
     end
     raise ArgumentError, "Expected a Puppet Type, got '#{obj.class.name}'" unless obj.is_a?(PAnyType)
+
     @dynamic_classes[obj]
   end
 
@@ -105,11 +106,12 @@ class RubyGenerator < TypeFormatter
     min_prefix_length.times do |idx|
       segment = segments_array[0][idx]
       break unless segments_array.all? { |sn| sn[idx] == segment }
+
       common_prefix << segment
     end
 
     # Create class definition of all contained types
-    bld = String.new
+    bld = ''.dup
     start_module(common_prefix, comment, bld)
     class_names = []
     names_by_prefix.each_pair do |seg_array, index_and_name_array|
@@ -159,6 +161,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
     end
   end
@@ -363,7 +366,7 @@ class RubyGenerator < TypeFormatter
         if array_type?(cp.type)
           bld << '    @' << rname(cp.name) << ".each { |value| yield(value) }\n"
         else
-          bld << '    yield(@' << rname(cp.name) << ') unless @' << rname(cp.name)  << ".nil?\n"
+          bld << '    yield(@' << rname(cp.name) << ') unless @' << rname(cp.name) << ".nil?\n"
         end
       end
       bld << "  end\n\n  def _pcore_all_contents(path, &block)\n    path << self\n"
@@ -405,7 +408,7 @@ class RubyGenerator < TypeFormatter
       bld << "\n  def eql?(o)\n"
       bld << "    super &&\n" unless obj.parent.nil?
       bld << "    o.instance_of?(self.class) &&\n" if include_type
-      eq_names.each { |eqn| bld << '    @' << rname(eqn) << '.eql?(o.' <<  rname(eqn) << ") &&\n" }
+      eq_names.each { |eqn| bld << '    @' << rname(eqn) << '.eql?(o.' << rname(eqn) << ") &&\n" }
       bld.chomp!(" &&\n")
       bld << "\n  end\n  alias == eql?\n"
     end

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

@@ -1,15 +1,16 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Types
   class RubyMethod < Annotation
     # Register the Annotation type. This is the type that all custom Annotations will inherit from.
     def self.register_ptype(loader, ir)
       @type = Pcore::create_object_type(loader, ir, self, 'RubyMethod', 'Annotation',
-        'body' => PStringType::DEFAULT,
-        'parameters' => {
-          KEY_TYPE => POptionalType.new(PStringType::NON_EMPTY),
-          KEY_VALUE => nil
-        }
+                                        'body' => PStringType::DEFAULT,
+                                        'parameters' => {
+                                          KEY_TYPE => POptionalType.new(PStringType::NON_EMPTY),
+                                          KEY_VALUE => nil
+                                        }
       )
     end
 

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

@@ -1,16 +1,15 @@
 # frozen_string_literal: true
+
 require_relative '../../../puppet/concurrent/thread_local_singleton'
 
 module Puppet::Pops
 module Types
-
 # Converts Puppet runtime objects to String under the control of a Format.
 # Use from Puppet Language is via the function `new`.
 #
 # @api private
 #
 class StringConverter
-
   # @api private
   class FormatError < ArgumentError
     def initialize(type_string, actual, expected)
@@ -111,11 +110,13 @@ class StringConverter
       unless @format.is_a?(String) && @format.length == 1
         raise ArgumentError, "The format must be a one letter format specifier, got '#{@format}'"
       end
+
       @format = @format.to_sym
       flags  = match[1].split('') || []
       unless flags.uniq.size == flags.size
         raise ArgumentError, "The same flag can only be used once, got '#{fmt}'"
       end
+
       @left  = flags.include?('-')
       @alt   = flags.include?('#')
       @plus  = (flags.include?(' ') ? :space : (flags.include?('+') ? :plus : :ignore))
@@ -124,10 +125,11 @@ class StringConverter
       @delimiters = nil
       DELIMITERS.each do |d|
         next unless flags.include?(d)
-          if !@delimiters.nil?
-            raise ArgumentError, "Only one of the delimiters [ { ( < | can be given in the format flags, got '#{fmt}'"
-          end
-          @delimiters = d
+        if !@delimiters.nil?
+          raise ArgumentError, "Only one of the delimiters [ { ( < | can be given in the format flags, got '#{fmt}'"
+        end
+
+        @delimiters = d
       end
 
       @width = match[2] ? match[2].to_i : nil
@@ -155,6 +157,7 @@ class StringConverter
       unless lower && higher
         return lower || higher
       end
+
       lower.merge(higher)
     end
 
@@ -226,6 +229,7 @@ class StringConverter
         0
       end
     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
     #
@@ -260,7 +264,7 @@ class StringConverter
   # (basically strings are quoted since they may contain a ','))
   #
   DEFAULT_CONTAINER_FORMATS = {
-    PAnyType::DEFAULT  => Format.new('%p').freeze,   # quoted string (Ruby inspect)
+    PAnyType::DEFAULT => Format.new('%p').freeze, # quoted string (Ruby inspect)
   }.freeze
 
   DEFAULT_ARRAY_FORMAT                          = Format.new('%a')
@@ -279,13 +283,13 @@ 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,
-    PHashType::DEFAULT     => DEFAULT_HASH_FORMAT.freeze,
-    PBinaryType::DEFAULT   => Format.new('%B').freeze,    # strict base64 string unquoted
-    PAnyType::DEFAULT      => Format.new('%s').freeze,    # unquoted string
+    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,
+    PHashType::DEFAULT => DEFAULT_HASH_FORMAT.freeze,
+    PBinaryType::DEFAULT => Format.new('%B').freeze, # strict base64 string unquoted
+    PAnyType::DEFAULT => Format.new('%s').freeze, # unquoted string
   }.freeze
 
   DEFAULT_PARAMETER_FORMAT = {
@@ -487,8 +491,8 @@ class StringConverter
         # 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 }}
+        # 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 }
@@ -497,7 +501,7 @@ class StringConverter
 
     case string_formats
     when :default
-     # do nothing, use default formats
+    # do nothing, use default formats
 
     when Hash
       # Convert and validate user input
@@ -511,14 +515,14 @@ class StringConverter
     _convert(value_type, value, options, DEFAULT_INDENTATION)
   end
 
-#  # A method only used for manual debugging as the default output of the formatting rules is
-#  # very hard to read otherwise.
-#  #
-#  # @api private
-#  def dump_string_formats(f, indent = 1)
-#     return f.to_s unless f.is_a?(Hash)
-#     "{#{f.map {|k,v| "#{k.to_s} => #{dump_string_formats(v,indent+1)}"}.join(",\n#{'  '*indent}  ")}}"
-#  end
+  #  # A method only used for manual debugging as the default output of the formatting rules is
+  #  # very hard to read otherwise.
+  #  #
+  #  # @api private
+  #  def dump_string_formats(f, indent = 1)
+  #     return f.to_s unless f.is_a?(Hash)
+  #     "{#{f.map {|k,v| "#{k.to_s} => #{dump_string_formats(v,indent+1)}"}.join(",\n#{'  '*indent}  ")}}"
+  #  end
 
   def _convert(val_type, value, format_map, indentation)
     @string_visitor.visit_this_3(self, val_type, value, format_map, indentation)
@@ -530,11 +534,13 @@ class StringConverter
     unless fmt.is_a?(Hash)
       raise ArgumentError, "expected a hash with type to format mappings, got instance of '#{fmt.class}'"
     end
+
     fmt.reduce({}) do | result, entry|
       key, value = entry
       unless key.is_a?(Types::PAnyType)
         raise ArgumentError, "top level keys in the format hash must be data types, got instance of '#{key.class}'"
       end
+
       if value.is_a?(Hash)
         result[key] = validate_container_input(value)
       else
@@ -551,6 +557,7 @@ class StringConverter
     if (fmt.keys - FMT_KEYS).size > 0
       raise ArgumentError, "only #{FMT_KEYS.map {|k| "'#{k}'"}.join(', ')} are allowed in a container format, got #{fmt}"
     end
+
     result                          = Format.new(fmt['format'])
     result.separator                = fmt['separator']
     result.separator2               = fmt['separator2']
@@ -619,36 +626,37 @@ class StringConverter
   def string_PDefaultType(val_type, val, format_map, _)
     f = get_format(val_type, format_map)
     apply_string_flags(f, case f.format
-    when :d, :s, :p
-      f.alt? ? '"default"' : 'default'
-    when :D
-      f.alt? ? '"Default"' : 'Default'
-    else
-      raise FormatError.new('Default', f.format, 'dDsp')
-    end)
+                          when :d, :s, :p
+                            f.alt? ? '"default"' : 'default'
+                          when :D
+                            f.alt? ? '"Default"' : 'Default'
+                          else
+                            raise FormatError.new('Default', f.format, 'dDsp')
+                          end)
   end
 
   # @api private
   def string_PUndefType(val_type, val, format_map, _)
     f = get_format(val_type, format_map)
     apply_string_flags(f, case f.format
-    when :n
-      f.alt? ? 'null' : 'nil'
-    when :u
-      f.alt? ? 'undefined' : 'undef'
-    when :d, :x, :X, :o, :b, :B, :e, :E, :f, :g, :G, :a, :A
-      'NaN'
-    when :v
-      'n/a'
-    when :V
-      'N/A'
-    when :s
-      f.alt? ? '""' : ''
-    when :p
-      f.alt? ? '"undef"' : 'undef'
-    else
-      raise FormatError.new('Undef', f.format, 'nudxXobBeEfgGaAvVsp')
-    end)
+                          when :n
+                            f.alt? ? 'null' : 'nil'
+                          when :u
+                            f.alt? ? 'undefined' : 'undef'
+                          when :d, :x, :X, :o, :b, :B, :e, :E, :f, :g, :G, :a, :A
+                            'NaN'
+                          when :v
+                            'n/a'
+                          when :V
+                            'N/A'
+                          when :s
+                            f.alt? ? '""' : ''
+                          when :p
+                            f.alt? ? '"undef"' : 'undef'
+                          else
+                            raise FormatError.new('Undef', f.format,
+                                                  'nudxXobBeEfgGaAvVsp')
+                          end)
   end
 
   # @api private
@@ -701,7 +709,7 @@ class StringConverter
   # Performs post-processing of literals to apply width and precision flags
   def apply_string_flags(f, literal_str)
     if f.left || f.width || f.prec
-      fmt = String.new('%')
+      fmt = '%'.dup
       fmt << '-' if f.left
       fmt << f.width.to_s if f.width
       fmt << '.' << f.prec.to_s if f.prec
@@ -815,23 +823,23 @@ class StringConverter
 
     when :c
       c_val = val.capitalize
-      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.tr('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.tr('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.tr('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.tr('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
+    when :t # trim
       c_val = val.strip
-      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.tr('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')
@@ -853,7 +861,7 @@ class StringConverter
     end
 
     # Assume that the string can be single quoted
-    bld = String.new('\'')
+    bld = "'".dup
     bld.force_encoding(str.encoding)
     escaped = false
     str.each_codepoint do |codepoint|
@@ -879,12 +887,12 @@ class StringConverter
     # If string ended with a backslash, then that backslash must be escaped
     bld << 0x5c if escaped
 
-    bld << '\''
+    bld << "'"
     bld
   end
 
   def puppet_double_quote(str)
-    bld = String.new('"')
+    bld = '"'.dup
     str.each_codepoint do |codepoint|
       case codepoint
       when 0x09
@@ -940,7 +948,7 @@ class StringConverter
 
     case format.format
     when :a, :s, :p
-      buf = String.new
+      buf = ''.dup
       if indentation.breaks?
         buf << "\n"
         buf << indentation.padding
@@ -1055,7 +1063,7 @@ class StringConverter
 
     when :h, :s, :p
       indentation = indentation.indenting(format.alt? || indentation.is_indenting?)
-      buf = String.new
+      buf = ''.dup
       if indentation.breaks?
         buf << "\n"
         buf << indentation.padding
@@ -1067,7 +1075,7 @@ class StringConverter
         padding = children_indentation.padding
       end
       buf << delims[0]
-      buf << cond_break  # break after opening delimiter if pretty printing
+      buf << cond_break # break after opening delimiter if pretty printing
       buf << val.map do |k,v|
         key_type = TypeCalculator.infer_set(k)
         val_type = TypeCalculator.infer_set(v)
@@ -1126,10 +1134,10 @@ class StringConverter
   def get_format(val_t, format_options)
     fmt = format_options.find {|k,_| k.assignable?(val_t) }
     return fmt[1] unless fmt.nil?
+
     return Format.new("%s")
   end
   private :get_format
-
 end
 end
 end