tjson 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 622fe5145c38438258607d59d9358ebe7cfe2d13
-  data.tar.gz: 7a534141296250d532964fbd7a1ccb3e67da126b
+  metadata.gz: a874be0629fb8b05f091435d8589d5d789a44865
+  data.tar.gz: 55d8f97a15fbcab3fd4022a8639d0d386e59e511
 SHA512:
-  metadata.gz: 2f2ceb6fe96feea0f77e25ca5318c42aa2e744365aad316942e43904a842f3ca3938ae7fc16979cf2e03e973dfe752739ba83042f36e3eaeb1033da23712574e
-  data.tar.gz: f273f7abd7c79b80b819af9433e47589bb9e773062dae6132aa81138f1024a9cc4cbcd67f4a5b39de6258ab341798e84d63658a00a1465ca6a9df5750747b0d4
+  metadata.gz: e3146a94f973371a2d2091449282393eabffeed605279bd2c8876c27d6a4a430d4a986ffb1f417cf10ccdc9b5431916dccd5ad18a04bc232d1e38bff19132388
+  data.tar.gz: c7b0f974840341d988c36d0ddc0160f57850951ecc1d0055643968e90c360c9d2aeb675cd9373d0f88d3b2c2b44fc5ff4104a3ea85cb38221d37b68a07752740

data/.rubocop.yml

@@ -21,6 +21,9 @@ Metrics/AbcSize:
 Metrics/CyclomaticComplexity:
   Enabled: false
 
+Metrics/PerceivedComplexity:
+  Enabled: false
+
 Metrics/ClassLength:
   Max: 100
 

data/CHANGES.md

@@ -1,3 +1,7 @@
+## 0.2.0 (2016-11-06)
+
+* Complete rewrite to support new postfix syntax
+
 ## 0.1.0 (2016-10-28)
 
 * Initial release

data/Gemfile

@@ -4,6 +4,10 @@ source "https://rubygems.org"
 
 gemspec
 
+group :development do
+  gem "guard-rspec"
+end
+
 group :development, :test do
   gem "rake"
   gem "toml-rb"

data/Guardfile

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+# More info at https://github.com/guard/guard#readme
+
+guard :rspec, cmd: "GUARD_RSPEC=1 bundle exec rspec --no-profile" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper)  { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+end

data/README.md

@@ -36,18 +36,18 @@ Or install it yourself as:
 To parse a TJSON document, use the `TJSON.parse` method:
 
 ```ruby
->> TJSON.parse('{"s:foo":"s:bar"}')
+>> TJSON.parse('{"foo:s":"bar"}')
 => {"foo"=>"bar"}
 ```
 
 The following describes how TJSON types map onto Ruby types during parsing:
 
- * **UTF-8 Strings**: parsed as Ruby `String` with `Encoding::UTF_8`
+ * **Unicode Strings**: parsed as Ruby `String` with `Encoding::UTF_8`
  * **Binary Data**: parsed as Ruby `String` with `Encoding::ASCII_8BIT` (a.k.a. `Encoding::BINARY`)
  * **Integers**: parsed as Ruby `Integer` (Fixnum or Bignum)
  * **Floats** (i.e. JSON number literals): parsed as Ruby `Float`
  * **Timestamps**: parsed as Ruby `Time`
- * **Arrays**: parsed as `TJSON::Array` (a subclass of `::Array`)
+ * **Arrays**: parsed as Ruby `Array`
  * **Objects**: parsed as `TJSON::Object` (a subclass of `::Hash`)
 
 ### Generating
@@ -55,27 +55,8 @@ The following describes how TJSON types map onto Ruby types during parsing:
 To generate TJSON from Ruby objects, use the `TJSON.generate` method:
 
 ```ruby
->> puts TJSON.generate({"foo" => "bar" })
-{"s:foo":"s:bar"}
-```
-
-The `TJSON.generate` method will call `#to_tjson` on any objects which are not
-one of Ruby's core types. You can implement this method on classes you wish to
-serialize as TJSON, although it MUST output tagged strings for encoding TJSON
-types such as UTF-8 strings or binary data.
-
-### TJSON::Binary
-
-The `TJSON::Binary` module contains a set of helper methods for serializing
-binary data in various different encodings:
-
-```ruby
->> TJSON::Binary.base16("Hello, world!")
-=> "b16:48656c6c6f2c20776f726c6421"
->> TJSON::Binary.base32("Hello, world!")
-=> "b32:jbswy3dpfqqho33snrscc"
->> TJSON::Binary.base64("Hello, world!")
-=> "b64:SGVsbG8sIHdvcmxkIQ"
+>> puts TJSON.generate({"foo" => "bar"})
+{"foo:s:"bar"}
 ```
 
 ## Contributing

data/lib/tjson.rb

@@ -7,11 +7,8 @@ require "time"
 require "base32"
 require "base64"
 
-require "tjson/array"
-require "tjson/binary"
-require "tjson/generator"
+require "tjson/datatype"
 require "tjson/object"
-require "tjson/parser"
 
 # Tagged JSON with Rich Types
 module TJSON
@@ -24,6 +21,9 @@ module TJSON
   # Failure to parse TJSON document
   ParseError = Class.new(Error)
 
+  # Invalid types
+  TypeError = Class.new(ParseError)
+
   # Duplicate object name
   DuplicateNameError = Class.new(ParseError)
 
@@ -43,18 +43,20 @@ module TJSON
     end
 
     begin
-      ::JSON.parse(
+      object = ::JSON.parse(
         utf8_string,
         max_nesting:      MAX_NESTING,
         allow_nan:        false,
         symbolize_names:  false,
         create_additions: false,
-        object_class:     TJSON::Object,
-        array_class:      TJSON::Array
+        object_class:     TJSON::Object
       )
     rescue ::JSON::ParserError => ex
       raise TJSON::ParseError, ex.message, ex.backtrace
     end
+
+    raise TJSON::TypeError, "invalid toplevel type: #{object.class}" unless object.is_a?(TJSON::Object)
+    object
   end
 
   # Generate TJSON from a Ruby Hash or Array
@@ -62,7 +64,7 @@ module TJSON
   # @param obj [Array, Hash] Ruby Hash or Array to serialize as TJSON
   # @return [String] serialized TJSON
   def self.generate(obj)
-    raise TypeError, "expected Hash or Array, got #{obj.class}" unless obj.is_a?(Hash) || obj.is_a?(Array)
-    JSON.generate(TJSON::Generator.generate(obj))
+    raise TypeError, "toplevel type must be a Hash" unless obj.is_a?(Hash)
+    JSON.generate(TJSON::DataType.generate(obj))
   end
 end

data/lib/tjson/datatype.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module TJSON
+  # Hierarchy of TJSON types
+  class DataType
+    # Find a type by its tag
+    def self.[](tag)
+      TAGS[tag] || raise(TJSON::TypeError, "unknown tag: #{tag.inspect}")
+    end
+
+    def self.parse(tag)
+      raise TJSON::TypeError, "expected String, got #{tag.class}" unless tag.is_a?(::String)
+
+      if tag == "O"
+        # Object
+        TJSON::DataType[tag]
+      elsif (result = tag.match(/\A(?<type>[A-Z][a-z0-9]*)\<(?<inner>.*)\>\z/))
+        # Non-scalar
+        inner = parse(result[:inner]) unless result[:inner].empty?
+        TJSON::DataType[result[:type]].new(inner).freeze
+      elsif tag =~ /\A[a-z][a-z0-9]*\z/
+        # Scalar
+        TJSON::DataType[tag]
+      else
+        raise TJSON::ParseError, "couldn't parse tag: #{tag.inspect}" unless result
+      end
+    end
+
+    def self.identify_type(obj)
+      case obj
+      when Hash               then self["O"]
+      when ::Array            then TJSON::DataType::Array.identify_type(obj)
+      when ::String, Symbol   then obj.encoding == Encoding::BINARY ? self["b"] : self["s"]
+      when ::Integer          then self["i"]
+      when ::Float            then self["f"]
+      when ::Time, ::DateTime then self["t"]
+      else raise TypeError, "don't know how to serialize #{obj.class} as TJSON"
+      end
+    end
+
+    def self.generate(obj)
+      identify_type(obj).generate(obj)
+    end
+
+    # Scalar types
+    class Scalar < TJSON::DataType
+      def scalar?
+        true
+      end
+
+      def inspect
+        "#<#{self.class}>"
+      end
+    end
+
+    # Non-scalar types
+    class NonScalar < TJSON::DataType
+      attr_reader :inner_type
+
+      def initialize(inner_type)
+        @inner_type = inner_type
+      end
+
+      def inspect
+        "#<#{self.class}<#{@inner_type.inspect}>>"
+      end
+
+      def scalar?
+        false
+      end
+
+      def ==(other)
+        self.class == other.class && inner_type == other.inner_type
+      end
+    end
+
+    # Numbers
+    class Number < Scalar; end
+  end
+end
+
+require "tjson/datatype/array"
+require "tjson/datatype/binary"
+require "tjson/datatype/float"
+require "tjson/datatype/integer"
+require "tjson/datatype/string"
+require "tjson/datatype/timestamp"
+require "tjson/datatype/object"
+
+# TJSON does not presently support user-extensible types
+TJSON::DataType::TAGS = {
+  # Object (non-scalar with self-describing types)
+  "O" => TJSON::DataType::Object.new(nil).freeze,
+
+  # Non-scalars
+  "A" => TJSON::DataType::Array,
+
+  # Scalars
+  "b"   => TJSON::DataType::Binary64.new.freeze,
+  "b16" => TJSON::DataType::Binary16.new.freeze,
+  "b32" => TJSON::DataType::Binary32.new.freeze,
+  "b64" => TJSON::DataType::Binary64.new.freeze,
+  "f"   => TJSON::DataType::Float.new.freeze,
+  "i"   => TJSON::DataType::SignedInt.new.freeze,
+  "s"   => TJSON::DataType::String.new.freeze,
+  "t"   => TJSON::DataType::Timestamp.new.freeze,
+  "u"   => TJSON::DataType::UnsignedInt.new.freeze
+}.freeze

data/lib/tjson/datatype/array.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module TJSON
+  class DataType
+    # TJSON arrays
+    class Array < NonScalar
+      # Determine the type of a Ruby array (for serialization)
+      def self.identify_type(array)
+        inner_type = nil
+
+        array.each do |elem|
+          t = TJSON::DataType.identify_type(elem)
+          inner_type ||= t
+          raise TJSON::TypeError, "array contains heterogenous types: #{array.inspect}" unless inner_type == t
+        end
+
+        new(inner_type)
+      end
+
+      def tag
+        "A<#{@inner_type.tag}>"
+      end
+
+      def convert(array)
+        raise TJSON::TypeError, "expected Array, got #{array.class}" unless array.is_a?(::Array)
+
+        return array.map! { |o| @inner_type.convert(o) } if @inner_type
+        return array if array.empty?
+        raise TJSON::ParseError, "no inner type specified for non-empty array: #{array.inspect}"
+      end
+
+      def generate(array)
+        array.map { |o| TJSON::DataType.generate(o) }
+      end
+    end
+  end
+end

data/lib/tjson/datatype/binary.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module TJSON
+  class DataType
+    # Binary Data
+    class Binary < Scalar; end
+
+    # Base16-serialized binary data
+    class Binary16 < Binary
+      def tag
+        "b16"
+      end
+
+      def convert(str)
+        raise TJSON::TypeError, "expected String, got #{str.class}: #{str.inspect}" unless str.is_a?(::String)
+        raise TJSON::ParseError, "base16 must be lower case: #{str.inspect}" if str =~ /[A-F]/
+        raise TJSON::ParseError, "invalid base16: #{str.inspect}" unless str =~ /\A[a-f0-9]*\z/
+
+        [str].pack("H*")
+      end
+
+      def generate(binary)
+        binary.unpack("H*").first
+      end
+    end
+
+    # Base32-serialized binary data
+    class Binary32 < Binary
+      def tag
+        "b32"
+      end
+
+      def convert(str)
+        raise TJSON::TypeError, "expected String, got #{str.class}: #{str.inspect}" unless str.is_a?(::String)
+        raise TJSON::ParseError, "base32 must be lower case: #{str.inspect}" if str =~ /[A-Z]/
+        raise TJSON::ParseError, "padding disallowed: #{str.inspect}" if str.include?("=")
+        raise TJSON::ParseError, "invalid base32: #{str.inspect}" unless str =~ /\A[a-z2-7]*\z/
+
+        ::Base32.decode(str.upcase).force_encoding(Encoding::BINARY)
+      end
+
+      def generate(binary)
+        Base32.encode(binary).downcase.delete("=")
+      end
+    end
+
+    # Base64-serialized binary data
+    class Binary64 < Binary
+      def tag
+        "b64"
+      end
+
+      def convert(str)
+        raise TJSON::TypeError, "expected String, got #{str.class}: #{str.inspect}" unless str.is_a?(::String)
+        raise TJSON::ParseError, "base64url only: #{str.inspect}" if str =~ %r{\+|\/}
+        raise TJSON::ParseError, "padding disallowed: #{str.inspect}" if str.include?("=")
+        raise TJSON::ParseError, "invalid base64url: #{str.inspect}" unless str =~ /\A[A-Za-z0-9\-_]*\z/
+
+        # Add padding, as older Rubies (< 2.3) require it
+        str = str.ljust((str.length + 3) & ~3, "=") if (str.length % 4).nonzero?
+
+        ::Base64.urlsafe_decode64(str)
+      end
+
+      def generate(binary)
+        Base64.urlsafe_encode64(binary).delete("=")
+      end
+    end
+  end
+end

data/lib/tjson/datatype/float.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module TJSON
+  class DataType
+    # Floating point type
+    class Float < Number
+      def tag
+        "f"
+      end
+
+      def convert(float)
+        raise TJSON::TypeError, "expected Float, got #{float.class}" unless float.is_a?(::Numeric)
+        float.to_f
+      end
+
+      def generate(float)
+        float.to_f
+      end
+    end
+  end
+end

data/lib/tjson/datatype/integer.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module TJSON
+  class DataType
+    # Base class of integer types
+    class Integer < Scalar
+      def generate(int)
+        # Integers are serialized as strings to sidestep the limits of some JSON parsers
+        int.to_s
+      end
+    end
+
+    # Signed 64-bit integer
+    class SignedInt < Integer
+      def tag
+        "i"
+      end
+
+      def convert(str)
+        raise TJSON::TypeError, "expected String, got #{str.class}: #{str.inspect}" unless str.is_a?(::String)
+        raise TJSON::ParseError, "invalid integer: #{str.inspect}" unless str =~ /\A\-?(0|[1-9][0-9]*)\z/
+
+        result = Integer(str, 10)
+        raise TJSON::ParseError, "oversized integer: #{result}"  if result > 9_223_372_036_854_775_807
+        raise TJSON::ParseError, "undersized integer: #{result}" if result < -9_223_372_036_854_775_808
+
+        result
+      end
+    end
+
+    # Unsigned 64-bit integer
+    class UnsignedInt < Integer
+      def tag
+        "u"
+      end
+
+      def convert(str)
+        raise TJSON::TypeError, "expected String, got #{str.class}: #{str.inspect}" unless str.is_a?(::String)
+        raise TJSON::ParseError, "invalid integer: #{str.inspect}" unless str =~ /\A(0|[1-9][0-9]*)\z/
+
+        result = Integer(str, 10)
+        raise TJSON::ParseError, "oversized integer: #{result}" if result > 18_446_744_073_709_551_615
+
+        result
+      end
+    end
+  end
+end

data/lib/tjson/datatype/object.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module TJSON
+  class DataType
+    # TJSON objects
+    class Object < NonScalar
+      def tag
+        "O"
+      end
+
+      def convert(obj)
+        raise TJSON::TypeError, "expected TJSON::Object, got #{obj.class}" unless obj.is_a?(TJSON::Object)
+
+        # Objects handle their own member conversions
+        obj
+      end
+
+      def generate(obj)
+        members = obj.map do |k, v|
+          raise TypeError, "expected String for key, got #{k.class}" unless k.is_a?(::String)
+          type = TJSON::DataType.identify_type(v)
+          ["#{k}:#{type.tag}", TJSON::DataType.generate(v)]
+        end
+
+        Hash[members]
+      end
+
+      def inspect
+        "#<#{self.class}>"
+      end
+    end
+  end
+end

data/lib/tjson/datatype/string.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module TJSON
+  class DataType
+    # Unicode String type
+    class String < Scalar
+      def tag
+        "s"
+      end
+
+      def convert(str)
+        raise TJSON::TypeError, "expected String, got #{str.class}: #{str.inspect}" unless str.is_a?(::String)
+        raise TJSON::EncodingError, "expected UTF-8, got #{str.encoding.inspect}" unless str.encoding == Encoding::UTF_8
+        str
+      end
+
+      def generate(obj)
+        obj.to_s
+      end
+    end
+  end
+end

data/lib/tjson/datatype/timestamp.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module TJSON
+  class DataType
+    # RFC3339 timestamp (Z-normalized)
+    class Timestamp < Scalar
+      def tag
+        "t"
+      end
+
+      def convert(str)
+        raise TJSON::TypeError, "expected String, got #{str.class}: #{str.inspect}" unless str.is_a?(::String)
+        raise TJSON::ParseError, "invalid timestamp: #{str.inspect}" unless str =~ /\A\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z\z/
+
+        ::Time.iso8601(str)
+      end
+
+      def generate(timestamp)
+        timestamp.to_time.utc.iso8601
+      end
+    end
+  end
+end

data/lib/tjson/object.rb

@@ -3,16 +3,15 @@
 module TJSON
   # TJSON object type (i.e. hash/dict-alike)
   class Object < ::Hash
-    def []=(name, value)
-      unless name.start_with?("s:", "b16:", "b64:")
-        raise TJSON::ParseError, "invalid tag on object name: #{name[/\A(.*?):/, 1]}" if name.include?(":")
-        raise TJSON::ParseError, "no tag found on object name: #{name.inspect}"
-      end
+    def []=(tagged_name, value)
+      # NOTE: this regex is sloppy. The real parsing is performed in TJSON::DataType#parse
+      result = tagged_name.match(/\A(?<name>.*):(?<tag>[A-Za-z0-9\<]+[\>]*)\z/)
 
-      name = TJSON::Parser.value(name)
-      raise TJSON::DuplicateNameError, "duplicate member name: #{name.inspect}" if key?(name)
+      raise ParseError, "invalid tag: #{tagged_name.inspect}" unless result
+      raise DuplicateNameError, "duplicate member name: #{result[:name].inspect}" if key?(result[:name])
 
-      super(name, TJSON::Parser.value(value))
+      type = TJSON::DataType.parse(result[:tag])
+      super(result[:name], type.convert(value))
     end
   end
 end

data/lib/tjson/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TJSON
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tjson
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Tony Arcieri
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-10-28 00:00:00.000000000 Z
+date: 2016-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base32
@@ -52,15 +52,20 @@ files:
 - ".travis.yml"
 - CHANGES.md
 - Gemfile
+- Guardfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/tjson.rb
-- lib/tjson/array.rb
-- lib/tjson/binary.rb
-- lib/tjson/generator.rb
+- lib/tjson/datatype.rb
+- lib/tjson/datatype/array.rb
+- lib/tjson/datatype/binary.rb
+- lib/tjson/datatype/float.rb
+- lib/tjson/datatype/integer.rb
+- lib/tjson/datatype/object.rb
+- lib/tjson/datatype/string.rb
+- lib/tjson/datatype/timestamp.rb
 - lib/tjson/object.rb
-- lib/tjson/parser.rb
 - lib/tjson/version.rb
 - tjson.gemspec
 homepage: https://github.com/tjson/tjson-ruby

data/lib/tjson/array.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module TJSON
-  # TJSON array type
-  class Array < ::Array
-    def <<(obj)
-      super(TJSON::Parser.value(obj))
-    end
-  end
-end

data/lib/tjson/binary.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module TJSON
-  # Binary serialization helpers
-  module Binary
-    module_function
-
-    def base16(string)
-      "b16:#{string.unpack('H*').first}"
-    end
-
-    def base32(string)
-      "b32:#{Base32.encode(string).downcase.delete('=')}"
-    end
-
-    def base64(string)
-      "b64:#{Base64.urlsafe_encode64(string).delete('=')}"
-    end
-  end
-end

data/lib/tjson/generator.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module TJSON
-  # Generates TJSON from Ruby objects
-  module Generator
-    module_function
-
-    def generate(obj)
-      case obj
-      when Hash           then generate_hash(obj)
-      when ::Array        then generate_array(obj)
-      when String, Symbol then generate_string(obj.to_s)
-      when Integer        then generate_integer(obj)
-      when Float          then obj
-      when Time, DateTime then generate_timestamp(obj.to_time)
-      else                     obj.to_tjson
-      end
-    end
-
-    def generate_hash(hash)
-      members = hash.map do |k, v|
-        raise TypeError, "expected String for key, got #{k.class}" unless k.is_a?(String)
-        [generate(k), generate(v)]
-      end
-
-      Hash[members]
-    end
-
-    def generate_array(array)
-      array.map { |o| generate(o) }
-    end
-
-    def generate_string(string)
-      if string.encoding == Encoding::BINARY
-        TJSON::Binary.base64(string)
-      else
-        "s:#{string.encode(Encoding::UTF_8)}"
-      end
-    end
-
-    def generate_integer(int)
-      "i:#{int}"
-    end
-
-    def generate_timestamp(time)
-      "t:#{time.utc.iso8601}"
-    end
-  end
-end

data/lib/tjson/parser.rb

@@ -1,97 +0,0 @@
-# frozen_string_literal: true
-
-module TJSON
-  # Postprocessing for extracting TJSON tags from JSON
-  module Parser
-    module_function
-
-    TAG_DELIMITER  = ":"
-    MAX_TAG_LENGTH = 3 # Sans ':'
-
-    def value(obj)
-      case obj
-      when String then parse(obj)
-      when Integer then obj.to_f
-      when TJSON::Object, TJSON::Array, Float then obj
-      else raise TypeError, "invalid TJSON value: #{obj.inspect}"
-      end
-    end
-
-    def parse(str)
-      raise TypeError, "expected String, got #{str.class}" unless str.is_a?(::String)
-      raise TJSON::EncodingError, "expected UTF-8, got #{str.encoding.inspect}" unless str.encoding == Encoding::UTF_8
-
-      dpos = str.index(TAG_DELIMITER)
-
-      raise TJSON::ParseError, "invalid tag (missing ':' delimiter)" unless dpos
-      raise TJSON::ParseError, "overlength tag (maximum #{MAX_TAG_LENGTH})" if dpos > MAX_TAG_LENGTH
-
-      tag = str.slice!(0, dpos + 1)
-
-      case tag
-      when "s:" then str
-      when "i:" then parse_signed_int(str)
-      when "u:" then parse_unsigned_int(str)
-      when "t:" then parse_timestamp(str)
-      when "b16:" then parse_base16(str)
-      when "b32:" then parse_base32(str)
-      when "b64:" then parse_base64url(str)
-      else raise TJSON::ParseError, "invalid tag #{tag.inspect} on string #{str.inspect}"
-      end
-    end
-
-    def parse_base16(str)
-      raise TypeError, "expected String, got #{str.class}" unless str.is_a?(::String)
-      raise TJSON::ParseError, "base16 must be lower case: #{str.inspect}" if str =~ /[A-F]/
-      raise TJSON::ParseError, "invalid base16: #{str.inspect}" unless str =~ /\A[a-f0-9]*\z/
-
-      [str].pack("H*")
-    end
-
-    def parse_base32(str)
-      raise TypeError, "expected String, got #{str.class}" unless str.is_a?(::String)
-      raise TJSON::ParseError, "base32 must be lower case: #{str.inspect}" if str =~ /[A-F]/
-      raise TJSON::ParseError, "padding disallowed: #{str.inspect}" if str.include?("=")
-      raise TJSON::ParseError, "invalid base32: #{str.inspect}" unless str =~ /\A[a-z2-7]*\z/
-
-      Base32.decode(str.upcase).force_encoding(Encoding::BINARY)
-    end
-
-    def parse_base64url(str)
-      raise TypeError, "expected String, got #{str.class}" unless str.is_a?(::String)
-      raise TJSON::ParseError, "base64url only: #{str.inspect}" if str =~ %r{\+|\/}
-      raise TJSON::ParseError, "padding disallowed: #{str.inspect}" if str.include?("=")
-      raise TJSON::ParseError, "invalid base64url: #{str.inspect}" unless str =~ /\A[A-Za-z0-9\-_]*\z/
-
-      # Add padding, as older Rubies (< 2.3) require it
-      str = str.ljust((str.length + 3) & ~3, "=") if (str.length % 4).nonzero?
-
-      Base64.urlsafe_decode64(str)
-    end
-
-    def parse_signed_int(str)
-      raise TJSON::ParseError, "invalid integer: #{str.inspect}" unless str =~ /\A\-?(0|[1-9][0-9]*)\z/
-
-      result = Integer(str, 10)
-      raise TJSON::ParseError, "oversized integer: #{result}"  if result > 9_223_372_036_854_775_807
-      raise TJSON::ParseError, "undersized integer: #{result}" if result < -9_223_372_036_854_775_808
-
-      result
-    end
-
-    def parse_unsigned_int(str)
-      raise TJSON::ParseError, "invalid integer: #{str.inspect}" unless str =~ /\A(0|[1-9][0-9]*)\z/
-
-      result = Integer(str, 10)
-      raise TJSON::ParseError, "oversized integer: #{result}" if result > 18_446_744_073_709_551_615
-
-      result
-    end
-
-    def parse_timestamp(str)
-      raise TJSON::ParseError, "invalid timestamp: #{str.inspect}" unless str =~ /\A\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z\z/
-
-      Time.iso8601(str)
-    end
-  end
-end