xnlogic-transit-ruby 0.8.572-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,123 @@
+# 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
+    MUTEX = Mutex.new
+    HANDLER_CACHE = {}
+
+    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)}
+      MUTEX.synchronize do
+        if HANDLER_CACHE.has_key?(custom_handlers)
+          @handlers = HANDLER_CACHE[custom_handlers]
+        else
+          @handlers = ReadHandlers::DEFAULT_READ_HANDLERS.merge(custom_handlers)
+        end
+
+      end
+      @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 = 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
+          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,193 @@
+# 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
+
+    HANDLER_CACHE = {}
+    VERBOSE_HANDLER_CACHE = {}
+    MUTEX = Mutex.new
+
+    # @api private
+    # Included in VerboseJson subclasses. Defined here to make it
+    # available in CRuby and JRuby environments.
+    module VerboseHandlers
+      def build_handlers(custom_handlers)
+        if VERBOSE_HANDLER_CACHE.has_key?(custom_handlers)
+          VERBOSE_HANDLER_CACHE[custom_handlers]
+        else
+          handlers = super(custom_handlers).reduce({}) do |h, (k,v)|
+            if v.respond_to?(:verbose_handler) && vh = v.verbose_handler
+              h.store(k, vh)
+            else
+              h.store(k, v)
+            end
+            h
+          end
+          VERBOSE_HANDLER_CACHE[custom_handlers] = handlers
+          handlers
+        end
+      end
+    end
+
+    # @api private
+    module Base
+      def parse_options(opts)
+        MUTEX.synchronize do
+          @handlers = build_handlers(opts[:handlers])
+        end
+        @handlers.values.each { |h| h.handlers=(@handlers) if h.respond_to?(:handlers=) }
+      end
+
+      def build_handlers(custom_handlers)
+        if HANDLER_CACHE.has_key?(custom_handlers)
+          HANDLER_CACHE[custom_handlers]
+        else
+          handlers = WriteHandlers::DEFAULT_WRITE_HANDLERS.dup
+          handlers.merge!(custom_handlers) if custom_handlers
+          HANDLER_CACHE[custom_handlers] = handlers
+          handlers
+        end
+      end
+
+      def find_handler(obj)
+        obj.class.ancestors.each do |a|
+          if handler = @handlers[a]
+            return handler
+          end
+        end
+        nil
+      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.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_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)
+        if 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
+        else
+          raise "Can not find a Write Handler for #{obj.inspect}."
+        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,38 @@
+# 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
+
+    # @api private
+    module JsonBase
+      def initialize(io, opts)
+        parse_options(opts)
+      end
+    end
+
+    # @api private
+    class Json
+      include Transit::Marshaler::Base
+      include Transit::Marshaler::JsonBase
+    end
+
+    # @api private
+    class VerboseJson
+      include Transit::Marshaler::Base
+      include Transit::Marshaler::JsonBase
+      include Transit::Marshaler::VerboseHandlers
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# 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 initialize(io, opts)
+        parse_options(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