puppet 4.4.2-x64-mingw32 → 4.5.0-x64-mingw32

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

@@ -312,6 +312,8 @@ class TypeCalculator
         infer_set_Array(o)
       when Hash
         infer_set_Hash(o)
+      when Semantic::Version
+        infer_set_Version(o)
       else
         infer_set_Object(o)
     end
@@ -429,7 +431,7 @@ class TypeCalculator
 
     if t1.is_a?(PVariantType) && t2.is_a?(PVariantType)
       # The common type is one that complies with either set
-      return PVariantType.new(t1.types | t2.types)
+      return PVariantType.maybe_create(t1.types | t2.types)
     end
 
     if t1.is_a?(PRegexpType) && t2.is_a?(PRegexpType)
@@ -552,7 +554,14 @@ class TypeCalculator
 
   # @api private
   def infer_Object(o)
-    PRuntimeType.new(:ruby, o.class.name)
+    if o.is_a?(PuppetObject)
+      o._ptype
+    else
+      name = o.class.name
+      ir = Loaders.implementation_registry
+      type = ir.nil? ? nil : ir.type_for_module(name)
+      type.nil? ? PRuntimeType.new(:ruby, name) : type
+    end
   end
 
   # The type of all types is PType
@@ -652,7 +661,7 @@ class TypeCalculator
     # A mapping must be made to empty string. A nil value will result in an error later
     title = o.title
     title = '' if :undef == title
-    PType.new(PResourceType.new(o.type.to_s.downcase, title))
+    PType.new(PResourceType.new(o.type.to_s, title))
   end
 
   # @api private
@@ -664,6 +673,16 @@ class TypeCalculator
     end
   end
 
+  # @api private
+  def infer_Version(o)
+    PSemVerType::DEFAULT
+  end
+
+  # @api private
+  def infer_VersionRange(o)
+    PSemVerRangeType::DEFAULT
+  end
+
   # @api private
   def infer_Hash(o)
     if o.empty?
@@ -699,12 +718,17 @@ class TypeCalculator
     elsif o.keys.all? {|k| PStringType::NON_EMPTY.instance?(k) }
       PStructType.new(o.each_pair.map { |k,v| PStructElement.new(PStringType.new(size_as_type(k), [k]), infer_set(v)) })
     else
-      ktype = PVariantType.new(o.keys.map {|k| infer_set(k) })
-      etype = PVariantType.new(o.values.map {|e| infer_set(e) })
+      ktype = PVariantType.maybe_create(o.keys.map {|k| infer_set(k) })
+      etype = PVariantType.maybe_create(o.values.map {|e| infer_set(e) })
       PHashType.new(unwrap_single_variant(ktype), unwrap_single_variant(etype), size_as_type(o))
     end
   end
 
+  # @api private
+  def infer_set_Version(o)
+    PSemVerType.new(Semantic::VersionRange.new(o, o))
+  end
+
   def unwrap_single_variant(possible_variant)
     if possible_variant.is_a?(PVariantType) && possible_variant.types.size == 1
       possible_variant.types[0]

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

@@ -0,0 +1,15 @@
+
+module Puppet::Pops::Types
+  # Raised when a conversion of a value to another type failed.
+  #
+  class TypeConversionError < Puppet::Error
+
+    # Creates a new instance with a given message
+    #
+    # @param message [String] The error message describing what failed
+    #
+    def initialize(message)
+      super(message)
+    end
+  end
+end

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

@@ -99,7 +99,7 @@ module TypeFactory
   # @api public
   #
   def self.variant(*types)
-    PVariantType.new(types.map {|v| type_of(v) })
+    PVariantType.maybe_create(types.map {|v| type_of(v) })
   end
 
   # Produces the Struct type, either a non parameterized instance representing
@@ -110,7 +110,7 @@ module TypeFactory
   # The value can be a ruby class, a String (interpreted as the name of a ruby class) or
   # a Type.
   #
-  # @param hash [Hash<Object, Object>] key => value hash
+  # @param hash [{String,PAnyType=>PAnyType}] key => value hash
   # @return [PStructType] the created Struct type
   #
   def self.struct(hash = {})
@@ -148,6 +148,15 @@ module TypeFactory
     PStructType.new(elements)
   end
 
+  # Produces an `Object` type from the given _hash_ that represents the features of the object
+  #
+  # @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)
+  end
+
   def self.tuple(types = [], size_type = nil)
     PTupleType.new(types.map {|elem| type_of(elem) }, size_type)
   end
@@ -295,21 +304,35 @@ module TypeFactory
     PCatalogEntryType::DEFAULT
   end
 
+  # Produces an instance of the SemVerRange type
+  def self.sem_ver_range
+    PSemVerRangeType::DEFAULT
+  end
+
+  # Produces an instance of the SemVer type
+  def self.sem_ver(*ranges)
+    ranges.empty? ? PSemVerType::DEFAULT : PSemVerType::new(*ranges)
+  end
+
   # Produces a PResourceType with a String type_name A PResourceType with a nil
   # or empty name is compatible with any other PResourceType.  A PResourceType
   # with a given name is only compatible with a PResourceType with the same
   # name.  (There is no resource-type subtyping in Puppet (yet)).
   #
   def self.resource(type_name = nil, title = nil)
-    type_name = type_name.type_name if type_name.is_a?(PResourceType)
-    type_name = type_name.downcase unless type_name.nil?
-    unless type_name.nil? || type_name =~ Patterns::CLASSREF
-      raise ArgumentError, "Illegal type name '#{type.type_name}'"
-    end
-    if type_name.nil? && !title.nil?
-      raise ArgumentError, 'The type name cannot be nil, if title is given'
+    case type_name
+    when PResourceType
+      PResourceType.new(type_name.type_name, title)
+    when String
+      type_name = TypeFormatter.singleton.capitalize_segments(type_name)
+      raise ArgumentError, "Illegal type name '#{type_name}'" unless type_name =~ Patterns::CLASSREF_EXT
+      PResourceType.new(type_name, title)
+    when nil
+      raise ArgumentError, 'The type name cannot be nil, if title is given' unless title.nil?
+      PResourceType::DEFAULT
+    else
+      raise ArgumentError, "The type name cannot be a #{type_name.class.name}"
     end
-    PResourceType.new(type_name, title)
   end
 
   # Produces PHostClassType with a string class_name.  A PHostClassType with
@@ -341,6 +364,17 @@ module TypeFactory
     PHashType.new(type_of(key), type_of(value), size_type)
   end
 
+  # Produces a type for Hash[key,value,size]
+  # @param key_type [PAnyType] the key type
+  # @param value_type [PAnyType] the value type
+  # @param size_type [PIntegerType]
+  # @return [PHashType] the created hash type
+  # @api public
+  #
+  def self.hash_kv(key_type, value_type, size_type = nil)
+    PHashType.new(key_type, value_type, size_type)
+  end
+
   # Produces a type for Array[Data]
   # @api public
   #
@@ -434,17 +468,16 @@ module TypeFactory
   # @param name [String] the name of the unresolved type
   # @param expression [Model::Expression] an expression that will evaluate to a type
   # @return [PTypeAliasType] the type alias
-  def self.type_alias(name, expression)
-    PTypeAliasType.new(name, expression)
+  def self.type_alias(name = nil, expression = nil)
+    name.nil? ? PTypeAliasType::DEFAULT : PTypeAliasType.new(name, expression)
   end
 
   # Returns the type that represents a type reference with a given name and optional
   # parameters.
-  # @param name [String] the name of the type
-  # @param parameters [Array] the parameters
+  # @param type_string [String] the string form of the type
   # @return [PTypeReferenceType] the type reference
-  def self.type_reference(name, parameters = nil)
-    PTypeReferenceType.new(name, parameters)
+  def self.type_reference(type_string = nil)
+    type_string == nil ? PTypeReferenceType::DEFAULT : PTypeReferenceType.new(type_string)
   end
 
   # Returns true if the given type t is of valid range parameter type (integer

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

@@ -28,18 +28,71 @@ class TypeFormatter
   # @api public
   #
   def string(t)
-    @@string_visitor.visit_this_0(self, t)
+    @bld = ''
+    append_string(t)
+    @bld
+  end
+
+  # Produces an string containing newline characters and indentation that represents the given
+  # type or literal _t_.
+  #
+  # @param t [Object] the type or literal to produce a string for
+  # @param indent [Integer] the current indentation level
+  # @param indent_width [Integer] the number of spaces to use for one indentation
+  #
+  # @api public
+  def indented_string(t, indent = 0, indent_width = 2)
+    @indent = indent
+    @indent_width = indent_width
+    begin
+      @bld = ''
+      (@indent * @indent_width).times { @bld << ' ' }
+      append_string(t)
+      @bld << "\n"
+      @bld
+    ensure
+      @indent = nil
+      @indent_width = nil
+    end
+  end
+
+  # @api private
+  def ruby_string(ref_ctor, indent, t)
+    @ruby = true
+    @ref_ctor = ref_ctor
+    begin
+      indented_string(t, indent)
+    ensure
+      @ruby = nil
+      @ref_ctor = nil
+    end
+  end
+
+
+  def append_string(t)
+    if @ruby && t.is_a?(PAnyType)
+      @ruby = false
+      begin
+        @bld << @ref_ctor << "('"
+        @@string_visitor.visit_this_0(self, t)
+        @bld << "')"
+      ensure
+        @ruby = true
+      end
+    else
+      @@string_visitor.visit_this_0(self, t)
+    end
   end
 
   # Produces a string representing the type where type aliases have been expanded
   # @api public
   #
   def alias_expanded_string(t)
-    @expand_aliases = true
+    @expanded = true
     begin
       string(t)
     ensure
-      @expand_aliases = false
+      @expanded = false
     end
   end
 
@@ -56,254 +109,378 @@ class TypeFormatter
   end
 
   # @api private
-  def string_Module(t)
-    string(TypeCalculator.singleton.type(t))
-  end
-
-  # @api private
-  def string_NilClass(t)     ; '?'       ; end
+  def string_PAnyType(_)     ; @bld << 'Any'     ; end
 
   # @api private
-  def string_String(t)       ; t.inspect ; end
+  def string_PUndefType(_)   ; @bld << 'Undef'   ; end
 
   # @api private
-  def string_Symbol(t)       ; t.to_s    ; end
+  def string_PDefaultType(_) ; @bld << 'Default' ; end
 
   # @api private
-  def string_PAnyType(t)     ; 'Any'     ; end
+  def string_PBooleanType(_) ; @bld << 'Boolean' ; end
 
   # @api private
-  def string_PUndefType(t)   ; 'Undef'   ; end
+  def string_PScalarType(_)  ; @bld << 'Scalar'  ; end
 
   # @api private
-  def string_PDefaultType(t) ; 'Default' ; end
+  def string_PDataType(_)    ; @bld << 'Data'    ; end
 
   # @api private
-  def string_PBooleanType(t) ; 'Boolean' ; end
-
-  # @api private
-  def string_PScalarType(t)  ; 'Scalar'  ; end
-
-  # @api private
-  def string_PDataType(t)    ; 'Data'    ; end
-
-  # @api private
-  def string_PNumericType(t) ; 'Numeric' ; end
+  def string_PNumericType(_) ; @bld << 'Numeric' ; end
 
   # @api private
   def string_PIntegerType(t)
-    append_array('Integer', range_array_part(t))
+    append_array('Integer', t.unbounded?) { append_elements(range_array_part(t)) }
   end
 
   # @api private
   def string_PType(t)
-    append_array('Type', t.type.nil? ? EMPTY_ARRAY : [string(t.type)])
+    append_array('Type', t.type.nil?) { append_string(t.type) }
   end
 
   # @api private
   def string_PIterableType(t)
-    append_array('Iterable', t.element_type.nil? ? EMPTY_ARRAY : [string(t.element_type)])
+    append_array('Iterable', t.element_type.nil?)  { append_string(t.element_type) }
   end
 
   # @api private
   def string_PIteratorType(t)
-    append_array('Iterator', t.element_type.nil? ? EMPTY_ARRAY : [string(t.element_type)])
+    append_array('Iterator', t.element_type.nil?) { append_string(t.element_type) }
   end
 
   # @api private
   def string_PFloatType(t)
-    append_array('Float', range_array_part(t))
+    append_array('Float', t.unbounded? ) { append_elements(range_array_part(t)) }
   end
 
   # @api private
   def string_PRegexpType(t)
-    append_array('Regexp', t.pattern.nil? ? EMPTY_ARRAY : [t.regexp.inspect])
+    append_array('Regexp', t.pattern.nil?) { append_string(t.regexp) }
   end
 
   # @api private
   def string_PStringType(t)
-    elements = range_array_part(t.size_type)
-    elements += t.values.map {|s| "'#{s}'" } if @debug
-    append_array('String', elements)
+    range = range_array_part(t.size_type)
+    append_array('String', range.empty?) do
+      if @debug
+        append_elements(range, true)
+        append_strings(t.values, true)
+        chomp_list
+      else
+        append_elements(range)
+      end
+    end
   end
 
   # @api private
   def string_PEnumType(t)
-    append_array('Enum', t.values.map {|s| "'#{s}'" })
+    append_array('Enum', t.values.empty?) { append_strings(t.values) }
   end
 
   # @api private
   def string_PVariantType(t)
-    append_array('Variant', t.types.map {|t2| string(t2) })
+    append_array('Variant', t.types.empty?) { append_strings(t.types) }
+  end
+
+  # @api private
+  def string_PSemVerType(t)
+    append_array('SemVer', t.ranges.empty?) { append_strings(t.ranges) }
+  end
+
+  # @api private
+  def string_PSemVerRangeType(t)
+    @bld << 'SemVerRange'
   end
 
   # @api private
   def string_PTupleType(t)
-    type_strings = t.types.map {|t2| string(t2) }
-    type_strings += range_array_part(t.size_type) unless type_strings.empty?
-    append_array('Tuple', type_strings)
+    append_array('Tuple', t.types.empty?) do
+      append_strings(t.types, true)
+      append_elements(range_array_part(t.size_type), true)
+      chomp_list
+    end
   end
 
   # @api private
   def string_PCallableType(t)
-    elements = EMPTY_ARRAY
-    unless t.param_types.nil?
+    append_array('Callable', t.param_types.nil?) do
       # translate to string, and skip Unit types
-      elements = t.param_types.types.map {|t2| string(t2) unless t2.class == PUnitType }.compact
+      append_strings(t.param_types.types.reject {|t2| t2.class == PUnitType }, true)
 
       if t.param_types.types.empty?
-        elements += ['0', '0']
+        append_strings([0, 0], true)
       else
-        elements += range_array_part(t.param_types.size_type)
+        append_elements(range_array_part(t.param_types.size_type), true)
       end
 
       # Add block T last (after min, max) if present)
       #
-      unless t.block_type.nil?
-        elements << string(t.block_type)
-      end
+      append_strings([t.block_type], true) unless t.block_type.nil?
+      chomp_list
     end
-    append_array('Callable', elements)
   end
 
   # @api private
   def string_PStructType(t)
-    args = t.elements.empty? ? EMPTY_ARRAY : [append_hash('', t.elements.map {|e| hash_entry_PStructElement(e)})]
-    append_array('Struct', args)
+    append_array('Struct', t.elements.empty?) { append_hash(Hash[t.elements.map {|e| struct_element_pair(e) }]) }
   end
 
   # @api private
-  def hash_entry_PStructElement(t)
+  def struct_element_pair(t)
     k = t.key_type
     value_optional = t.value_type.assignable?(PUndefType::DEFAULT)
-    key_string =
-      if k.is_a?(POptionalType)
-        # Output as literal String
-        value_optional ? "'#{t.name}'" : string(k)
-      else
-        value_optional ? "NotUndef['#{t.name}']" : "'#{t.name}'"
-      end
-    [key_string, string(t.value_type)]
+    if k.is_a?(POptionalType)
+      # Output as literal String
+      k = t.name if value_optional
+    else
+      k = value_optional ? PNotUndefType.new(k) : t.name
+    end
+    [k, t.value_type]
   end
 
   # @api private
   def string_PPatternType(t)
-    append_array('Pattern', t.patterns.map {|s| "#{s.regexp.inspect}" })
+    append_array('Pattern', t.patterns.empty?) { append_strings(t.patterns.map(&:regexp)) }
   end
 
   # @api private
   def string_PCollectionType(t)
-    append_array('Collection', range_array_part(t.size_type))
+    range = range_array_part(t.size_type)
+    append_array('Collection', range.empty? ) { append_elements(range) }
   end
 
   # @api private
-  def string_PUnitType(t)
-    'Unit'
+  def string_PUnitType(_)
+    @bld << 'Unit'
   end
 
   # @api private
   def string_PRuntimeType(t)
-    append_array('Runtime', [string(t.runtime), string(t.runtime_type_name)])
-  end
-
-  def is_empty_range?(from, to)
-    from == 0 && to == 0
+    append_array('Runtime') { append_strings([t.runtime, t.name_or_pattern]) }
   end
 
   # @api private
   def string_PArrayType(t)
     if t.has_empty_range?
-      append_array('Array', ['0', '0'])
+      append_array('Array') { append_strings([0, 0]) }
     else
-      append_array('Array', t == PArrayType::DATA ? EMPTY_ARRAY : [string(t.element_type)] + range_array_part(t.size_type))
+      append_array('Array', t == PArrayType::DATA) do
+        append_strings([t.element_type], true)
+        append_elements(range_array_part(t.size_type), true)
+        chomp_list
+      end
     end
   end
 
   # @api private
   def string_PHashType(t)
     if t.has_empty_range?
-      append_array('Hash', ['0', '0'])
+      append_array('Hash') { append_strings([0, 0]) }
     else
-      append_array('Hash', t == PHashType::DATA ? EMPTY_ARRAY : [string(t.key_type), string(t.element_type)] + range_array_part(t.size_type))
+      append_array('Hash', t == PHashType::DATA) do
+        append_strings([t.key_type, t.element_type], true)
+        append_elements(range_array_part(t.size_type), true)
+        chomp_list
+      end
     end
   end
 
   # @api private
-  def string_PCatalogEntryType(t)
-    'CatalogEntry'
+  def string_PCatalogEntryType(_)
+    @bld << 'CatalogEntry'
   end
 
   # @api private
   def string_PHostClassType(t)
-    append_array('Class', t.class_name.nil? ? EMPTY_ARRAY : [t.class_name])
+    append_array('Class', t.class_name.nil?) { append_elements([t.class_name]) }
   end
 
   # @api private
   def string_PResourceType(t)
     if t.type_name
-      append_array(capitalize_segments(t.type_name), t.title.nil? ? EMPTY_ARRAY : ["'#{t.title}'"])
+      append_array(capitalize_segments(t.type_name), t.title.nil?) { append_string(t.title) }
     else
-      'Resource'
+      @bld << 'Resource'
     end
   end
 
   # @api private
   def string_PNotUndefType(t)
     contained_type = t.type
-    if contained_type.nil? || contained_type.class == PAnyType
-      args = EMPTY_ARRAY
-    else
+    append_array('NotUndef', contained_type.nil? || contained_type.class == PAnyType) do
       if contained_type.is_a?(PStringType) && contained_type.values.size == 1
-        args = [ "'#{contained_type.values[0]}'" ]
+        append_string(contained_type.values[0])
       else
-        args = [ string(contained_type) ]
+        append_string(contained_type)
       end
     end
-    append_array('NotUndef', args)
+  end
+
+  # @api private
+  def string_PAnnotatedMember(m)
+    hash = m.i12n_hash
+    if hash.size == 1
+      string(m.type)
+    else
+      string(hash)
+    end
+  end
+
+  # Used when printing names of well known keys in an Object type. Placed in a separate
+  # method to allow override.
+  # @api private
+  def symbolic_key(key)
+    @ruby ? "'#{key}'" : key
+  end
+
+  # @api private
+  def string_PObjectType(t)
+    if @expanded
+      begin
+        @expanded = false
+        append_array('Object') do
+          append_hash(t.i12n_hash.each, proc { |k| @bld << symbolic_key(k) }) do |k,v|
+            case k
+            when PObjectType::KEY_ATTRIBUTES, PObjectType::KEY_FUNCTIONS
+              # Types might need to be output as type references
+              append_hash(v) do |_, fv|
+                if fv.is_a?(Hash)
+                  append_hash(fv, proc { |fak| @bld << symbolic_key(fak) }) do |fak,fav|
+                    case fak
+                    when PObjectType::KEY_KIND
+                      @bld << fav
+                    else
+                      append_string(fav)
+                    end
+                  end
+                else
+                  append_string(fv)
+                end
+              end
+            when PObjectType::KEY_EQUALITY
+              append_array('') { append_strings(v) } if v.is_a?(Array)
+            else
+              append_string(v)
+            end
+          end
+        end
+      ensure
+        @expanded = true
+      end
+    else
+      @bld << t.label
+    end
   end
 
   # @api private
   def string_POptionalType(t)
     optional_type = t.optional_type
-    if optional_type.nil?
-      args = EMPTY_ARRAY
-    else
+    append_array('Optional', optional_type.nil?) do
       if optional_type.is_a?(PStringType) && optional_type.values.size == 1
-        args = [ "'#{optional_type.values[0]}'" ]
+        append_string(optional_type.values[0])
       else
-        args = [ string(optional_type) ]
+        append_string(optional_type)
       end
     end
-    append_array('Optional', args)
   end
 
   # @api private
   def string_PTypeAliasType(t)
-    expand = @expand_aliases
+    expand = @expanded
     if expand && t.self_recursion?
       @guard ||= RecursionGuard.new
       expand = (@guard.add_this(t) & RecursionGuard::SELF_RECURSION_IN_THIS) == 0
     end
-    expand ? "#{t.name} = #{string(t.resolved_type)}" : t.name
+    @bld << t.name
+    if expand
+      @bld << ' = '
+      append_string(t.resolved_type)
+    end
   end
 
   # @api private
   def string_PTypeReferenceType(t)
-    if t.parameters.empty?
-      t.name
-    else
-      append_array(t.name.clone, t.parameters.map {|p| string(p) })
-    end
+    append_array('TypeReference') { append_string(t.type_string) }
+  end
+
+  # @api private
+  def string_Array(t)
+    append_array('') { append_strings(t) }
+  end
+
+  # @api private
+  def string_FalseClass(t)   ; @bld << 'false'       ; end
+
+  # @api private
+  def string_Hash(t)
+    append_hash(t)
+  end
+
+  # @api private
+  def string_Module(t)
+    append_string(TypeCalculator.singleton.type(t))
   end
 
+  # @api private
+  def string_NilClass(t)     ; @bld << (@ruby ? 'nil' : '?') ; end
+
+  # @api private
+  def string_Numeric(t)      ; @bld << t.to_s    ; end
+
+  # @api private
+  def string_Regexp(t)       ; @bld << t.inspect; end
+
+  # @api private
+  def string_String(t)
+    # Use single qoute on strings that does not contain single quotes, control characters, or backslashes.
+    # TODO: This should move to StringConverter when this formatter is changed to take advantage of it
+    @bld << (t.ascii_only? && (t =~ /^(?:'|\p{Cntrl}|\\)$/).nil? ? "'#{t}'" : t.inspect)
+  end
+
+  # @api private
+  def string_Symbol(t)       ; @bld << t.to_s    ; end
+
+  # @api private
+  def string_TrueClass(t)    ; @bld << 'true'    ; end
+
+  # @api private
+  def string_Version(t)      ; @bld << "'#{t}'"  ; end
+
+  # @api private
+  def string_VersionRange(t) ; @bld << "'#{t}'"  ; end
+
   # Debugging to_s to reduce the amount of output
   def to_s
     '[a TypeFormatter]'
   end
 
-  private
-
   NAME_SEGMENT_SEPARATOR = '::'.freeze
+  STARTS_WITH_ASCII_CAPITAL = /^[A-Z]/
+
+  # Capitalizes each segment in a name separated with the {NAME_SEPARATOR} conditionally. The name
+  # will not be subject to capitalization if it already starts with a capital letter. This to avoid
+  # that existing camel casing is lost.
+  #
+  # @param qualified_name [String] the name to capitalize
+  # @return [String] the capitalized name
+  #
+  # @api private
+  def capitalize_segments(qualified_name)
+    if !qualified_name.is_a?(String) || qualified_name =~ STARTS_WITH_ASCII_CAPITAL
+      qualified_name
+    else
+      segments = qualified_name.split(NAME_SEGMENT_SEPARATOR)
+      if segments.size == 1
+        qualified_name.capitalize
+      else
+        segments.each(&:capitalize!)
+        segments.join(NAME_SEGMENT_SEPARATOR)
+      end
+    end
+  end
+
+  private
 
   COMMA_SEP = ', '.freeze
 
@@ -313,30 +490,76 @@ class TypeFormatter
     t.nil? || t.unbounded? ? EMPTY_ARRAY : [t.from.nil? ? 'default' : t.from.to_s , t.to.nil? ? 'default' : t.to.to_s ]
   end
 
-  def append_array(bld, array)
+  def append_elements(array, to_be_continued = false)
     case array.size
     when 0
     when 1
-      bld << '[' << array[0] << ']'
+      @bld << array[0]
+      @bld << COMMA_SEP if to_be_continued
     else
-      bld << '['
-      array.each { |elem| bld << elem << COMMA_SEP }
-      bld.chomp!(COMMA_SEP)
-      bld << ']'
+      array.each { |elem| @bld << elem << COMMA_SEP }
+      chomp_list unless to_be_continued
+    end
+  end
+
+  def append_strings(array, to_be_continued = false)
+    case array.size
+    when 0
+    when 1
+      append_string(array[0])
+      @bld << COMMA_SEP if to_be_continued
+    else
+      array.each do |elem|
+        append_string(elem)
+        @bld << COMMA_SEP
+      end
+      chomp_list unless to_be_continued
+    end
+  end
+
+  def append_array(start, empty = false)
+    @bld << start
+    unless empty
+      @bld << '['
+      yield
+      @bld << ']'
+    end
+  end
+
+  def append_hash(hash, key_proc = nil)
+    @bld << '{'
+    @indent += 1 if @indent
+    hash.each do |k, v|
+      newline if @indent
+      if key_proc.nil?
+        append_string(k)
+      else
+        key_proc.call(k)
+      end
+      @bld << HASH_ENTRY_OP
+      if block_given?
+        yield(k, v)
+      else
+        append_string(v)
+      end
+      @bld << COMMA_SEP
+    end
+    chomp_list
+    if @indent
+      @indent -= 1
+      newline
     end
-    bld
+    @bld << '}'
   end
 
-  def append_hash(bld, hash_entries)
-    bld << '{'
-    hash_entries.each { |k, v| bld << k  << HASH_ENTRY_OP << v << COMMA_SEP }
-    bld.chomp!(COMMA_SEP)
-    bld << '}'
-    bld
+  def newline
+    @bld.rstrip!
+    @bld << "\n"
+    (@indent * @indent_width).times { @bld << ' ' }
   end
 
-  def capitalize_segments(s)
-    s.split(NAME_SEGMENT_SEPARATOR).map(&:capitalize).join(NAME_SEGMENT_SEPARATOR)
+  def chomp_list
+    @bld.chomp!(COMMA_SEP)
   end
 
   @singleton = new