puppet 4.3.2-x64-mingw32 → 4.4.0-x64-mingw32

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

@@ -1,15 +1,16 @@
+module Puppet::Pops
+module Types
 # Helper module that makes creation of type objects simpler.
 # @api public
 #
-module Puppet::Pops::Types::TypeFactory
-  Types = Puppet::Pops::Types
-  @type_calculator = Types::TypeCalculator.singleton
+module TypeFactory
+  @type_calculator = TypeCalculator.singleton
 
   # Produces the Integer type
   # @api public
   #
   def self.integer
-    Types::PIntegerType::DEFAULT
+    PIntegerType::DEFAULT
   end
 
   # Produces an Integer range type
@@ -19,7 +20,7 @@ module Puppet::Pops::Types::TypeFactory
     # optimize eq with symbol (faster when it is left)
     from = :default == from if from == 'default'
     to = :default if to == 'default'
-    Types::PIntegerType.new(from, to)
+    PIntegerType.new(from, to)
   end
 
   # Produces a Float range type
@@ -29,21 +30,35 @@ module Puppet::Pops::Types::TypeFactory
     # optimize eq with symbol (faster when it is left)
     from = Float(from) unless :default == from || from.nil?
     to = Float(to) unless :default == to || to.nil?
-    Types::PFloatType.new(from, to)
+    PFloatType.new(from, to)
   end
 
   # Produces the Float type
   # @api public
   #
   def self.float
-    Types::PFloatType::DEFAULT
+    PFloatType::DEFAULT
   end
 
   # Produces the Numeric type
   # @api public
   #
   def self.numeric
-    Types::PNumericType::DEFAULT
+    PNumericType::DEFAULT
+  end
+
+  # Produces the Iterable type
+  # @api public
+  #
+  def self.iterable(elem_type = nil)
+    elem_type.nil? ? PIterableType::DEFAULT : PIterableType.new(elem_type)
+  end
+
+  # Produces the Iterator type
+  # @api public
+  #
+  def self.iterator(elem_type = nil)
+    elem_type.nil? ? PIteratorType::DEFAULT : PIteratorType.new(elem_type)
   end
 
   # Produces a string representation of the type
@@ -57,7 +72,7 @@ module Puppet::Pops::Types::TypeFactory
   # @api public
   #
   def self.string(size_type = nil, *values)
-    Types::PStringType.new(size_type, values)
+    PStringType.new(size_type, values)
   end
 
   # Produces the Optional type, i.e. a short hand for Variant[T, Undef]
@@ -70,21 +85,21 @@ module Puppet::Pops::Types::TypeFactory
   # @api public
   #
   def self.optional(optional_type = nil)
-    Types::POptionalType.new(type_of(optional_type.is_a?(String) ? string(nil, optional_type) : type_of(optional_type)))
+    POptionalType.new(type_of(optional_type.is_a?(String) ? string(nil, optional_type) : type_of(optional_type)))
   end
 
   # Produces the Enum type, optionally with specific string values
   # @api public
   #
   def self.enum(*values)
-    Types::PEnumType.new(values)
+    PEnumType.new(values)
   end
 
   # Produces the Variant type, optionally with the "one of" types
   # @api public
   #
   def self.variant(*types)
-    Types::PVariantType.new(types.map {|v| type_of(v) })
+    PVariantType.new(types.map {|v| type_of(v) })
   end
 
   # Produces the Struct type, either a non parameterized instance representing
@@ -102,53 +117,53 @@ module Puppet::Pops::Types::TypeFactory
     tc = @type_calculator
     elements = hash.map do |key_type, value_type|
       value_type = type_of(value_type)
-      raise ArgumentError, 'Struct element value_type must be a Type' unless value_type.is_a?(Types::PAnyType)
+      raise ArgumentError, 'Struct element value_type must be a Type' unless value_type.is_a?(PAnyType)
 
       # TODO: Should have stricter name rule
       if key_type.is_a?(String)
         raise ArgumentError, 'Struct element key cannot be an empty String' if key_type.empty?
         key_type = string(nil, key_type)
         # Must make key optional if the value can be Undef
-        key_type = optional(key_type) if tc.assignable?(value_type, Types::PUndefType::DEFAULT)
+        key_type = optional(key_type) if tc.assignable?(value_type, PUndefType::DEFAULT)
       else
         # assert that the key type is one of String[1], NotUndef[String[1]] and Optional[String[1]]
         case key_type
-        when Types::PNotUndefType
+        when PNotUndefType
           # We can loose the NotUndef wrapper here since String[1] isn't optional anyway
           key_type = key_type.type
           s = key_type
-        when Types::POptionalType
+        when POptionalType
           s = key_type.optional_type
-        when Types::PStringType, Types::PEnumType
+        when PStringType, PEnumType
           s = key_type
         else
           raise ArgumentError, "Illegal Struct member key type. Expected NotUndef, Optional, String, or Enum. Got: #{key_type.class.name}"
         end
-        unless (s.is_a?(Puppet::Pops::Types::PStringType) || s.is_a?(Puppet::Pops::Types::PEnumType)) && s.values.size == 1 && !s.values[0].empty?
+        unless (s.is_a?(PStringType) || s.is_a?(PEnumType)) && s.values.size == 1 && !s.values[0].empty?
           raise ArgumentError, "Unable to extract a non-empty literal string from Struct member key type #{tc.string(key_type)}"
         end
       end
-      Types::PStructElement.new(key_type, value_type)
+      PStructElement.new(key_type, value_type)
     end
-    Types::PStructType.new(elements)
+    PStructType.new(elements)
   end
 
   def self.tuple(types = [], size_type = nil)
-    Types::PTupleType.new(types.map {|elem| type_of(elem) }, size_type)
+    PTupleType.new(types.map {|elem| type_of(elem) }, size_type)
   end
 
   # Produces the Boolean type
   # @api public
   #
   def self.boolean
-    Types::PBooleanType::DEFAULT
+    PBooleanType::DEFAULT
   end
 
   # Produces the Any type
   # @api public
   #
   def self.any
-    Types::PAnyType::DEFAULT
+    PAnyType::DEFAULT
   end
 
   # Produces the Regexp type
@@ -158,11 +173,11 @@ module Puppet::Pops::Types::TypeFactory
   #
   def self.regexp(pattern = nil)
     if pattern
-      t = Types::PRegexpType.new(pattern.is_a?(Regexp) ? pattern.inspect[1..-2] : pattern)
+      t = PRegexpType.new(pattern.is_a?(Regexp) ? pattern.inspect[1..-2] : pattern)
       t.regexp unless pattern.nil? # compile pattern to catch errors
       t
     else
-      Types::PRegexpType::DEFAULT
+      PRegexpType::DEFAULT
     end
   end
 
@@ -170,7 +185,7 @@ module Puppet::Pops::Types::TypeFactory
     patterns = regular_expressions.map do |re|
       case re
       when String
-        re_t = Types::PRegexpType.new(re)
+        re_t = PRegexpType.new(re)
         re_t.regexp  # compile it to catch errors
         re_t
 
@@ -178,33 +193,33 @@ module Puppet::Pops::Types::TypeFactory
         # Regep.to_s includes options user did not enter and does not escape source
         # to work either as a string or as a // regexp. The inspect method does a better
         # job, but includes the //
-        Types::PRegexpType.new(re.inspect[1..-2])
+        PRegexpType.new(re.inspect[1..-2])
 
-      when Types::PRegexpType
+      when PRegexpType
         re
 
-      when Types::PPatternType
+      when PPatternType
         re.patterns
 
      else
        raise ArgumentError, "Only String, Regexp, Pattern-Type, and Regexp-Type are allowed: got '#{re.class}"
       end
     end.flatten.uniq
-    Types::PPatternType.new(patterns)
+    PPatternType.new(patterns)
   end
 
   # Produces the Literal type
   # @api public
   #
   def self.scalar
-    Types::PScalarType::DEFAULT
+    PScalarType::DEFAULT
   end
 
   # Produces a CallableType matching all callables
   # @api public
   #
   def self.all_callables
-    return Puppet::Pops::Types::PCallableType::DEFAULT
+    return PCallableType::DEFAULT
   end
 
   # Produces a Callable type with one signature without support for a block
@@ -224,7 +239,7 @@ module Puppet::Pops::Types::TypeFactory
   # Params are given as a sequence of arguments to {#type_of}.
   #
   def self.callable(*params)
-    last_callable = Puppet::Pops::Types::TypeCalculator.is_kind_of_callable?(params.last)
+    last_callable = TypeCalculator.is_kind_of_callable?(params.last)
     block_t = last_callable ? params.pop : nil
 
     # compute a size_type for the signature based on the two last parameters
@@ -242,42 +257,42 @@ module Puppet::Pops::Types::TypeFactory
 
     # If the specification requires types, and none were given, a Unit type is used
     if types.empty? && !size_type.nil? && size_type.range[1] > 0
-      types << Types::PUnitType::DEFAULT
+      types << PUnitType::DEFAULT
     end
     # create a signature
     tuple_t = tuple(types, size_type)
-    Types::PCallableType.new(tuple_t, block_t)
+    PCallableType.new(tuple_t, block_t)
   end
 
   # Produces the abstract type Collection
   # @api public
   #
   def self.collection(size_type = nil)
-    size_type.nil? ? Types::PCollectionType::DEFAULT : Types::PCollectionType.new(nil, size_type)
+    size_type.nil? ? PCollectionType::DEFAULT : PCollectionType.new(nil, size_type)
   end
 
   # Produces the Data type
   # @api public
   #
   def self.data
-    Types::PDataType::DEFAULT
+    PDataType::DEFAULT
   end
 
   # Creates an instance of the Undef type
   # @api public
   def self.undef
-    Types::PUndefType::DEFAULT
+    PUndefType::DEFAULT
   end
 
   # Creates an instance of the Default type
   # @api public
   def self.default
-    Types::PDefaultType::DEFAULT
+    PDefaultType::DEFAULT
   end
 
   # Produces an instance of the abstract type PCatalogEntryType
   def self.catalog_entry
-    Types::PCatalogEntryType::DEFAULT
+    PCatalogEntryType::DEFAULT
   end
 
   # Produces a PResourceType with a String type_name A PResourceType with a nil
@@ -286,15 +301,15 @@ module Puppet::Pops::Types::TypeFactory
   # 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?(Types::PResourceType)
+    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 =~ Puppet::Pops::Patterns::CLASSREF
+    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'
     end
-    Types::PResourceType.new(type_name, title)
+    PResourceType.new(type_name, title)
   end
 
   # Produces PHostClassType with a string class_name.  A PHostClassType with
@@ -304,9 +319,9 @@ module Puppet::Pops::Types::TypeFactory
   #
   def self.host_class(class_name = nil)
     if class_name.nil?
-      Types::PHostClassType::DEFAULT
+      PHostClassType::DEFAULT
     else
-      Types::PHostClassType.new(class_name.sub(/^::/, ''))
+      PHostClassType.new(class_name.sub(/^::/, ''))
     end
   end
 
@@ -315,7 +330,7 @@ module Puppet::Pops::Types::TypeFactory
   # @api public
   #
   def self.array_of(o, size_type = nil)
-    Types::PArrayType.new(type_of(o), size_type)
+    PArrayType.new(type_of(o), size_type)
   end
 
   # Produces a type for Hash[Scalar, o] where o is either a type, or an
@@ -323,21 +338,21 @@ module Puppet::Pops::Types::TypeFactory
   # @api public
   #
   def self.hash_of(value, key = scalar, size_type = nil)
-    Types::PHashType.new(type_of(key), type_of(value), size_type)
+    PHashType.new(type_of(key), type_of(value), size_type)
   end
 
   # Produces a type for Array[Data]
   # @api public
   #
   def self.array_of_data
-    Types::PArrayType::DATA
+    PArrayType::DATA
   end
 
   # Produces a type for Hash[Scalar, Data]
   # @api public
   #
   def self.hash_of_data
-    Types::PHashType::DATA
+    PHashType::DATA
   end
 
   # Produces a type for NotUndef[T]
@@ -345,20 +360,20 @@ module Puppet::Pops::Types::TypeFactory
   # the type String[inst_type].
   #
   # @param inst_type [Type,String] the type to qualify
-  # @return [Puppet::Pops::Types::PNotUndefType] the NotUndef type
+  # @return [PNotUndefType] the NotUndef type
   #
   # @api public
   #
   def self.not_undef(inst_type = nil)
     inst_type = string(nil, inst_type) if inst_type.is_a?(String)
-    Types::PNotUndefType.new(inst_type)
+    PNotUndefType.new(inst_type)
   end
 
   # Produces a type for Type[T]
   # @api public
   #
   def self.type_type(inst_type = nil)
-    inst_type.nil? ? Types::PType::DEFAULT : Types::PType.new(inst_type)
+    inst_type.nil? ? PType::DEFAULT : PType.new(inst_type)
   end
 
   # Produce a type corresponding to the class of given unless given is a
@@ -368,10 +383,10 @@ module Puppet::Pops::Types::TypeFactory
   def self.type_of(o)
     if o.is_a?(Class)
       @type_calculator.type(o)
-    elsif o.is_a?(Types::PAnyType)
+    elsif o.is_a?(PAnyType)
       o
     elsif o.is_a?(String)
-      Types::PRuntimeType.new(:ruby, o)
+      PRuntimeType.new(:ruby, o)
     else
       @type_calculator.infer_generic(o)
     end
@@ -395,7 +410,7 @@ module Puppet::Pops::Types::TypeFactory
     if o.is_a?(Class)
       @type_calculator.type(o)
     else
-      Types::PRuntimeType.new(:ruby, o.class.name)
+      PRuntimeType.new(:ruby, o.class.name)
     end
   end
 
@@ -404,7 +419,7 @@ module Puppet::Pops::Types::TypeFactory
   # or mapps a Ruby Class to its name.
   #
   def self.ruby_type(class_name = nil)
-    Types::PRuntimeType.new(:ruby, class_name)
+    PRuntimeType.new(:ruby, class_name)
   end
 
   # Generic creator of a RuntimeType - allows creating the type with nil or
@@ -412,7 +427,24 @@ module Puppet::Pops::Types::TypeFactory
   #
   def self.runtime(runtime=nil, runtime_type_name = nil)
     runtime = runtime.to_sym if runtime.is_a?(String)
-    Types::PRuntimeType.new(runtime, runtime_type_name)
+    PRuntimeType.new(runtime, runtime_type_name)
+  end
+
+  # Returns the type alias for the given expression
+  # @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)
+  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
+  # @return [PTypeReferenceType] the type reference
+  def self.type_reference(name, parameters = nil)
+    PTypeReferenceType.new(name, parameters)
   end
 
   # Returns true if the given type t is of valid range parameter type (integer
@@ -422,3 +454,5 @@ module Puppet::Pops::Types::TypeFactory
   end
 
 end
+end
+end

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

@@ -0,0 +1,334 @@
+module Puppet::Pops
+module Types
+# String
+# ------
+# Creates a string representation of a type.
+#
+# @api public
+#
+class TypeFormatter
+  # 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)
+    @singleton.string(t)
+  end
+
+  # @return [TypeCalculator] the singleton instance
+  #
+  # @api private
+  def self.singleton
+    @singleton
+  end
+
+  # Produces a string representing the type
+  # @api public
+  #
+  def string(t)
+    @@string_visitor.visit_this_0(self, t)
+  end
+
+  # Produces a string representing the type where type aliases have been expanded
+  # @api public
+  #
+  def alias_expanded_string(t)
+    @expand_aliases = true
+    begin
+      string(t)
+    ensure
+      @expand_aliases = false
+    end
+  end
+
+  # Produces a debug string representing the type (possibly with more information that the regular string format)
+  # @api public
+  #
+  def debug_string(t)
+    @debug = true
+    begin
+      string(t)
+    ensure
+      @debug = false
+    end
+  end
+
+  # @api private
+  def string_Module(t)
+    string(TypeCalculator.singleton.type(t))
+  end
+
+  # @api private
+  def string_NilClass(t)     ; '?'       ; end
+
+  # @api private
+  def string_String(t)       ; t.inspect ; end
+
+  # @api private
+  def string_Symbol(t)       ; t.to_s    ; end
+
+  # @api private
+  def string_PAnyType(t)     ; 'Any'     ; end
+
+  # @api private
+  def string_PUndefType(t)   ; 'Undef'   ; end
+
+  # @api private
+  def string_PDefaultType(t) ; 'Default' ; 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
+
+  # @api private
+  def string_PIntegerType(t)
+    append_array('Integer', range_array_part(t))
+  end
+
+  # @api private
+  def string_PType(t)
+    append_array('Type', t.type.nil? ? EMPTY_ARRAY : [string(t.type)])
+  end
+
+  # @api private
+  def string_PIterableType(t)
+    append_array('Iterable', t.element_type.nil? ? EMPTY_ARRAY : [string(t.element_type)])
+  end
+
+  # @api private
+  def string_PIteratorType(t)
+    append_array('Iterator', t.element_type.nil? ? EMPTY_ARRAY : [string(t.element_type)])
+  end
+
+  # @api private
+  def string_PFloatType(t)
+    append_array('Float', range_array_part(t))
+  end
+
+  # @api private
+  def string_PRegexpType(t)
+    append_array('Regexp', t.pattern.nil? ? EMPTY_ARRAY : [t.regexp.inspect])
+  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)
+  end
+
+  # @api private
+  def string_PEnumType(t)
+    append_array('Enum', t.values.map {|s| "'#{s}'" })
+  end
+
+  # @api private
+  def string_PVariantType(t)
+    append_array('Variant', t.types.map {|t2| string(t2) })
+  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)
+  end
+
+  # @api private
+  def string_PCallableType(t)
+    elements = EMPTY_ARRAY
+    unless t.param_types.nil?
+      # translate to string, and skip Unit types
+      elements = t.param_types.types.map {|t2| string(t2) unless t2.class == PUnitType }.compact
+
+      if t.param_types.types.empty?
+        elements += ['0', '0']
+      else
+        elements += range_array_part(t.param_types.size_type)
+      end
+
+      # Add block T last (after min, max) if present)
+      #
+      unless t.block_type.nil?
+        elements << string(t.block_type)
+      end
+    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)
+  end
+
+  # @api private
+  def hash_entry_PStructElement(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)]
+  end
+
+  # @api private
+  def string_PPatternType(t)
+    append_array('Pattern', t.patterns.map {|s| "#{s.regexp.inspect}" })
+  end
+
+  # @api private
+  def string_PCollectionType(t)
+    append_array('Collection', range_array_part(t.size_type))
+  end
+
+  # @api private
+  def string_PUnitType(t)
+    'Unit'
+  end
+
+  # @api private
+  def string_PRuntimeType(t)
+    append_array('Runtime', [string(t.runtime), string(t.runtime_type_name)])
+  end
+
+  # @api private
+  def string_PArrayType(t)
+    append_array('Array', t == PArrayType::DATA ? EMPTY_ARRAY : [string(t.element_type)] + range_array_part(t.size_type))
+  end
+
+  # @api private
+  def string_PHashType(t)
+    append_array('Hash', t == PHashType::DATA ? EMPTY_ARRAY : [string(t.key_type), string(t.element_type)] + range_array_part(t.size_type))
+  end
+
+  # @api private
+  def string_PCatalogEntryType(t)
+    'CatalogEntry'
+  end
+
+  # @api private
+  def string_PHostClassType(t)
+    append_array('Class', t.class_name.nil? ? EMPTY_ARRAY : [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}'"])
+    else
+      '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
+      if contained_type.is_a?(PStringType) && contained_type.values.size == 1
+        args = [ "'#{contained_type.values[0]}'" ]
+      else
+        args = [ string(contained_type) ]
+      end
+    end
+    append_array('NotUndef', args)
+  end
+
+  # @api private
+  def string_POptionalType(t)
+    optional_type = t.optional_type
+    if optional_type.nil?
+      args = EMPTY_ARRAY
+    else
+      if optional_type.is_a?(PStringType) && optional_type.values.size == 1
+        args = [ "'#{optional_type.values[0]}'" ]
+      else
+        args = [ string(optional_type) ]
+      end
+    end
+    append_array('Optional', args)
+  end
+
+  # @api private
+  def string_PTypeAliasType(t)
+    expand = @expand_aliases
+    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
+  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
+  end
+
+  # Debugging to_s to reduce the amount of output
+  def to_s
+    '[a TypeFormatter]'
+  end
+
+  private
+
+  NAME_SEGMENT_SEPARATOR = '::'.freeze
+
+  COMMA_SEP = ', '.freeze
+
+  HASH_ENTRY_OP = ' => '.freeze
+
+  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 ]
+  end
+
+  def append_array(bld, array)
+    case array.size
+    when 0
+    when 1
+      bld << '[' << array[0] << ']'
+    else
+      bld << '['
+      array.each { |elem| bld << elem << COMMA_SEP }
+      bld.chomp!(COMMA_SEP)
+      bld << ']'
+    end
+    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
+  end
+
+  def capitalize_segments(s)
+    s.split(NAME_SEGMENT_SEPARATOR).map(&:capitalize).join(NAME_SEGMENT_SEPARATOR)
+  end
+
+  @singleton = new
+  @@string_visitor = Visitor.new(nil, 'string',0,0)
+end
+end
+end