xnlogic-transit-ruby 0.8.572-java

data/lib/transit/reader.rb

@@ -0,0 +1,65 @@
+# Copyright 2014 Cognitect. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS-IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Transit
+  # Transit::Reader converts incoming transit data into appropriate
+  # values/objects in Ruby.
+  # @see https://github.com/cognitect/transit-format
+  class Reader
+    extend Forwardable
+
+    # @!method read
+    #   Reads transit values from an IO (file, stream, etc), and
+    #   converts each one to the appropriate Ruby object.
+    #
+    #   With a block, yields each object to the block as it is processed.
+    #
+    #   Without a block, returns a single object.
+    #
+    #   @example
+    #     reader = Transit::Reader.new(:json, io)
+    #     reader.read {|obj| do_something_with(obj)}
+    #
+    #     reader = Transit::Reader.new(:json, io)
+    #     obj = reader.read
+    def_delegators :@reader, :read
+
+    # @param [Symbol] format required any of :msgpack, :json, :json_verbose
+    # @param [IO]     io required
+    # @param [Hash]   opts optional
+    # Creates a new Reader configured to read from <tt>io</tt>,
+    # expecting <tt>format</tt> (<tt>:json</tt>, <tt>:msgpack</tt>).
+    #
+    # Use opts to register custom read handlers, associating each one
+    # with its tag.
+    #
+    # @example
+    #
+    #   json_reader                 = Transit::Reader.new(:json, io)
+    #   # ^^ reads both :json and :json_verbose formats ^^
+    #   msgpack_writer              = Transit::Reader.new(:msgpack, io)
+    #   writer_with_custom_handlers = Transit::Reader.new(:json, io,
+    #     :handlers => {"point" => PointReadHandler})
+    #
+    # @see Transit::ReadHandlers
+    def initialize(format, io, opts={})
+      @reader = case format
+                when :json, :json_verbose
+                  Unmarshaler::Json.new(io, opts)
+                else
+                  Unmarshaler::MessagePack.new(io, opts)
+                end
+    end
+  end
+end

data/lib/transit/rolling_cache.rb

@@ -0,0 +1,70 @@
+# Copyright 2014 Cognitect. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS-IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Transit
+  # @api private
+  class RollingCache
+    extend Forwardable
+
+    def_delegators "@key_to_value", :has_key?, :size
+
+    FIRST_ORD = 48
+    LAST_ORD  = 91
+    CACHE_CODE_DIGITS = 44;
+    CACHE_SIZE = CACHE_CODE_DIGITS * CACHE_CODE_DIGITS;
+    MIN_SIZE_CACHEABLE = 4
+
+    def initialize
+      clear
+    end
+
+    def read(key)
+      @key_to_value[key]
+    end
+
+    def write(val)
+      @value_to_key[val] || begin
+                              clear if @key_to_value.size >= CACHE_SIZE
+                              key = next_key(@key_to_value.size)
+                              @value_to_key[val] = key
+                              @key_to_value[key] = val
+                            end
+    end
+
+    def cache_key?(str, _=false)
+      str[0] == SUB && str != MAP_AS_ARRAY
+    end
+
+    def cacheable?(str, as_map_key=false)
+      str.size >= MIN_SIZE_CACHEABLE && (as_map_key || str.start_with?("~#","~$","~:"))
+    end
+
+    private
+
+    def clear
+      @key_to_value = {}
+      @value_to_key = {}
+    end
+
+    def next_key(i)
+      hi = i / CACHE_CODE_DIGITS;
+      lo = i % CACHE_CODE_DIGITS;
+      if hi == 0
+        "^#{(lo+FIRST_ORD).chr}"
+      else
+        "^#{(hi+FIRST_ORD).chr}#{(lo+FIRST_ORD).chr}"
+      end
+    end
+  end
+end

data/lib/transit/transit_types.rb

@@ -0,0 +1,258 @@
+# Copyright 2014 Cognitect. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS-IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Transit
+  class Wrapper
+    extend Forwardable
+
+    def_delegators :@value, :hash, :to_sym, :to_s
+
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && @value == other.value
+    end
+    alias eql? ==
+
+    def inspect
+      "<#{self.class} \"#{to_s}\">"
+    end
+  end
+
+  # Represents a transit symbol extension type.
+  # @see https://github.com/cognitect/transit-format
+  class Symbol < Wrapper
+    def initialize(sym)
+      super sym.to_sym
+    end
+
+    def namespace
+      @namespace ||= parsed[-2]
+    end
+
+    def name
+      @name ||= parsed[-1] || "/"
+    end
+
+    private
+
+    def parsed
+      @parsed ||= @value.to_s.split("/")
+    end
+  end
+
+  # Represents a transit byte array extension type.
+  # @see https://github.com/cognitect/transit-format
+  class ByteArray < Wrapper
+    def self.from_base64(data)
+      new(Base64.decode64(data))
+    end
+
+    def to_base64
+      Base64.encode64(@value)
+    end
+
+    # For human-readable display only. Use value() for programmatic
+    # consumption of the decoded value.
+    #
+    # Forces the platform's default external encoding, which is
+    # potentially lossy, but also guarantees that something will be
+    # printed instead of raising an error when there is no encoding
+    # information provided.
+    def to_s
+      @value.dup.force_encoding(Encoding.default_external)
+    end
+  end
+
+  # Represents a transit UUID extension type.
+  # @see https://github.com/cognitect/transit-format
+  class UUID
+    def self.random
+      new
+    end
+
+    def initialize(uuid_or_most_significant_bits=nil,least_significant_bits=nil)
+      case uuid_or_most_significant_bits
+      when String
+        @string_rep = uuid_or_most_significant_bits
+      when Array
+        @numeric_rep = uuid_or_most_significant_bits.map {|n| twos_complement(n)}
+      when Numeric
+        @numeric_rep = [twos_complement(uuid_or_most_significant_bits), twos_complement(least_significant_bits)]
+      when nil
+        @string_rep = SecureRandom.uuid
+      else
+        raise "Can't build UUID from #{uuid_or_most_significant_bits.inspect}"
+      end
+    end
+
+    def to_s
+      @string_rep ||= numbers_to_string
+    end
+
+    def most_significant_bits
+      @most_significant_bits ||= numeric_rep[0]
+    end
+
+    def least_significant_bits
+      @least_significant_bits ||= numeric_rep[1]
+    end
+
+    def inspect
+      @inspect ||= "<#{self.class} \"#{to_s}\">"
+    end
+
+    def ==(other)
+      return false unless other.is_a?(self.class)
+      if @numeric_rep
+        other.most_significant_bits == most_significant_bits &&
+          other.least_significant_bits == least_significant_bits
+      else
+        other.to_s == @string_rep
+      end
+    end
+    alias eql? ==
+
+    def hash
+      most_significant_bits.hash + least_significant_bits.hash
+    end
+
+    private
+
+    def numeric_rep
+      @numeric_rep ||= string_to_numbers
+    end
+
+    def numbers_to_string
+      most_significant_bits = @numeric_rep[0]
+      least_significant_bits = @numeric_rep[1]
+      digits(most_significant_bits >> 32, 8) + "-" +
+        digits(most_significant_bits >> 16, 4) + "-" +
+        digits(most_significant_bits, 4)       + "-" +
+        digits(least_significant_bits >> 48, 4) + "-" +
+        digits(least_significant_bits, 12)
+    end
+
+    def string_to_numbers
+      str = @string_rep.delete("-")
+      [twos_complement(str[ 0..15].hex), twos_complement(str[16..31].hex)]
+    end
+
+    def digits(val, digits)
+      hi = 1 << (digits*4)
+      (hi | (val & (hi - 1))).to_s(16)[1..-1]
+    end
+
+    def twos_complement(integer_value, num_of_bits=64)
+      max_signed   = 2**(num_of_bits-1)
+      max_unsigned = 2**num_of_bits
+      (integer_value >= max_signed) ? integer_value - max_unsigned : integer_value
+    end
+  end
+
+  # Represents a transit hypermedia link extension type.
+  # @see https://github.com/cognitect/transit-format
+  # @see http://amundsen.com/media-types/collection/format/#arrays-links
+  class Link
+    KEYS          = ["href", "rel", "name", "render", "prompt"]
+    RENDER_VALUES = ["link", "image"]
+
+    # @overload Link.new(hash)
+    #   @param [Hash] hash
+    #     Valid keys are:
+    #       "href"   required, String or Addressable::URI
+    #       "rel"    required, String
+    #       "name"   optional, String
+    #       "render" optional, String (only "link" or "image")
+    #       "prompt" optional, String
+    # @overload Link.new(href, rel, name, render, prompt)
+    #   @param [String, Addressable::URI] href required
+    #   @param [String] rel required
+    #   @param [String] name optional
+    #   @param [String] render optional (only "link" or "image")
+    #   @param [String] prompt optional
+    def initialize(*args)
+      @values = if args[0].is_a?(Hash)
+                  reconcile_values(args[0])
+                elsif args.length >= 2 && (args[0].is_a?(Addressable::URI) || args[0].is_a?(String))
+                  reconcile_values(Hash[KEYS.zip(args)])
+                else
+                  raise ArgumentError, "The first argument to Link.new can be a URI, String or a Hash. When the first argument is a URI or String, the second argument, rel, must present."
+                end
+    end
+
+    def href;   @href   ||= @values["href"]   end
+    def rel;    @rel    ||= @values["rel"]    end
+    def name;   @name   ||= @values["name"]   end
+    def render; @render ||= @values["render"] end
+    def prompt; @prompt ||= @values["prompt"] end
+
+    def to_h
+      @values
+    end
+
+    def ==(other)
+      other.is_a?(Link) && other.to_h == to_h
+    end
+    alias eql? ==
+
+    def hash
+      @values.hash
+    end
+
+    private
+
+    def reconcile_values(map)
+      map.dup.tap do |m|
+        m["href"] = Addressable::URI.parse(m["href"]) if m["href"].is_a?(String)
+        if m["render"]
+          render = m["render"].downcase
+          if RENDER_VALUES.include?(render)
+            m["render"] = render
+          else
+            raise ArgumentError, "render must be either #{RENDER_VALUES[0]} or #{RENDER_VALUES[1]}"
+          end
+        end
+      end.freeze
+    end
+  end
+
+  # Represents a transit tag and value. Returned by default when a
+  # reader encounters a tag for which there is no registered
+  # handler. Can also be used in a custom write handler to force
+  # representation to use a transit ground type using a rep for which
+  # there is no registered handler (e.g., an iterable for the
+  # representation of an array).
+  # @see https://github.com/cognitect/transit-format
+  class TaggedValue
+    attr_reader :tag, :rep
+    def initialize(tag, rep)
+      @tag = tag
+      @rep = rep
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && other.tag == @tag && other.rep == @rep
+    end
+    alias eql? ==
+
+    def hash
+      @tag.hash + @rep.hash
+    end
+  end
+end

data/lib/transit/write_handlers.rb

@@ -0,0 +1,438 @@
+# Copyright 2014 Cognitect. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS-IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Transit
+  # WriteHandlers convert instances of Ruby types to their
+  # corresponding Transit semantic types, and ReadHandlers read
+  # convert transit values back into instances of Ruby
+  # types. transit-ruby ships with default sets of WriteHandlers for
+  # each of the Ruby types that map naturally to transit types, and
+  # ReadHandlers for each transit type. For the common case, the
+  # built-in handlers will suffice, but you can add your own extension
+  # types and/or override the built-in handlers.
+  #
+  # ## Custom handlers
+  #
+  # For example, Ruby has Date, Time, and DateTime, each with their
+  # own semantics. Transit has an instance type, which does not
+  # differentiate between Date and Time, so transit-ruby writes Dates,
+  # Times, and DateTimes as transit instances, and reads transit
+  # instances as DateTimes. If your application cares that Dates are
+  # different from DateTimes, you could register custom write and read
+  # handlers, overriding the built-in DateHandler and adding a new
+  # DateReadHandler.
+  #
+  # ### Write handlers
+  #
+  # Write handlers are required to expose <tt>tag</tt>, <tt>rep</tt>, and <tt>string_rep</tt> methods:
+  #
+  # ```ruby
+  # class DateWriteHandler
+  #   def tag(_) "D" end
+  #   def rep(o) o.to_s end
+  #   def string_rep(o) o.to_s end
+  #   def verbose_handler(_) nil end # optional - see Verbose write handlers, below
+  # end
+  # ```
+  #
+  # <tt>tag</tt> returns the tag used to identify the transit type
+  # (built-in or extension). It accepts the object being written,
+  # which allows the handler to return different tags for different
+  # semantics, e.g. the built-in IntHandler, which returns the tag "i"
+  # for numbers that fit within a 64-bit signed integer and "n" for
+  # anything outside that range.
+  #
+  # <tt>rep</tt> accepts the object being written and returns its wire
+  # representation. This can be a scalar value (identified by a
+  # one-character tag) or a map (Ruby Hash) or an array (identified by
+  # a multi-character tag).
+  #
+  # <tt>string_rep</tt> accepts the object being written and returns a
+  # string representation. Used when the object is a key in a map.
+  #
+  # ### Read handlers
+  #
+  # Read handlers are required to expose a single <tt>from_rep</tt> method:
+  #
+  # ```ruby
+  # class DateReadHandler
+  #   def from_rep(rep)
+  #     Date.parse(rep)
+  #   end
+  # end
+  # ```
+  #
+  # <tt>from_rep</tt> accepts the wire representation (without the tag), and
+  # uses it to build an appropriate Ruby object.
+  #
+  # ### Usage
+  #
+  # ```ruby
+  # io = StringIO.new('','w+')
+  # writer = Transit::Writer.new(:json, io, :handlers => {Date => DateWriteHandler.new})
+  # writer.write(Date.new(2014,7,22))
+  # io.string
+  # # => "[\"~#'\",\"~D2014-07-22\"]\n"
+  #
+  # reader = Transit::Reader.new(:json, StringIO.new(io.string), :handlers => {"D" => DateReadHandler.new})
+  # reader.read
+  # # => #<Date: 2014-07-22 ((2456861j,0s,0n),+0s,2299161j)>
+  # ```
+  #
+  # ## Custom types and representations
+  #
+  # Transit supports scalar and structured representations. The Date
+  # example, above, demonstrates a String representation (scalar) of a
+  # Date. This works well because it is a natural representation, but
+  # it might not be a good solution for a more complex type, e.g. a
+  # Point. While you _could_ represent a Point as a String, e.g.
+  # <tt>("x:37,y:42")</tt>, it would be more efficient and arguably
+  # more natural to represent it as an array of Integers:
+  #
+  # ```ruby
+  # require 'ostruct'
+  # Point = Struct.new(:x,:y) do
+  #   def to_a; [x,y] end
+  # end
+  #
+  # class PointWriteHandler
+  #   def tag(_) "point" end
+  #   def rep(o) o.to_a  end
+  #   def string_rep(_) nil end
+  # end
+  #
+  # class PointReadHandler
+  #   def from_rep(rep)
+  #     Point.new(*rep)
+  #   end
+  # end
+  #
+  # io = StringIO.new('','w+')
+  # writer = Transit::Writer.new(:json_verbose, io, :handlers => {Point => PointWriteHandler.new})
+  # writer.write(Point.new(37,42))
+  # io.string
+  # # => "{\"~#point\":[37,42]}\n"
+  #
+  # reader = Transit::Reader.new(:json, StringIO.new(io.string),
+  #   :handlers => {"point" => PointReadHandler.new})
+  # reader.read
+  # # => #<struct Point x=37, y=42>
+  # ```
+  #
+  # Note that Date used a one-character tag, "D", whereas Point uses a
+  # multi-character tag, "point". Transit expects one-character tags
+  # to have scalar representations (string, integer, float, boolean,
+  # etc) and multi-character tags to have structural representations,
+  # i.e. maps (Ruby Hashes) or arrays.
+  #
+  # ## Verbose write handlers
+  #
+  # Write handlers can, optionally, support the JSON-VERBOSE format by
+  # providing a verbose write handler. Transit uses this for instances
+  # (Ruby Dates, Times, DateTimes) to differentiate between the more
+  # efficient format using an int representing milliseconds since 1970
+  # in JSON mode from the more readable format using a String in
+  # JSON-VERBOSE mode.
+  #
+  # ```ruby
+  # inst = DateTime.new(1985,04,12,23,20,50,"0")
+  #
+  # io = StringIO.new('','w+')
+  # writer = Transit::Writer.new(:json, io)
+  # writer.write(inst)
+  # io.string
+  # #=> "[\"~#'\",\"~m482196050000\"]\n"
+  #
+  # io = StringIO.new('','w+')
+  # writer = Transit::Writer.new(:json_verbose, io)
+  # writer.write(inst)
+  # io.string
+  # #=> "{\"~#'\":\"~t1985-04-12T23:20:50.000Z\"}\n"
+  # ```
+  #
+  # When you want a more human-readable format for your own custom
+  # types in JSON-VERBOSE mode, create a second write handler and add
+  # a <tt>verbose_handler</tt> method to the first handler that
+  # returns an instance of the verbose handler:
+  #
+  # ```ruby
+  # Element = Struct.new(:id, :name)
+  #
+  # class ElementWriteHandler
+  #   def tag(_) "el" end
+  #   def rep(v) v.id end
+  #   def string_rep(v) v.name end
+  #   def verbose_handler() ElementVerboseWriteHandler.new end
+  # end
+  #
+  # class ElementVerboseWriteHandler < ElementWriteHandler
+  #   def rep(v) v.name end
+  # end
+  #
+  # write_handlers = {Element => ElementWriteHandler.new}
+  #
+  # e = Element.new(3, "Lithium")
+  #
+  # io = StringIO.new('','w+')
+  # writer = Transit::Writer.new(:json, io, :handlers => write_handlers)
+  # writer.write(e)
+  # io.string
+  # # => "[\"~#el\",3]\n"
+  #
+  # io = StringIO.new('','w+')
+  # writer = Transit::Writer.new(:json_verbose, io, :handlers => write_handlers)
+  # writer.write(e)
+  # io.string
+  # # => "{\"~#el\":\"Lithium\"}\n"
+  # ```
+  #
+  # Note that you register the same handler collection; transit-ruby takes care of
+  # asking for the verbose_handler for the :json_verbose format.
+  module WriteHandlers
+    class NilHandler
+      def tag(_) "_" end
+      def rep(_) nil end
+      def string_rep(n) nil end
+    end
+
+    class KeywordHandler
+      def tag(_) ":" end
+      def rep(s) s.to_s end
+      def string_rep(s) rep(s) end
+    end
+
+    class StringHandler
+      def tag(_) "s" end
+      def rep(s) s end
+      def string_rep(s) s end
+    end
+
+    class TrueHandler
+      def tag(_) "?" end
+      def rep(_) true end
+      def string_rep(_) "t" end
+    end
+
+    class FalseHandler
+      def tag(_) "?" end
+      def rep(_) false end
+      def string_rep(_) "f" end
+    end
+
+    class IntHandler
+      def tag(i) i > MAX_INT || i < MIN_INT ? "n" : "i" end
+      def rep(i) i > MAX_INT || i < MIN_INT ? i.to_s : i end
+      def string_rep(i) i.to_s end
+    end
+
+    class FloatHandler
+      def tag(f)
+        return "z" if f.nan?
+        case f
+        when Float::INFINITY, -Float::INFINITY
+          "z"
+        else
+          "d"
+        end
+      end
+
+      def rep(f)
+        return "NaN" if f.nan?
+        case f
+        when  Float::INFINITY then "INF"
+        when -Float::INFINITY then "-INF"
+        else f
+        end
+      end
+
+      def string_rep(f) rep(f).to_s end
+    end
+
+    class BigDecimalHandler
+      def tag(_) "f" end
+      def rep(f) f.to_s("f") end
+      def string_rep(f) rep(f) end
+    end
+
+    class RationalHandler
+      def tag(_) "ratio" end
+      def rep(r) [r.numerator, r.denominator] end
+      def string_rep(_) nil end
+    end
+
+    # TimeHandler, DateTimeHandler, and DateHandler all have different
+    # implementations of string_rep. Here is the rationale:
+    #
+    # For all three, want to write out the same format
+    # e.g. 2014-04-18T18:51:29.478Z, and we want the milliseconds to truncate
+    # rather than round, eg 29.4786 seconds should be 29.478, not 29.479.
+    # - "sss is the number of complete milliseconds since the start of the
+    #    second as three decimal digits."
+    # - http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.1.15
+    #
+    # Some data points (see benchmarks/encoding_time.rb)
+    # - Time and DateTime each offer iso8601 methods, but strftime is faster.
+    # - DateTime's strftime (and iso8601) round millis
+    # - Time's strftime (and iso8601) truncate millis
+    # - we don't care about truncate v round for dates (which have 000 ms)
+    # - date.to_datetime.strftime(...) is considerably faster than date.to_time.strftime(...)
+    class TimeHandler
+      def tag(_) "m" end
+      def rep(t) DateTimeUtil.to_millis(t) end
+      def string_rep(t) rep(t).to_s end
+      def verbose_handler() VerboseTimeHandler.new end
+    end
+
+    class DateTimeHandler < TimeHandler
+      def verbose_handler() VerboseDateTimeHandler.new end
+    end
+
+    class DateHandler     < TimeHandler
+      def verbose_handler() VerboseDateHandler.new end
+    end
+
+    class VerboseTimeHandler
+      def tag(_) "t" end
+      def rep(t)
+        # .getutc because we don't want to modify t
+        t.getutc.strftime(Transit::TIME_FORMAT)
+      end
+      def string_rep(t) rep(t) end
+    end
+
+    class VerboseDateTimeHandler < VerboseTimeHandler
+      def rep(t)
+        # .utc because to_time already creates a new object
+        t.to_time.utc.strftime(Transit::TIME_FORMAT)
+      end
+    end
+
+    class VerboseDateHandler < VerboseTimeHandler
+      def rep(d)
+        # to_datetime because DateTime's strftime is faster
+        # thank Time's, and millis are 000 so it doesn't matter
+        # if we truncate or round.
+        d.to_datetime.strftime(Transit::TIME_FORMAT)
+      end
+    end
+
+    class UuidHandler
+      def tag(_) "u" end
+      def rep(u) [u.most_significant_bits, u.least_significant_bits] end
+      def string_rep(u) u.to_s end
+    end
+
+    class LinkHandler
+      def tag(_) "link" end
+      def rep(l) l.to_h end
+      def string_rep(_) nil end
+    end
+
+    class UriHandler
+      def tag(_) "r" end
+      def rep(u) u.to_s end
+      def string_rep(u) rep(u) end
+    end
+
+    class AddressableUriHandler
+      def tag(_) "r" end
+      def rep(u) u.to_s end
+      def string_rep(u) rep(u) end
+    end
+
+    class ByteArrayHandler
+      def tag(_) "b" end
+      if Transit::jruby?
+        def rep(b)
+          b.value.to_java_bytes
+        end
+      else
+        def rep(b)
+          b.to_base64
+        end
+      end
+      def string_rep(b) rep(b) end
+    end
+
+    class TransitSymbolHandler
+      def tag(_) "$" end
+      def rep(s) s.to_s end
+      def string_rep(s) rep(s) end
+    end
+
+    class ArrayHandler
+      def tag(_) "array" end
+      def rep(a) a end
+      def string_rep(_) nil end
+    end
+
+    class MapHandler
+      def handlers=(handlers)
+        @handlers = handlers
+      end
+
+      def stringable_keys?(m)
+        m.keys.all? {|k| (@handlers[k.class].tag(k).length == 1) }
+      end
+
+      def tag(m)
+        stringable_keys?(m) ? "map" : "cmap"
+      end
+
+      def rep(m)
+        stringable_keys?(m) ? m : m.reduce([]) {|a, kv| a.concat(kv)}
+      end
+
+      def string_rep(_) nil end
+    end
+
+    class SetHandler
+      def tag(_) "set" end
+      def rep(s) s.to_a end
+      def string_rep(_) nil end
+    end
+
+    class TaggedValueHandler
+      def tag(tv) tv.tag end
+      def rep(tv) tv.rep end
+      def string_rep(_) nil end
+    end
+
+    DEFAULT_WRITE_HANDLERS = {
+      NilClass         => NilHandler.new,
+      ::Symbol         => KeywordHandler.new,
+      String           => StringHandler.new,
+      TrueClass        => TrueHandler.new,
+      FalseClass       => FalseHandler.new,
+      Fixnum           => IntHandler.new,
+      Bignum           => IntHandler.new,
+      Float            => FloatHandler.new,
+      BigDecimal       => BigDecimalHandler.new,
+      Rational         => RationalHandler.new,
+      Time             => TimeHandler.new,
+      DateTime         => DateTimeHandler.new,
+      Date             => DateHandler.new,
+      UUID             => UuidHandler.new,
+      Link             => LinkHandler.new,
+      URI              => UriHandler.new,
+      Addressable::URI => AddressableUriHandler.new,
+      ByteArray        => ByteArrayHandler.new,
+      Transit::Symbol  => TransitSymbolHandler.new,
+      Array            => ArrayHandler.new,
+      Hash             => MapHandler.new,
+      Set              => SetHandler.new,
+      TaggedValue      => TaggedValueHandler.new
+    }.freeze
+  end
+end