transit-ruby 0.8.552-java

data/lib/transit/date_time_util.rb

@@ -0,0 +1,39 @@
+# 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
+  module DateTimeUtil
+    def to_millis(v)
+      case v
+      when DateTime
+        t = v.new_offset(0).to_time
+      when Date
+        t = Time.gm(v.year, v.month, v.day)
+      when Time
+        t = v
+      else
+        raise "Don't know how to get millis from #{t.inspect}"
+      end
+      (t.to_i * 1000) + (t.usec / 1000.0).round
+    end
+
+    def from_millis(millis)
+      t = Time.at(millis / 1000).utc
+      DateTime.new(t.year, t.month, t.day, t.hour, t.min, t.sec + (millis % 1000 * 0.001))
+    end
+
+    module_function :to_millis, :from_millis
+  end
+end

data/lib/transit/decoder.rb

@@ -0,0 +1,115 @@
+# 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
+  # Converts a transit value to an instance of a type
+  # @api private
+  class Decoder
+    ESC_ESC  = "#{ESC}#{ESC}"
+    ESC_SUB  = "#{ESC}#{SUB}"
+    ESC_RES  = "#{ESC}#{RES}"
+
+    IDENTITY = ->(v){v}
+
+    GROUND_TAGS = %w[_ s ? i d b ' array map]
+
+    def initialize(options={})
+      custom_handlers = options[:handlers] || {}
+      custom_handlers.each {|k,v| validate_handler(k,v)}
+      @handlers = ReadHandlers::DEFAULT_READ_HANDLERS.merge(custom_handlers)
+      @default_handler = options[:default_handler] || ReadHandlers::DEFAULT_READ_HANDLER
+    end
+
+    # @api private
+    class Tag < String; end
+
+    # Decodes a transit value to a corresponding object
+    #
+    # @param node a transit value to be decoded
+    # @param cache
+    # @param as_map_key
+    # @return decoded object
+    def decode(node, cache=RollingCache.new, as_map_key=false)
+      case node
+      when String
+        if cache.has_key?(node)
+          cache.read(node)
+        else
+          parsed = begin
+                     if !node.start_with?(ESC)
+                       node
+                     elsif node.start_with?(TAG)
+                       Tag.new(node[2..-1])
+                     elsif handler = @handlers[node[1]]
+                       handler.from_rep(node[2..-1])
+                     elsif node.start_with?(ESC_ESC, ESC_SUB, ESC_RES)
+                       node[1..-1]
+                     else
+                       @default_handler.from_rep(node[1], node[2..-1])
+                     end
+                   end
+          if cache.cacheable?(node, as_map_key)
+            cache.write(parsed)
+          end
+          parsed
+        end
+      when Array
+        return node if node.empty?
+        e0 = decode(node.shift, cache, false)
+        if e0 == MAP_AS_ARRAY
+          decode(Hash[*node], cache)
+        elsif Tag === e0
+          v = decode(node.shift, cache)
+          if handler = @handlers[e0]
+            handler.from_rep(v)
+          else
+            @default_handler.from_rep(e0,v)
+          end
+        else
+          [e0] + node.map {|e| decode(e, cache, as_map_key)}
+        end
+      when Hash
+        if node.size == 1
+          k = decode(node.keys.first,   cache, true)
+          v = decode(node.values.first, cache, false)
+          if Tag === k
+            if handler = @handlers[k]
+              handler.from_rep(v)
+            else
+              @default_handler.from_rep(k,v)
+            end
+          else
+            {k => v}
+          end
+        else
+          node.keys.each do |k|
+            node.store(decode(k, cache, true), decode(node.delete(k), cache))
+          end
+          node
+        end
+      else
+        node
+      end
+    end
+
+    def validate_handler(key, handler)
+      raise ArgumentError.new(CAN_NOT_OVERRIDE_GROUND_TYPES_MESSAGE) if GROUND_TAGS.include?(key)
+    end
+
+    CAN_NOT_OVERRIDE_GROUND_TYPES_MESSAGE = <<-MSG
+You can not supply custom read handlers for ground types.
+MSG
+
+  end
+end

data/lib/transit/marshaler/base.rb

@@ -0,0 +1,179 @@
+# 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::Writer marshals Ruby objects as transit values to an output stream.
+  # @see https://github.com/cognitect/transit-format
+  module Marshaler
+
+    # @api private
+    module Base
+      def parse_options(opts)
+        @cache_enabled  = !opts[:verbose]
+        @prefer_strings = opts[:prefer_strings]
+        @max_int        = opts[:max_int]
+        @min_int        = opts[:min_int]
+
+        handlers = WriteHandlers::DEFAULT_WRITE_HANDLERS.dup
+        handlers = handlers.merge!(opts[:handlers]) if opts[:handlers]
+        @handlers = (opts[:verbose] ? verbose_handlers(handlers) : handlers)
+        @handlers.values.each do |h|
+          if h.respond_to?(:handlers=)
+            h.handlers=(@handlers)
+          end
+        end
+      end
+
+      def find_handler(obj)
+        obj.class.ancestors.each do |a|
+          if handler = @handlers[a]
+            return handler
+          end
+        end
+        nil
+      end
+
+      def verbose_handlers(handlers)
+        handlers.each do |k, v|
+          if v.respond_to?(:verbose_handler) && vh = v.verbose_handler
+            handlers.store(k, vh)
+          end
+        end
+        handlers
+      end
+
+      def escape(s)
+        if s.start_with?(SUB,ESC,RES) && s != "#{SUB} "
+          "#{ESC}#{s}"
+        else
+          s
+        end
+      end
+
+      def emit_nil(as_map_key, cache)
+        as_map_key ? emit_string(ESC, "_", nil, true, cache) : emit_value(nil)
+      end
+
+      def emit_string(prefix, tag, value, as_map_key, cache)
+        encoded = "#{prefix}#{tag}#{value}"
+        if @cache_enabled && cache.cacheable?(encoded, as_map_key)
+          emit_value(cache.write(encoded), as_map_key)
+        else
+          emit_value(encoded, as_map_key)
+        end
+      end
+
+      def emit_boolean(handler, b, as_map_key, cache)
+        as_map_key ? emit_string(ESC, "?", handler.string_rep(b), true, cache) : emit_value(b)
+      end
+
+      def emit_int(tag, i, as_map_key, cache)
+        if as_map_key || i > @max_int || i < @min_int
+          emit_string(ESC, tag, i, as_map_key, cache)
+        else
+          emit_value(i, as_map_key)
+        end
+      end
+
+      def emit_double(d, as_map_key, cache)
+        as_map_key ? emit_string(ESC, "d", d, true, cache) : emit_value(d)
+      end
+
+      def emit_array(a, cache)
+        emit_array_start(a.size)
+        a.each {|e| marshal(e, false, cache)}
+        emit_array_end
+      end
+
+      def emit_map(m, cache)
+        emit_map_start(m.size)
+        m.each do |k,v|
+          marshal(k, true, cache)
+          marshal(v, false, cache)
+        end
+        emit_map_end
+      end
+
+      def emit_tagged_value(tag, rep, cache)
+        emit_array_start(2)
+        emit_string(ESC, "#", tag, false, cache)
+        marshal(rep, false, cache)
+        emit_array_end
+      end
+
+      def emit_encoded(handler, tag, obj, as_map_key, cache)
+        if tag.length == 1
+          rep = handler.rep(obj)
+          if String === rep
+            emit_string(ESC, tag, rep, as_map_key, cache)
+          elsif as_map_key || @prefer_strings
+            if str_rep = handler.string_rep(obj)
+              emit_string(ESC, tag, str_rep, as_map_key, cache)
+            else
+              raise "Cannot be encoded as String: " + {:tag => tag, :rep => rep, :obj => obj}.to_s
+            end
+          else
+            emit_tagged_value(tag, handler.rep(obj), cache)
+          end
+        elsif as_map_key
+          raise "Cannot be used as a map key: " + {:tag => tag, :rep => rep, :obj => obj}.to_s
+        else
+          emit_tagged_value(tag, handler.rep(obj), cache)
+        end
+      end
+
+      def marshal(obj, as_map_key, cache)
+        handler = find_handler(obj)
+        tag = handler.tag(obj)
+        case tag
+        when "_"
+          emit_nil(as_map_key, cache)
+        when "?"
+          emit_boolean(handler, obj, as_map_key, cache)
+        when "s"
+          emit_string(nil, nil, escape(handler.rep(obj)), as_map_key, cache)
+        when "i"
+          emit_int(tag, handler.rep(obj), as_map_key, cache)
+        when "d"
+          emit_double(handler.rep(obj), as_map_key, cache)
+        when "'"
+          emit_tagged_value(tag, handler.rep(obj), cache)
+        when "array"
+          emit_array(handler.rep(obj), cache)
+        when "map"
+          emit_map(handler.rep(obj), cache)
+        else
+          emit_encoded(handler, tag, obj, as_map_key, cache)
+        end
+      end
+
+      def marshal_top(obj, cache=RollingCache.new)
+        if handler = find_handler(obj)
+          if tag = handler.tag(obj)
+            if tag.length == 1
+              marshal(TaggedValue.new(QUOTE, obj), false, cache)
+            else
+              marshal(obj, false, cache)
+            end
+            flush
+          else
+            raise "Handler must provide a non-nil tag: #{handler.inspect}"
+          end
+        else
+          raise "Can not find a Write Handler for #{obj.inspect}."
+        end
+      end
+    end
+  end
+end

data/lib/transit/marshaler/jruby/json.rb

@@ -0,0 +1,46 @@
+# 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
+  module Marshaler
+
+    module JsonBase
+      def default_opts
+        {:prefer_strings => true,
+          :max_int       => JSON_MAX_INT,
+          :min_int       => JSON_MIN_INT}
+      end
+    end
+
+    # @api private
+    class Json
+      include Transit::Marshaler::Base
+      include Transit::Marshaler::JsonBase
+
+      def initialize(io, opts)
+        parse_options(default_opts.merge(opts))
+      end
+    end
+
+    # @api private
+    class VerboseJson
+      include Transit::Marshaler::Base
+      include Transit::Marshaler::JsonBase
+
+      def initialize(io, opts)
+        parse_options(default_opts.merge(opts))
+      end
+    end
+  end
+end

data/lib/transit/marshaler/jruby/messagepack.rb

@@ -0,0 +1,31 @@
+# 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
+  module Marshaler
+    class MessagePack
+      include Transit::Marshaler::Base
+
+      def default_opts
+        {:prefer_strings => false,
+          :max_int       => MAX_INT,
+          :min_int       => MIN_INT}
+      end
+
+      def initialize(io, opts)
+        parse_options(default_opts.merge(opts))
+      end
+    end
+  end
+end

data/lib/transit/read_handlers.rb

@@ -0,0 +1,113 @@
+# 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
+  # @see Transit::WriteHandlers
+  module ReadHandlers
+    class Default
+      def from_rep(tag,val) TaggedValue.new(tag, val) end
+    end
+    class NilHandler
+      def from_rep(_) nil end
+    end
+    class KeywordHandler
+      def from_rep(v) v.to_sym end
+    end
+    class BooleanHandler
+      def from_rep(v) v == "t" end
+    end
+    class ByteArrayHandler
+      def from_rep(v) ByteArray.from_base64(v) end
+    end
+    class FloatHandler
+      def from_rep(v) Float(v) end
+    end
+    class IntegerHandler
+      def from_rep(v) v.to_i end
+    end
+    class BigIntegerHandler
+      def from_rep(v) v.to_i end
+    end
+    class BigDecimalHandler
+      def from_rep(v) BigDecimal.new(v) end
+    end
+    class SpecialNumbersHandler
+      def from_rep(v)
+        case v
+        when "NaN"  then  Float::NAN
+        when "INF"  then  Float::INFINITY
+        when "-INF" then -Float::INFINITY
+        else raise ArgumentError.new("Don't know how to handle #{v.inspect} for the \"z\" tag")
+        end
+      end
+    end
+    class IdentityHandler
+      def from_rep(v) v end
+    end
+    class SymbolHandler
+      def from_rep(v) Transit::Symbol.new(v) end
+    end
+    class TimeStringHandler
+      def from_rep(v) DateTime.iso8601(v) end
+    end
+    class TimeIntHandler
+      def from_rep(v) DateTimeUtil.from_millis(v.to_i) end
+    end
+    class UuidHandler
+      def from_rep(v) UUID.new(v) end
+    end
+    class UriHandler
+      def from_rep(v) Addressable::URI.parse(v) end
+    end
+    class SetHandler
+      def from_rep(v) Set.new(v) end
+    end
+    class LinkHandler
+      def from_rep(v) Link.new(v) end
+    end
+    class CmapHandler
+      def from_rep(v) Hash[*v] end
+    end
+    class RatioHandler
+      def from_rep(v) Rational(v[0], v[1]) end
+    end
+
+    DEFAULT_READ_HANDLERS = {
+      "_" => NilHandler.new,
+      ":" => KeywordHandler.new,
+      "?" => BooleanHandler.new,
+      "b" => ByteArrayHandler.new,
+      "d" => FloatHandler.new,
+      "i" => IntegerHandler.new,
+      "n" => BigIntegerHandler.new,
+      "f" => BigDecimalHandler.new,
+      "c" => IdentityHandler.new,
+      "$" => SymbolHandler.new,
+      "t" => TimeStringHandler.new,
+      "m" => TimeIntHandler.new,
+      "u" => UuidHandler.new,
+      "r" => UriHandler.new,
+      "'" => IdentityHandler.new,
+      "z" => SpecialNumbersHandler.new,
+      "set"     => SetHandler.new,
+      "link"    => LinkHandler.new,
+      "list"    => IdentityHandler.new,
+      "cmap"    => CmapHandler.new,
+      "ratio"   => RatioHandler.new
+    }.freeze
+
+    DEFAULT_READ_HANDLER = Default.new
+
+  end
+end