ffi-msgpack 0.1.0

data/lib/ffi/msgpack/packable.rb

@@ -0,0 +1,20 @@
+require 'ffi/msgpack/packer'
+
+module FFI
+  module MsgPack
+    module Packable
+      #
+      # Packs a Ruby Object.
+      #
+      # @return [String]
+      #   The packed Object.
+      #
+      def to_msgpack
+        packer = Packer.create
+        packer << obj
+
+        return packer.to_s
+      end
+    end
+  end
+end

data/lib/ffi/msgpack/packer.rb

@@ -0,0 +1,153 @@
+require 'ffi/msgpack/types'
+require 'ffi/msgpack/msgpack'
+
+module FFI
+  module MsgPack
+    class Packer < FFI::Struct
+
+      layout :data, :pointer,
+             :callback, :msgpack_packer_write
+
+      # The optional buffer to write packed Msg Objects into.
+      attr_accessor :buffer
+
+      # The total length of the buffer
+      attr_accessor :total
+
+      #
+      # Creates a new packer.
+      #
+      # @param [#<<] buffer
+      #   Optional buffer to append packed Msg Objects to.
+      #
+      # @yield [packed(,length)]
+      #   If a block is given, it will be used as the callback to write
+      #   the packed data.
+      #
+      # @yieldparam [String] packed
+      #   The packed bytes representing a Msg Object.
+      #
+      # @yieldparam [Integer] length
+      #   The length of the packed data.
+      #
+      # @return [Packer]
+      #   The new packer.
+      #
+      def Packer.create(buffer=nil,&block)
+        packer = Packer.new()
+
+        # zero the memory
+        packer[:data] = nil
+        packer[:callback] = nil
+
+        # zero the total
+        packer.total = 0
+
+        if block
+          # disable the buffer
+          packer.buffer = nil
+
+          # custom callback
+          packer.callback(&block)
+        else
+          # set the buffer
+          packer.buffer = (buffer || '')
+
+          # setup the default callback
+          packer.callback do |packed,length|
+            packer.buffer << packed
+          end
+        end
+
+        return packer
+      end
+
+      #
+      # Sets the write callback for the packer.
+      #
+      # @yield [packed(,length)]
+      #   If a block is given, it will be used as the callback to write
+      #   the packed data.
+      #
+      # @yieldparam [String] packed
+      #   The packed bytes representing a Msg Object.
+      #
+      # @yieldparam [Integer] length
+      #   The length of the packed data.
+      #
+      # @return [Proc]
+      #   The new callback.
+      #
+      def callback(&block)
+        self[:callback] = Proc.new do |data_ptr,packed_ptr,length|
+          @total += length
+
+          packed = packed_ptr.get_bytes(0,length)
+
+          if block.arity == 2
+            block.call(packed,length)
+          else
+            block.call(packed)
+          end
+          
+          0 # return 0 to indicate success
+        end
+      end
+
+      #
+      # Packs a Msg Object.
+      #
+      # @param [MsgObject] msg
+      #   The Msg Object to pack.
+      #
+      # @return [Integer]
+      #   Returns 0 on a successful write, and -1 if an error occurred.
+      #
+      def pack(msg)
+        MsgPack.msgpack_pack_object(self,msg)
+      end
+
+      #
+      # Packs a Ruby object.
+      #
+      # @param [Hash, Array, String, Symbol, Integer, Float, true, false, nil] value
+      #   The Ruby object to pack.
+      #
+      # @return [Packer]
+      #   The packer.
+      #
+      def <<(value)
+        pack(MsgObject.new_object(value))
+        return self
+      end
+
+      #
+      # The contents of the buffer.
+      #
+      # @return [String, nil]
+      #   The contents of the buffer, or `nil` if only a callback is being
+      #   used to write the packed data.
+      #
+      def to_s
+        @buffer.to_s if @buffer
+      end
+
+      #
+      # Inspects the packer.
+      #
+      # @return [String]
+      #   The inspected packer.
+      #
+      def inspect
+        addr = ('0x%x' % self.pointer.address)
+
+        if @buffer
+          "#<#{self.class}:#{addr}: #{@buffer.inspect}>"
+        else
+          "#<#{self.class}:#{addr}>"
+        end
+      end
+
+    end
+  end
+end

data/lib/ffi/msgpack/types.rb

@@ -0,0 +1,30 @@
+require 'ffi'
+
+module FFI
+  module MsgPack
+    extend FFI::Library
+
+    typedef :pointer, :FILE
+
+    enum :msgpack_unpack_return, [
+      :success, 2,
+      :extra_bytes, 1,
+      :continue, 0,
+      :parse_error, -1
+    ]
+
+    callback :msgpack_packer_write, [:pointer, :pointer, :uint], :int
+
+    enum :msgpack_object_type, [
+      :nil,              0x01,
+      :boolean,          0x02,
+      :positive_integer, 0x03,
+      :negative_integer, 0x04,
+      :double,           0x05,
+      :raw,              0x06,
+      :array,            0x07,
+      :map,              0x08
+    ]
+
+  end
+end

data/lib/ffi/msgpack/unpacker.rb

@@ -0,0 +1,248 @@
+require 'ffi/msgpack/exceptions/parse_error'
+require 'ffi/msgpack/types'
+require 'ffi/msgpack/msgpack'
+
+module FFI
+  module MsgPack
+    class Unpacker < FFI::Struct
+
+      include Enumerable
+
+      # Default chunk-size to expand the buffer by
+      CHUNK_SIZE = 1024
+
+      # The default size of the unpacker buffer
+      DEFAULT_SIZE = CHUNK_SIZE * 4
+
+      # The chunk-size to expand the buffer by
+      attr_accessor :chunk_size
+
+      # The optional stream to read packed data from
+      attr_accessor :stream
+
+      layout :buffer, :pointer,
+             :used, :size_t,
+             :free, :size_t,
+             :off, :size_t,
+             :parsed, :size_t,
+             :z, :pointer,
+             :initial_buffer_size, :size_t,
+             :ctx, :pointer
+
+      #
+      # Initializes a new unpacker object.
+      #
+      def initialize(*arguments)
+        super(*arguments)
+
+        @chunk_size = CHUNK_SIZE
+        @stream = nil
+      end
+
+      #
+      # Creates a new unpacker object.
+      #
+      # @param [Integer] size
+      #   The buffer size of the unpacker.
+      #
+      # @return [Unpacker]
+      #   The new unpacker.
+      #
+      def Unpacker.create(size=DEFAULT_SIZE)
+        Unpacker.new(MsgPack.msgpack_unpacker_new(size))
+      end
+
+      #
+      # Destroys a previously allocated unpacker object.
+      #
+      # @param [FFI::Pointer] ptr
+      #   The pointer to the allocated unpacker.
+      #
+      def Unpacker.release(ptr)
+        MsgPack.msgpack_unpacker_free(ptr)
+      end
+
+      #
+      # Writes packed data into the buffer of the unpacker.
+      #
+      # @param [String] packed
+      #   The packed data.
+      #
+      # @return [Unpacker]
+      #   The unpacker.
+      #
+      def <<(packed)
+        # make sure we have space in the buffer
+        reserve_buffer(packed.length)
+
+        # copy in the bytes
+        self[:buffer].put_bytes(buffer_offset,packed)
+
+        # advace the buffer position
+        buffer_consumed!(packed.length)
+        return self
+      end
+
+      #
+      # Reads packed data from a stream into the buffer of the unpacker.
+      #
+      # @param [IO] io
+      #   The stream to read the packed data from.
+      #
+      # @return [Boolean]
+      #   Specifies whether data was read from the stream, or if the stream
+      #   is empty.
+      #
+      def read(io)
+        reserve_buffer(@chunk_size)
+        result = io.read(buffer_capacity)
+
+        unless (result.nil? || result.empty?)
+          self << result
+          return true
+        else
+          return false
+        end
+      end
+
+      #
+      # Enumerates over each Msg Object from the buffer in the unpacker.
+      #
+      # If {#stream} is set, packed data will be read from it, when the
+      # buffer of the unpacker is fully unpacked.
+      #
+      # @yield [obj]
+      #   The given block will be passed each Msg Object.
+      #
+      # @yieldparam [MsgObject] obj
+      #   An unpacked Msg Object.
+      #
+      # @return [Unpacker]
+      #   The unpacker.
+      #
+      def each_object
+        loop do
+          ret = MsgPack.msgpack_unpacker_execute(self)
+
+          if ret > 0
+            # copy out the next Msg Object and release it's zone
+            obj = MsgPack.msgpack_unpacker_data(self)
+            zone = MsgPack.msgpack_unpacker_release_zone(self)
+
+            # reset the unpacker
+            MsgPack.msgpack_unpacker_reset(self)
+
+            yield obj
+
+            # free the zone now that we are done with it
+            MsgPack.msgpack_zone_free(zone)
+          elsif ret < 0
+            raise(ParseError,"a parse error occurred",caller)
+          else
+            unless (@stream && read(@stream))
+              break
+            end
+          end
+        end
+
+        return self
+      end
+
+      #
+      # Enumerates over each Msg Object from the buffer in the unpacker.
+      #
+      # @yield [obj]
+      #   The given block will be passed each unpacked Ruby Object, from
+      #   the buffer of the unpacker.
+      #
+      # @yieldparam [nil, true, false, Integer, Float, String, Array, Hash]  obj
+      #   A Ruby Object unpacked from the buffer of the unpacker.
+      #
+      # @return [Enumerator, Unpacker]
+      #   If no block is given, an enumerator will be returned.
+      #
+      def each
+        return enum_for(:each) unless block_given?
+
+        each_object do |obj|
+          yield obj.to_ruby
+        end
+      end
+
+      protected
+
+      #
+      # Reserves space in the buffer.
+      #
+      # @param [Integer] size
+      #   The number of bytes to reserve.
+      #
+      # @return [Boolean]
+      #   Specifies whether the size has been successfully reserved.
+      #
+      def reserve_buffer(size)
+        if self[:free] >= size
+          true
+        else
+          MsgPack.msgpack_unpacker_expand_buffer(self,size)
+        end
+      end
+
+      #
+      # The offset to empty space in the buffer.
+      #
+      # @return [Integer]
+      #   The number of bytes within the buffer.
+      #
+      def buffer_offset
+        self[:used]
+      end
+
+      #
+      # The remaining space of the buffer.
+      #
+      # @return [Integer]
+      #   The number of bytes free in the buffer.
+      #
+      def buffer_capacity
+        self[:free]
+      end
+
+      #
+      # Consums space in the buffer.
+      #
+      # @param [Integer] size
+      #   The number of bytes to be consumed.
+      #
+      # @return [nil]
+      #
+      def buffer_consumed!(size)
+        self[:used] += size
+        self[:free] -= size
+
+        return nil
+      end
+
+      #
+      # The size of the unparsed message in the buffer.
+      #
+      # @return [Integer]
+      #   The number of bytes that are unparsed.
+      #
+      def message_size
+        self[:parsed] - self[:off] + self[:used]
+      end
+
+      #
+      # The number of bytes that have been parsed in the buffer.
+      #
+      # @return [Integer]
+      #   The number of parsed bytes.
+      #
+      def parsed_size
+        self[:parsed]
+      end
+
+    end
+  end
+end