bolt 0.24.0 → 0.25.0

data/vendored/puppet/lib/puppet/pops/serialization/to_stringified_converter.rb

@@ -1,226 +0,0 @@
-module Puppet::Pops
-module Serialization
-
-  # Class that can process an arbitrary object into a value that is assignable to `Data`
-  # and where contents is converted from rich data to one of:
-  # * Numeric (Integer, Float)
-  # * Boolean 
-  # * Undef (nil)
-  # * String
-  # * Array
-  # * Hash
-  # 
-  # The conversion is lossy - the result cannot be deserialized to produce the original data types.
-  # All rich values are transformed to strings..
-  # Hashes with rich keys are transformed to use string representation of such keys.
-  #
-  # @api public
-  class ToStringifiedConverter
-    include Evaluator::Runtime3Support
-
-    # Converts the given _value_ according to the given _options_ and return the result of the conversion
-    #
-    # @param value [Object] the value to convert
-    # @param options {Symbol => <Boolean,String>} options hash
-    # @option options [String] :message_prefix String to prepend to in warnings and errors
-    # @option options [String] :semantic object (AST) to pass to the issue reporter
-    # @return [Data] the processed result. An object assignable to `Data` with rich data stringified.
-    #
-    # @api public
-    def self.convert(value, options = EMPTY_HASH)
-      new(options).convert(value)
-    end
-
-    # Creates a new instance of the processor
-    #
-    # @param options {Symbol => Object} options hash
-    # @option options [String] :message_prefix String to prepend to path in warnings and errors
-    # @option semantic [Object] :semantic object to pass to the issue reporter
-    def initialize(options = EMPTY_HASH)
-      @message_prefix = options[:message_prefix]
-      @semantic = options[:semantic]
-    end
-
-    # Converts the given _value_
-    #
-    # @param value [Object] the value to convert
-    # @return [Data] the processed result. An object assignable to `Data` with rich data stringified.
-    #
-    # @api public
-    def convert(value)
-      @path = []
-      @values = {}
-      to_data(value)
-    end
-
-    private
-
-    def path_to_s
-      s = @message_prefix || ''
-      s << JsonPath.to_json_path(@path)[1..-1]
-      s
-    end
-
-    def to_data(value)
-      if value.is_a?(String)
-        to_string_or_binary(value)
-      elsif value.nil? || Types::PScalarDataType::DEFAULT.instance?(value)
-        value
-      elsif :default == value
-        'default'
-      elsif value.is_a?(Symbol)
-        value.to_s
-      elsif value.instance_of?(Array)
-        process(value) do
-          result = []
-          value.each_with_index do |elem, index|
-            with(index) { result << to_data(elem) }
-          end
-          result
-        end
-      elsif value.instance_of?(Hash)
-        process(value) do
-          if value.keys.all? { |key| key.is_a?(String) && key != PCORE_TYPE_KEY && key != PCORE_VALUE_KEY }
-            result = {}
-            value.each_pair { |key, elem| with(key) { result[key] = to_data(elem) } }
-            result
-          else
-            non_string_keyed_hash_to_data(value)
-          end
-        end
-      else
-        unknown_to_string(value)
-      end
-    end
-
-    # Turns an ASCII-8BIT encoded string into a Binary, returns US_ASCII encoded and transforms all other strings to UTF-8
-    # with replacements for non Unicode characters.
-    # If String cannot be represented as UTF-8
-    def to_string_or_binary(value)
-      encoding = value.encoding
-      if encoding == Encoding::ASCII_8BIT
-        Puppet::Pops::Types::PBinaryType::Binary.from_binary_string(value).to_s
-      else
-        # Transform to UTF-8 (do not assume UTF-8 is correct) with source invalid byte
-        # sequences and UTF-8 undefined characters replaced by the default unicode uFFFD character
-        # (black diamond with question mark).
-        value.encode(Encoding::UTF_8, encoding, :invalid => :replace, :undef => :replace)
-      end
-    end
-
-    # Performs a check for endless recursion before
-    # it yields to the given block. The result of yielding is returned.
-    #
-    # @param value [Object] the value
-    # @yield The block that will produce the data for the value
-    # @return [Data] the result of yielding to the given block, or a hash denoting a reference
-    #
-    # @api private
-    def process(value, &block)
-      with_recursive_guard(value, &block)
-    end
-
-    # Pushes `key` to the end of the path and yields to the given block. The
-    # `key` is popped when the yield returns.
-    # @param key [Object] the key to push on the current path
-    # @yield The block that will produce the returned value
-    # @return [Object] the result of yielding to the given block
-    #
-    # @api private
-    def with(key)
-      @path.push(key)
-      value = yield
-      @path.pop
-      value
-    end
-
-    # @param value [Object] the value to use when checking endless recursion
-    # @yield The block that will produce the data
-    # @return [Data] the result of yielding to the given block
-    def with_recursive_guard(value)
-      id = value.object_id
-      if @recursive_lock
-        if @recursive_lock.include?(id)
-          serialization_issue(Issues::SERIALIZATION_ENDLESS_RECURSION, :type_name => value.class.name)
-        end
-        @recursive_lock[id] = true
-      else
-        @recursive_lock = { id => true }
-      end
-      v = yield
-      @recursive_lock.delete(id)
-      v
-    end
-
-    # A hash key that is non conforming
-    def unknown_key_to_string(value)
-      unknown_to_string(value)
-    end
-
-    def unknown_to_string(value)
-      if value.is_a?(Regexp)
-        return Puppet::Pops::Types::PRegexpType.regexp_to_s_with_delimiters(value)
-
-      elsif value.instance_of?(Types::PSensitiveType::Sensitive)
-        # to_s does not differentiate between instances - if they were used as keys in a hash
-        # the stringified result would override all Sensitive keys with the last such key's value
-        # this adds object_id.
-        #
-        return "#<#{value}:#{value.object_id}>"
-
-      elsif value.is_a?(Puppet::Pops::Types::PObjectType)
-        # regular to_s on an ObjectType gives the entire definition
-        return value.name
-
-      end
-
-      # Do a to_s on anything else
-      result = value.to_s
-
-      # The result may be ascii-8bit encoded without being a binary (low level object.inspect returns ascii-8bit string)
-      # This can be the case if runtime objects have very simple implementation (no to_s or inspect method).
-      # They are most likely not of Binary nature. Therefore the encoding is forced and only if it errors
-      # will the result be taken as binary and encoded as base64 string.
-      if result.encoding == Encoding::ASCII_8BIT
-        begin
-          result.force_encoding(Encoding::UTF_8)
-        rescue
-          # The result cannot be represented in UTF-8, make it a binary Base64 encoded string
-          Puppet::Pops::Types::PBinaryType::Binary.from_binary_string(result).to_s
-        end
-      end
-      result
-    end
-
-    def non_string_keyed_hash_to_data(hash)
-      result = {}
-      hash.each_pair do |key, value|
-        if key.is_a?(Symbol)
-          key = key.to_s
-        elsif !key.is_a?(String)
-          key = unknown_key_to_string(key)
-        end
-        if key == "__ptype" || key =="__pvalue"
-          key = "reserved key: #{key}"
-        end
-        with(key) { result[key] = to_data(value) }
-      end
-      result
-    end
-
-    def serialization_issue(issue, options = EMPTY_HASH)
-      semantic = @semantic
-      if semantic.nil?
-        tos = Puppet::Pops::PuppetStack.top_of_stack
-        if tos.empty?
-          semantic = Puppet::Pops::SemanticError.new(issue, nil, EMPTY_HASH)
-        else
-          file, line = stacktrace
-          semantic = Puppet::Pops::SemanticError.new(issue, nil, {:file => file, :line => line})
-        end
-      end
-      optionally_fail(issue,  semantic, options)
-    end
-  end
-end
-end

data/vendored/puppet/lib/puppet/pops/time/timespan.rb

@@ -1,718 +0,0 @@
-module Puppet::Pops
-module Time
-  NSECS_PER_USEC = 1000
-  NSECS_PER_MSEC = NSECS_PER_USEC * 1000
-  NSECS_PER_SEC  = NSECS_PER_MSEC * 1000
-  NSECS_PER_MIN  = NSECS_PER_SEC  * 60
-  NSECS_PER_HOUR = NSECS_PER_MIN  * 60
-  NSECS_PER_DAY  = NSECS_PER_HOUR * 24
-
-  KEY_STRING = 'string'.freeze
-  KEY_FORMAT = 'format'.freeze
-  KEY_NEGATIVE = 'negative'.freeze
-  KEY_DAYS = 'days'.freeze
-  KEY_HOURS = 'hours'.freeze
-  KEY_MINUTES = 'minutes'.freeze
-  KEY_SECONDS = 'seconds'.freeze
-  KEY_MILLISECONDS = 'milliseconds'.freeze
-  KEY_MICROSECONDS = 'microseconds'.freeze
-  KEY_NANOSECONDS = 'nanoseconds'.freeze
-
-  # TimeData is a Numeric that stores its value internally as nano-seconds but will be considered to be seconds and fractions of
-  # seconds when used in arithmetic or comparison with other Numeric types.
-  #
-  class TimeData < Numeric
-    include LabelProvider
-
-    attr_reader :nsecs
-
-    def initialize(nanoseconds)
-      @nsecs = nanoseconds
-    end
-
-    def <=>(o)
-      case o
-      when self.class
-        @nsecs <=> o.nsecs
-      when Integer
-        to_int <=> o
-      when Float
-        to_f <=> o
-      else
-        nil
-      end
-    end
-
-    def label(o)
-      Utils.name_to_segments(o.class.name).last
-    end
-
-    # @return [Float] the number of seconds
-    def to_f
-      @nsecs.fdiv(NSECS_PER_SEC)
-    end
-
-    # @return [Integer] the number of seconds with fraction part truncated
-    def to_int
-      @nsecs / NSECS_PER_SEC
-    end
-
-    def to_i
-      to_int
-    end
-
-    # @return [Complex] short for `#to_f.to_c`
-    def to_c
-      to_f.to_c
-    end
-
-    # @return [Rational] initial numerator is nano-seconds and denominator is nano-seconds per second
-    def to_r
-      Rational(@nsecs, NSECS_PER_SEC)
-    end
-
-    undef_method :phase, :polar, :rect, :rectangular
-  end
-
-  class Timespan < TimeData
-    def self.from_fields(negative, days, hours, minutes, seconds, milliseconds = 0, microseconds = 0, nanoseconds = 0)
-      ns = (((((days * 24 + hours) * 60 + minutes) * 60 + seconds) * 1000 + milliseconds) * 1000 + microseconds) * 1000 + nanoseconds
-      new(negative ? -ns : ns)
-    end
-
-    def self.from_hash(hash)
-      hash.include?('string') ? from_string_hash(hash) : from_fields_hash(hash)
-    end
-
-    def self.from_string_hash(hash)
-      parse(hash[KEY_STRING], hash[KEY_FORMAT] || Format::DEFAULTS)
-    end
-
-    def self.from_fields_hash(hash)
-      from_fields(
-        hash[KEY_NEGATIVE] || false,
-        hash[KEY_DAYS] || 0,
-        hash[KEY_HOURS] || 0,
-        hash[KEY_MINUTES] || 0,
-        hash[KEY_SECONDS] || 0,
-        hash[KEY_MILLISECONDS] || 0,
-        hash[KEY_MICROSECONDS] || 0,
-        hash[KEY_NANOSECONDS] || 0)
-    end
-
-    def self.parse(str, format = Format::DEFAULTS)
-      if format.is_a?(::Array)
-        format.each do |fmt|
-          fmt = FormatParser.singleton.parse_format(fmt) unless fmt.is_a?(Format)
-          begin
-            return fmt.parse(str)
-          rescue ArgumentError
-          end
-        end
-        raise ArgumentError, _("Unable to parse '%{str}' using any of the formats %{formats}") % { str: str, formats: format.join(', ') }
-      end
-      format = FormatParser.singleton.parse_format(format) unless format.is_a?(Format)
-      format.parse(str)
-    end
-
-    # @return [true] if the stored value is negative
-    def negative?
-      @nsecs < 0
-    end
-
-    def +(o)
-      case o
-      when Timestamp
-        Timestamp.new(@nsecs + o.nsecs)
-      when Timespan
-        Timespan.new(@nsecs + o.nsecs)
-      when Integer, Float
-        # Add seconds
-        Timespan.new(@nsecs + (o * NSECS_PER_SEC).to_i)
-      else
-        raise ArgumentError, _("%{klass} cannot be added to a Timespan") % { klass: a_an_uc(o) } unless o.is_a?(Timespan)
-      end
-    end
-
-    def -(o)
-      case o
-      when Timespan
-        Timespan.new(@nsecs - o.nsecs)
-      when Integer, Float
-        # Subtract seconds
-        Timespan.new(@nsecs - (o * NSECS_PER_SEC).to_i)
-      else
-        raise ArgumentError, _("%{klass} cannot be subtracted from a Timespan") % { klass: a_an_uc(o) }
-      end
-    end
-
-    def -@
-      Timespan.new(-@nsecs)
-    end
-
-    def *(o)
-      case o
-      when Integer, Float
-        Timespan.new((@nsecs * o).to_i)
-      else
-        raise ArgumentError, _("A Timestamp cannot be multiplied by %{klass}") % { klass: a_an(o) }
-      end
-    end
-
-    def divmod(o)
-      case o
-      when Integer
-        to_i.divmod(o)
-      when Float
-        to_f.divmod(o)
-      else
-        raise ArgumentError, _("Can not do modulus on a Timespan using a %{klass}") % { klass: a_an(o) }
-      end
-    end
-
-    def modulo(o)
-      divmod(o)[1]
-    end
-
-    def %(o)
-      modulo(o)
-    end
-
-    def div(o)
-      case o
-      when Timespan
-        # Timespan/Timespan yields a Float
-        @nsecs.fdiv(o.nsecs)
-      when Integer, Float
-        Timespan.new(@nsecs.div(o))
-      else
-        raise ArgumentError, _("A Timespan cannot be divided by %{klass}") % { klass: a_an(o) }
-      end
-    end
-
-    def /(o)
-      div(o)
-    end
-
-    # @return [Integer] a positive integer denoting the number of days
-    def days
-      total_days
-    end
-
-    # @return [Integer] a positive integer, 0 - 23 denoting hours of day
-    def hours
-      total_hours % 24
-    end
-
-    # @return [Integer] a positive integer, 0 - 59 denoting minutes of hour
-    def minutes
-      total_minutes % 60
-    end
-
-    # @return [Integer] a positive integer, 0 - 59 denoting seconds of minute
-    def seconds
-      total_seconds % 60
-    end
-
-    # @return [Integer] a positive integer, 0 - 999 denoting milliseconds of second
-    def milliseconds
-      total_milliseconds % 1000
-    end
-
-    # @return [Integer] a positive integer, 0 - 999.999.999 denoting nanoseconds of second
-    def nanoseconds
-      total_nanoseconds % NSECS_PER_SEC
-    end
-
-    # Formats this timestamp into a string according to the given `format`
-    #
-    # @param [String,Format] format The format to use when producing the string
-    # @return [String] the string representing the formatted timestamp
-    # @raise [ArgumentError] if the format is a string with illegal format characters
-    # @api public
-    def format(format)
-      format = FormatParser.singleton.parse_format(format) unless format.is_a?(Format)
-      format.format(self)
-    end
-
-    # Formats this timestamp into a string according to {Format::DEFAULTS[0]}
-    #
-    # @return [String] the string representing the formatted timestamp
-    # @api public
-    def to_s
-      format(Format::DEFAULTS[0])
-    end
-
-    def to_hash(compact = false)
-      result = {}
-      n = nanoseconds
-      if compact
-        s = total_seconds
-        result[KEY_SECONDS] = negative? ? -s : s
-        result[KEY_NANOSECONDS] = negative? ? -n : n unless n == 0
-      else
-        add_unless_zero(result, KEY_DAYS, days)
-        add_unless_zero(result, KEY_HOURS, hours)
-        add_unless_zero(result, KEY_MINUTES, minutes)
-        add_unless_zero(result, KEY_SECONDS, seconds)
-        unless n == 0
-          add_unless_zero(result, KEY_NANOSECONDS, n % 1000)
-          n /= 1000
-          add_unless_zero(result, KEY_MICROSECONDS, n % 1000)
-          add_unless_zero(result, KEY_MILLISECONDS, n / 1000)
-        end
-        result[KEY_NEGATIVE] = true if negative?
-      end
-      result
-    end
-
-    def add_unless_zero(result, key, value)
-      result[key] = value unless value == 0
-    end
-    private :add_unless_zero
-
-    # @api private
-    def total_days
-      total_nanoseconds / NSECS_PER_DAY
-    end
-
-    # @api private
-    def total_hours
-      total_nanoseconds / NSECS_PER_HOUR
-    end
-
-    # @api private
-    def total_minutes
-      total_nanoseconds / NSECS_PER_MIN
-    end
-
-    # @api private
-    def total_seconds
-      total_nanoseconds / NSECS_PER_SEC
-    end
-
-    # @api private
-    def total_milliseconds
-      total_nanoseconds / NSECS_PER_MSEC
-    end
-
-    # @api private
-    def total_microseconds
-      total_nanoseconds / NSECS_PER_USEC
-    end
-
-    # @api private
-    def total_nanoseconds
-      @nsecs.abs
-    end
-
-    # Represents a compiled Timestamp format. The format is used both when parsing a timestamp
-    # in string format and when producing a string from a timestamp instance.
-    #
-    class Format
-      # A segment is either a string that will be represented literally in the formatted timestamp
-      # or a value that corresponds to one of the possible format characters.
-      class Segment
-        def append_to(bld, ts)
-          raise NotImplementedError, "'#{self.class.name}' should implement #append_to"
-        end
-
-        def append_regexp(bld, ts)
-          raise NotImplementedError, "'#{self.class.name}' should implement #append_regexp"
-        end
-
-        def multiplier
-          raise NotImplementedError, "'#{self.class.name}' should implement #multiplier"
-        end
-      end
-
-      class LiteralSegment < Segment
-        def append_regexp(bld)
-          bld << "(#{Regexp.escape(@literal)})"
-        end
-
-        def initialize(literal)
-          @literal = literal
-        end
-
-        def append_to(bld, ts)
-          bld << @literal
-        end
-
-        def concat(codepoint)
-          @literal.concat(codepoint)
-        end
-
-        def nanoseconds
-          0
-        end
-      end
-
-      class ValueSegment < Segment
-        def initialize(padchar, width, default_width)
-          @use_total = false
-          @padchar = padchar
-          @width = width
-          @default_width = default_width
-          @format = create_format
-        end
-
-        def create_format
-          case @padchar
-          when nil
-            '%d'
-          when ' '
-            "%#{@width || @default_width}d"
-          else
-            "%#{@padchar}#{@width || @default_width}d"
-          end
-        end
-
-        def append_regexp(bld)
-          if @width.nil?
-            case @padchar
-            when nil
-              bld << (use_total? ? '([0-9]+)' : "([0-9]{1,#{@default_width}})")
-            when '0'
-              bld << (use_total? ? '([0-9]+)' : "([0-9]{1,#{@default_width}})")
-            else
-              bld << (use_total? ? '\s*([0-9]+)' : "([0-9\\s]{1,#{@default_width}})")
-            end
-          else
-            case @padchar
-            when nil
-              bld << "([0-9]{1,#{@width}})"
-            when '0'
-              bld << "([0-9]{#{@width}})"
-            else
-              bld << "([0-9\\s]{#{@width}})"
-            end
-          end
-        end
-
-        def nanoseconds(group)
-          group.to_i * multiplier
-        end
-
-        def multiplier
-          0
-        end
-
-        def set_use_total
-          @use_total = true
-        end
-
-        def use_total?
-          @use_total
-        end
-
-        def append_value(bld, n)
-          bld << sprintf(@format, n)
-        end
-      end
-
-      class DaySegment < ValueSegment
-        def initialize(padchar, width)
-          super(padchar, width, 1)
-        end
-
-        def multiplier
-          NSECS_PER_DAY
-        end
-
-        def append_to(bld, ts)
-          append_value(bld, ts.days)
-        end
-      end
-
-      class HourSegment < ValueSegment
-        def initialize(padchar, width)
-          super(padchar, width, 2)
-        end
-
-        def multiplier
-          NSECS_PER_HOUR
-        end
-
-        def append_to(bld, ts)
-          append_value(bld, use_total? ? ts.total_hours : ts.hours)
-        end
-      end
-
-      class MinuteSegment < ValueSegment
-        def initialize(padchar, width)
-          super(padchar, width, 2)
-        end
-
-        def multiplier
-          NSECS_PER_MIN
-        end
-
-        def append_to(bld, ts)
-          append_value(bld, use_total? ? ts.total_minutes : ts.minutes)
-        end
-      end
-
-      class SecondSegment < ValueSegment
-        def initialize(padchar, width)
-          super(padchar, width, 2)
-        end
-
-        def multiplier
-          NSECS_PER_SEC
-        end
-
-        def append_to(bld, ts)
-          append_value(bld, use_total? ? ts.total_seconds : ts.seconds)
-        end
-      end
-
-      # Class that assumes that leading zeroes are significant and that trailing zeroes are not and left justifies when formatting.
-      # Applicable after a decimal point, and hence to the %L and %N formats.
-      class FragmentSegment < ValueSegment
-        def nanoseconds(group)
-          # Using %L or %N to parse a string only makes sense when they are considered to be fractions. Using them
-          # as a total quantity would introduce ambiguities.
-          raise ArgumentError, _('Format specifiers %L and %N denotes fractions and must be used together with a specifier of higher magnitude') if use_total?
-          n = group.to_i
-          p = 9 - group.length
-          p <= 0 ? n : n * 10 ** p
-        end
-
-        def create_format
-          if @padchar.nil?
-            '%d'
-          else
-            "%-#{@width || @default_width}d"
-          end
-        end
-
-        def append_value(bld, n)
-          # Strip trailing zeroes when default format is used
-          n = n.to_s.sub(/\A([0-9]+?)0*\z/, '\1').to_i unless use_total? || @padchar == '0'
-          super(bld, n)
-        end
-      end
-
-      class MilliSecondSegment < FragmentSegment
-        def initialize(padchar, width)
-          super(padchar, width, 3)
-        end
-
-        def multiplier
-          NSECS_PER_MSEC
-        end
-
-        def append_to(bld, ts)
-          append_value(bld, use_total? ? ts.total_milliseconds : ts.milliseconds)
-        end
-      end
-
-      class NanoSecondSegment < FragmentSegment
-        def initialize(padchar, width)
-          super(padchar, width, 9)
-        end
-
-        def multiplier
-          width = @width || @default_width
-          if width < 9
-            10 ** (9 - width)
-          else
-            1
-          end
-        end
-
-        def append_to(bld, ts)
-          ns = ts.total_nanoseconds
-          width = @width || @default_width
-          if width < 9
-            # Truncate digits to the right, i.e. let %6N reflect microseconds
-            ns /= 10 ** (9 - width)
-            ns %= 10 ** width unless use_total?
-          else
-            ns %= NSECS_PER_SEC unless use_total?
-          end
-          append_value(bld, ns)
-        end
-      end
-
-      def initialize(format, segments)
-        @format = format.freeze
-        @segments = segments.freeze
-      end
-
-      def format(timespan)
-        bld = timespan.negative? ? '-' : ''
-        @segments.each { |segment| segment.append_to(bld, timespan) }
-        bld
-      end
-
-      def parse(timespan)
-        md = regexp.match(timespan)
-        raise ArgumentError, _("Unable to parse '%{timespan}' using format '%{format}'") % { timespan: timespan, format: @format } if md.nil?
-        nanoseconds = 0
-        md.captures.each_with_index do |group, index|
-          segment = @segments[index]
-          next if segment.is_a?(LiteralSegment)
-          group.lstrip!
-          raise ArgumentError, _("Unable to parse '%{timespan}' using format '%{format}'") % { timespan: timespan, format: @format } unless group =~ /\A[0-9]+\z/
-          nanoseconds += segment.nanoseconds(group)
-        end
-        Timespan.new(timespan.start_with?('-') ? -nanoseconds : nanoseconds)
-      end
-
-      def to_s
-        @format
-      end
-
-      private
-
-      def regexp
-        @regexp ||= build_regexp
-      end
-
-      def build_regexp
-        bld = '\A-?'
-        @segments.each { |segment| segment.append_regexp(bld) }
-        bld << '\z'
-        Regexp.new(bld)
-      end
-    end
-
-    # Parses a string into a Timestamp::Format instance
-    class FormatParser
-      def self.singleton
-        @singleton
-      end
-
-      def initialize
-        @formats = Hash.new { |hash, str| hash[str] = internal_parse(str) }
-      end
-
-      def parse_format(format)
-        @formats[format]
-      end
-
-      private
-
-      NSEC_MAX = 0
-      MSEC_MAX = 1
-      SEC_MAX = 2
-      MIN_MAX = 3
-      HOUR_MAX = 4
-      DAY_MAX = 5
-
-      SEGMENT_CLASS_BY_ORDINAL = [
-        Format::NanoSecondSegment, Format::MilliSecondSegment, Format::SecondSegment, Format::MinuteSegment, Format::HourSegment, Format::DaySegment
-      ]
-
-      def bad_format_specifier(format, start, position)
-        _("Bad format specifier '%{expression}' in '%{format}', at position %{position}") % { expression: format[start,position-start], format: format, position: position }
-      end
-
-      def append_literal(bld, codepoint)
-        if bld.empty? || !bld.last.is_a?(Format::LiteralSegment)
-          bld << Format::LiteralSegment.new(''.concat(codepoint))
-        else
-          bld.last.concat(codepoint)
-        end
-      end
-
-      # States used by the #internal_parser function
-      STATE_LITERAL = 0 # expects literal or '%'
-      STATE_PAD  = 1 # expects pad, width, or format character
-      STATE_WIDTH = 2 # expects width, or format character
-
-      def internal_parse(str)
-        bld = []
-        raise ArgumentError, _('Format must be a String') unless str.is_a?(String)
-        highest = -1
-        state = STATE_LITERAL
-        padchar = '0'
-        width = nil
-        position = -1
-        fstart = 0
-
-        str.codepoints do |codepoint|
-          position += 1
-          if state == STATE_LITERAL
-            if codepoint == 0x25 # '%'
-              state = STATE_PAD
-              fstart = position
-              padchar = '0'
-              width = nil
-            else
-              append_literal(bld, codepoint)
-            end
-            next
-          end
-
-          case codepoint
-          when 0x25 # '%'
-            append_literal(bld, codepoint)
-            state = STATE_LITERAL
-          when 0x2D # '-'
-            raise ArgumentError, bad_format_specifier(str, fstart, position) unless state == STATE_PAD
-            padchar = nil
-            state = STATE_WIDTH
-          when 0x5F # '_'
-            raise ArgumentError, bad_format_specifier(str, fstart, position) unless state == STATE_PAD
-            padchar = ' '
-            state = STATE_WIDTH
-          when 0x44 # 'D'
-            highest = DAY_MAX
-            bld << Format::DaySegment.new(padchar, width)
-            state = STATE_LITERAL
-          when 0x48 # 'H'
-            highest = HOUR_MAX unless highest > HOUR_MAX
-            bld << Format::HourSegment.new(padchar, width)
-            state = STATE_LITERAL
-          when 0x4D # 'M'
-            highest = MIN_MAX unless highest > MIN_MAX
-            bld << Format::MinuteSegment.new(padchar, width)
-            state = STATE_LITERAL
-          when 0x53 # 'S'
-            highest = SEC_MAX unless highest > SEC_MAX
-            bld << Format::SecondSegment.new(padchar, width)
-            state = STATE_LITERAL
-          when 0x4C # 'L'
-            highest = MSEC_MAX unless highest > MSEC_MAX
-            bld << Format::MilliSecondSegment.new(padchar, width)
-            state = STATE_LITERAL
-          when 0x4E # 'N'
-            highest = NSEC_MAX unless highest > NSEC_MAX
-            bld << Format::NanoSecondSegment.new(padchar, width)
-            state = STATE_LITERAL
-          else # only digits allowed at this point
-            raise ArgumentError, bad_format_specifier(str, fstart, position) unless codepoint >= 0x30 && codepoint <= 0x39
-            if state == STATE_PAD && codepoint == 0x30
-              padchar = '0'
-            else
-              n = codepoint - 0x30
-              if width.nil?
-                width = n
-              else
-                width = width * 10 + n
-              end
-            end
-            state = STATE_WIDTH
-          end
-        end
-
-        raise ArgumentError, bad_format_specifier(str, fstart, position)  unless state == STATE_LITERAL
-        unless highest == -1
-          hc = SEGMENT_CLASS_BY_ORDINAL[highest]
-          bld.find { |s| s.instance_of?(hc) }.set_use_total
-        end
-        Format.new(str, bld)
-      end
-
-      @singleton = FormatParser.new
-    end
-
-    class Format
-      DEFAULTS = ['%D-%H:%M:%S.%-N', '%H:%M:%S.%-N', '%M:%S.%-N', '%S.%-N', '%D-%H:%M:%S', '%H:%M:%S', '%D-%H:%M', '%S'].map { |str| FormatParser.singleton.parse_format(str) }
-    end
-  end
-end
-end