puppet-retrospec 1.5.0 → 1.6.0

data/vendor/pup410/lib/puppet/pops/serialization/object.rb

@@ -0,0 +1,71 @@
+require_relative 'instance_reader'
+require_relative 'instance_writer'
+
+module Puppet::Pops
+module Serialization
+
+# Instance reader for objects that implement {Types::PuppetObject}
+# @api private
+class ObjectReader
+  include InstanceReader
+
+  def read(impl_class, value_count, deserializer)
+    type = impl_class._ptype
+    (names, types, required_count) = type.parameter_info(impl_class)
+    max = names.size
+    unless value_count >= required_count && value_count <= max
+      raise Serialization::SerializationError, "Feature count mismatch for #{impl_class.name}. Expected #{required_count} - #{max}, actual #{value_count}"
+    end
+    # Deserializer must know about this instance before we read its attributes
+    val = deserializer.remember(impl_class.allocate)
+    args = Array.new(value_count) { deserializer.read }
+    types.each_with_index do |ptype, index|
+      if index < args.size
+        arg = args[index]
+        Types::TypeAsserter.assert_instance_of(nil, ptype, arg) { "#{type.name}[#{names[index]}]" } unless arg == :default
+      else
+        attr = type[names[index]]
+        raise Serialization::SerializationError, "Missing default value for #{type.name}[#{names[index]}]" unless attr.value?
+        args << attr.value
+      end
+    end
+    val.send(:initialize, *args)
+    val
+  end
+
+  INSTANCE = ObjectReader.new
+end
+
+# Instance writer for objects that implement {Types::PuppetObject}
+# @api private
+class ObjectWriter
+  include InstanceWriter
+
+  def write(type, value, serializer)
+    impl_class = value.class
+    (names, types, required_count) = type.parameter_info(impl_class, true)
+    args = names.map { |name| value.send(name) }
+
+    # Pop optional arguments that are default
+    while args.size > required_count
+      break unless args.last == type[names[args.size-1]].value
+      args.pop
+    end
+
+    if type.name.start_with?('Pcore::') || serializer.type_by_reference?
+      serializer.push_written(value)
+      serializer.start_pcore_object(type.name, args.size)
+    else
+      serializer.start_object(args.size + 1)
+      serializer.write(type)
+      serializer.push_written(value)
+    end
+
+    args.each { |arg| serializer.write(arg) }
+  end
+
+  INSTANCE = ObjectWriter.new
+end
+end
+end
+

data/vendor/pup410/lib/puppet/pops/serialization/rgen.rb

@@ -0,0 +1,152 @@
+require_relative 'instance_reader'
+require_relative 'instance_writer'
+
+module Puppet::Pops
+module Serialization
+
+# @api private
+module RGen
+  class Base
+    def features(impl_class)
+      impl_class.ecore.eAllStructuralFeatures.reject {|feature| feature.derived }
+    end
+  end
+
+  # Instance reader for RGen::Ecore objects
+  # @api private
+  class RGenReader < Base
+    include InstanceReader
+
+    def read(impl_class, value_count, deserializer)
+      features = features(impl_class)
+      raise SerializationError, "Feature count mismatch for #{impl_class}" unless value_count == features.size
+      # Deserializer must know about this instance before we read its attributes
+      obj = deserializer.remember(impl_class.new)
+      features.each { |feature| obj.setGeneric(feature.name, deserializer.read) }
+      obj
+    end
+
+    INSTANCE = RGenReader.new
+  end
+
+  # Instance writer for RGen::Ecore objects
+  # @api private
+  class RGenWriter < Base
+    include InstanceWriter
+
+    def write(type, value, serializer)
+      impl_class = value.class
+      features = features(impl_class)
+      serializer.push_written(value)
+      serializer.start_pcore_object(type.name, features.size)
+      features.each { |feature| serializer.write(value.getGeneric(feature.name)) }
+    end
+
+    INSTANCE = RGenWriter.new
+  end
+
+  # A generator that produces a {Types::PTypeSetType} instance based on an ruby {Module}
+  # that represents an RGen::ECore::EPackage.
+  #
+  # The generator is not complete. In particular, it does not deal with:
+  # - references that extend beyond eCore and the given ePackage
+  # - sub packages
+  # - methods
+  # - annotations
+  #
+  class TypeGenerator
+
+    ECore = ::RGen::ECore
+
+    def generate_type_set(namespace, package, loader)
+      types = {}
+      package.constants.each do |c|
+        cls = package.const_get(c)
+        next unless cls.is_a?(Class) && cls.respond_to?(:ecore)
+        e_class = cls.ecore
+        types[e_class.name] = generate_type_hash(e_class)
+      end
+      type_set = Types::PTypeSetType.new(namespace, {
+        Pcore::KEY_PCORE_VERSION => Pcore::PCORE_VERSION,
+        Types::KEY_VERSION => '0.1.0',
+        Types::KEY_TYPES => types
+      }, Pcore::RUNTIME_NAME_AUTHORITY).resolve(Types::TypeParser.singleton, loader)
+
+      type_set.types.values.each do |type|
+        type.reader = RGenReader::INSTANCE
+        type.writer = RGenWriter::INSTANCE
+      end
+      type_set
+    end
+
+    def generate_type_hash(e_class)
+      attributes = {}
+      e_class.eStructuralFeatures.each do |feature|
+        attr = {}
+        attributes[feature.name] = attr
+        type = feature_type(feature)
+        value = feature.defaultValue
+        if value.nil?
+          if feature.lowerBound == 0
+            if feature.upperBound == -1 || feature.upperBound > 1
+              attr[Types::KEY_VALUE] = []
+            elsif !feature.derived
+              type = Types::POptionalType.new(type)
+              attr[Types::KEY_VALUE] = nil
+            end
+          end
+        else
+          value = value.to_s if value.is_a?(Symbol)
+          attr['value'] = value
+        end
+        attr[Types::KEY_TYPE] = type
+        if feature.derived
+          attr[Types::KEY_KIND] = Types::PObjectType::ATTRIBUTE_KIND_DERIVED
+        elsif feature.unsettable
+          attr[Types::KEY_KIND] = Types::PObjectType::ATTRIBUTE_KIND_CONSTANT
+        end
+      end
+      result = { Types::KEY_ATTRIBUTES => attributes }
+      supers = e_class.eSuperTypes
+      case supers.size
+      when 0
+      when 1
+        result['parent'] = Types::PTypeReferenceType.new(supers[0].name)
+      else
+        raise SerializationError, "Multiple inheritance is not supported. #{e_class.name} has #{supers.size} super types"
+      end
+      result
+    end
+
+    def feature_type(feature)
+      eType = feature.eType
+      type = case eType
+      when ECore::EInt, ECore::ELong
+        Types::PIntegerType::DEFAULT
+      when ECore::EFloat
+        Types::PFloatType::DEFAULT
+      when ECore::EEnum
+        Types::PEnumType.new(eType.eLiterals.map { |e| e.name })
+      when ECore::EBoolean
+        Types::PBooleanType::DEFAULT
+      when ECore::EString
+        Types::PStringType::DEFAULT
+      when ECore::EClass
+        Types::PTypeReferenceType.new(eType.name)
+      else
+        Types::PAnyType::DEFAULT
+      end
+
+      case feature.upperBound
+      when 1
+        type
+      when -1
+        Types::PArrayType.new(type, Types::PIntegerType.new(feature.lowerBound))
+      else
+        Types::PArrayType.new(type, Types::PIntegerType.new(feature.lowerBound, feature.upperBound))
+      end
+    end
+  end
+end
+end
+end

data/vendor/pup410/lib/puppet/pops/serialization/serializer.rb

@@ -0,0 +1,125 @@
+require_relative 'extension'
+
+module Puppet::Pops
+module Serialization
+  # The serializer is capable of writing, arrays, maps, and complex objects using an underlying protocol writer. It takes care of
+  # tabulating and disassembling complex objects.
+  # @api public
+  class Serializer
+    # Provides access to the writer.
+    # @api private
+    attr_reader :writer
+
+    # @param writer [AbstractWriter] the writer that is used for writing primitive values
+    # @param options [{String, Object}] serialization options
+    # @option options [Boolean] :type_by_reference `true` if Object types are serialized by name only.
+    # @api public
+    def initialize(writer, options = EMPTY_HASH)
+      @written = {}
+      @writer = writer
+      @options = options
+    end
+
+    # Tell the underlying writer to finish
+    # @api public
+    def finish
+      @writer.finish
+    end
+
+    # Write an object
+    # @param [Object] value the object to write
+    # @api public
+    def write(value)
+      case value
+      when Integer, Float, String, true, false, nil
+        @writer.write(value)
+      when :default
+        @writer.write(Extension::Default::INSTANCE)
+      else
+        index = @written[value.object_id]
+        if index.nil?
+          write_tabulated_first_time(value)
+        else
+          @writer.write(Extension::Tabulation.new(index))
+        end
+      end
+    end
+
+    # Write the start of an array.
+    # @param [Integer] size the size of the array
+    # @api private
+    def start_array(size)
+      @writer.write(Extension::ArrayStart.new(size))
+    end
+
+    # Write the start of a map (hash).
+    # @param [Integer] size the number of entries in the map
+    # @api private
+    def start_map(size)
+      @writer.write(Extension::MapStart.new(size))
+    end
+
+    # Write the start of a complex pcore object
+    # @param [String] type_ref the name of the type
+    # @param [Integer] attr_count the number of attributes in the object
+    # @api private
+    def start_pcore_object(type_ref, attr_count)
+      @writer.write(Extension::PcoreObjectStart.new(type_ref, attr_count))
+    end
+
+    # Write the start of a complex object
+    # @param [Integer] attr_count the number of attributes in the object
+    # @api private
+    def start_object(attr_count)
+      @writer.write(Extension::ObjectStart.new(attr_count))
+    end
+
+    def push_written(value)
+      @written[value.object_id] = @written.size
+    end
+
+    # Write the start of a sensitive object
+    # @api private
+    def start_sensitive
+      @writer.write(Extension::SensitiveStart::INSTANCE)
+    end
+
+    def type_by_reference?
+      @options[:type_by_reference] == true
+    end
+
+    # First time write of a tabulated object. This means that the object is written and then remembered. Subsequent writes
+    # of the same object will yield a write of a tabulation index instead.
+    # @param [Object] value the value to write
+    # @api private
+    def write_tabulated_first_time(value)
+      case value
+      when Symbol, Regexp, SemanticPuppet::Version, SemanticPuppet::VersionRange, Time::Timestamp, Time::Timespan, Types::PBinaryType::Binary
+        push_written(value)
+        @writer.write(value)
+      when Array
+        push_written(value)
+        start_array(value.size)
+        value.each { |elem| write(elem) }
+      when Hash
+        push_written(value)
+        start_map(value.size)
+        value.each_pair { |key, val| write(key); write(val) }
+      when Types::PSensitiveType::Sensitive
+        start_sensitive
+        write(value.unwrap)
+      when Types::PTypeReferenceType
+        push_written(value)
+        @writer.write(value)
+      when Types::PuppetObject
+        value._ptype.write(value, self)
+      else
+        impl_class = value.class
+        type = Loaders.implementation_registry.type_for_module(impl_class)
+        raise SerializationError, "No Puppet Type found for #{impl_class.name}" unless type.is_a?(Types::PObjectType)
+        type.write(value, self)
+      end
+    end
+  end
+end
+end

data/vendor/pup410/lib/puppet/pops/serialization/time_factory.rb

@@ -0,0 +1,67 @@
+module Puppet::Pops
+module Serialization
+  # Implements all the constructors found in the Time class and ensures that
+  # the created Time object can be serialized and deserialized using its
+  # seconds and nanoseconds without loss of precision.
+  #
+  # @deprecated No longer in use. Functionality replaced by Timestamp
+  # @api private
+  class TimeFactory
+
+    NANO_DENOMINATOR = 10**9
+
+    def self.at(*args)
+      sec_nsec_safe(Time.at(*args))
+    end
+
+    def self.gm(*args)
+      sec_nsec_safe(Time.gm(*args))
+    end
+
+    def self.local(*args)
+      sec_nsec_safe(Time.local(*args))
+    end
+
+    def self.mktime(*args)
+      sec_nsec_safe(Time.mktime(*args))
+    end
+
+    def self.new(*args)
+      sec_nsec_safe(Time.new(*args))
+    end
+
+    def self.now
+      sec_nsec_safe(Time.now)
+    end
+
+    def self.utc(*args)
+      sec_nsec_safe(Time.utc(*args))
+    end
+
+    # Creates a Time object from a Rational defined as:
+    #
+    # (_sec_ * #NANO_DENOMINATOR + _nsec_) / #NANO_DENOMINATOR
+    #
+    # This ensures that a Time object can be reliably serialized and using its
+    # its #tv_sec and #tv_nsec values and then recreated again (using this method)
+    # without loss of precision.
+    #
+    # @param sec [Integer] seconds since Epoch
+    # @param nsec [Integer] nano seconds
+    # @return [Time] the created object
+    #
+    def self.from_sec_nsec(sec, nsec)
+      Time.at(Rational(sec * NANO_DENOMINATOR + nsec, NANO_DENOMINATOR))
+    end
+
+    # Returns a new Time object that is adjusted to ensure that precision is not
+    # lost when it is serialized and deserialized using its seconds and nanoseconds
+    # @param t [Time] the object to adjust
+    # @return [Time] the adjusted object
+    #
+    def self.sec_nsec_safe(t)
+      from_sec_nsec(t.tv_sec, t.tv_nsec)
+    end
+  end
+end
+end

data/vendor/pup410/lib/puppet/pops/time/timespan.rb

@@ -0,0 +1,718 @@
+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 #{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, "#{a_an_uc(o)} cannot be added to a Timespan" 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, "#{a_an_uc(o)} cannot be subtracted from a Timespan"
+      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 #{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 #{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 #{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}'" 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}'" 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 '#{format[start,position-start]}' in '#{format}', at 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