transit-ruby 0.8.467

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.getutc
+      else
+        raise "Don't know how to get millis from #{t.inspect}"
+      end
+      (t.to_i * 1000) + (t.usec / 1000)
+    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/read_handlers.rb

@@ -0,0 +1,98 @@
+# 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 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
+
+    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,
+      "set"     => SetHandler.new,
+      "link"    => LinkHandler.new,
+      "list"    => IdentityHandler.new,
+      "cmap"    => CmapHandler.new
+    }.freeze
+
+    DEFAULT_READ_HANDLER = Default.new
+
+  end
+end

data/lib/transit/reader.rb

@@ -0,0 +1,117 @@
+# 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
+    # @api private
+    class JsonUnmarshaler
+      class ParseHandler
+        def each(&block) @yield_v = block end
+        def add_value(v) @yield_v[v] if @yield_v end
+
+        def hash_start()      {} end
+        def hash_set(h,k,v)   h.store(k,v) end
+        def array_start()     [] end
+        def array_append(a,v) a << v end
+
+        def error(message, line, column)
+          raise Exception.new(message, line, column)
+        end
+      end
+
+      def initialize(io, opts)
+        @io = io
+        @decoder = Transit::Decoder.new(opts)
+        @parse_handler = ParseHandler.new
+      end
+
+      # @see Reader#read
+      def read
+        if block_given?
+          @parse_handler.each {|v| yield @decoder.decode(v)}
+        else
+          @parse_handler.each {|v| return @decoder.decode(v)}
+        end
+        Oj.sc_parse(@parse_handler, @io)
+      end
+    end
+
+    # @api private
+    class MessagePackUnmarshaler
+      def initialize(io, opts)
+        @decoder = Transit::Decoder.new(opts)
+        @unpacker = MessagePack::Unpacker.new(io)
+      end
+
+      # @see Reader#read
+      def read
+        if block_given?
+          @unpacker.each {|v| yield @decoder.decode(v)}
+        else
+          @decoder.decode(@unpacker.read)
+        end
+      end
+    end
+
+    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
+                  require 'oj'
+                  JsonUnmarshaler.new(io, opts)
+                else
+                  require 'msgpack'
+                  MessagePackUnmarshaler.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,251 @@
+# 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
+
+    def to_s
+      @value
+    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