beefcake 0.1.0

data/lib/beefcake/buffer/decode.rb

@@ -0,0 +1,101 @@
+require 'beefcake/buffer/base'
+
+module Beefcake
+
+  class Buffer
+
+    def read_info
+      n    = read_uint64
+      fn   = n >> 3
+      wire = n & 0x7
+
+      [fn, wire]
+    end
+
+    def read_string
+      read(read_uint64)
+    end
+    alias :read_bytes :read_string
+
+    def read_fixed32
+      bytes = read(4)
+      bytes.unpack("V").first
+    end
+
+    def read_fixed64
+      bytes = read(8)
+      x, y = bytes.unpack("VV")
+      x + (y << 32)
+    end
+
+    def read_int64
+      n = read_uint64
+      if n > MaxInt64
+        n -= (1 << 64)
+      end
+      n
+    end
+    alias :read_int32 :read_int64
+
+    def read_uint64
+      n = shift = 0
+      while true
+        if shift >= 64
+          raise BufferOverflowError, "varint"
+        end
+        b = buf.slice!(0).ord
+        n |= ((b & 0x7F) << shift)
+        shift += 7
+        if (b & 0x80) == 0
+          return n
+        end
+      end
+    end
+    alias :read_uint32 :read_uint64
+
+    def read_sint64
+      decode_zigzag(read_uint64)
+    end
+    alias :read_sint32 :read_sint64
+
+    def read_sfixed32
+      decode_zigzag(read_fixed32)
+    end
+
+    def read_sfixed64
+      decode_zigzag(read_fixed64)
+    end
+
+    def read_float
+      bytes = read(4)
+      bytes.unpack("e").first
+    end
+
+    def read_double
+      bytes = read(8)
+      bytes.unpack("E").first
+    end
+
+    def read_bool
+      read_int32 != 0
+    end
+
+    def skip(wire)
+      case wire
+      when 0 then read_uint64
+      when 1 then read_fixed64
+      when 2 then read_string
+      when 5 then read_fixed32
+      end
+    end
+
+
+    private
+
+    def decode_zigzag(n)
+      (n >> 1) ^ -(n & 1)
+    end
+
+  end
+
+end

data/lib/beefcake/buffer/encode.rb

@@ -0,0 +1,115 @@
+require 'beefcake/buffer/base'
+
+module Beefcake
+
+  class Buffer
+
+    def append(type, val, fn)
+      if fn != 0
+        wire = Buffer.wire_for(type)
+        append_info(fn, wire)
+      end
+
+      __send__("append_#{type}", val)
+    end
+
+    def append_info(fn, wire)
+      self << ((fn << 3) | wire)
+    end
+
+    def append_fixed32(n, tag=false)
+      if n < MinUint32 or n > MaxUint32
+        raise OutOfRangeError, n
+      end
+
+      self << [n].pack("V")
+    end
+
+    def append_fixed64(n)
+      if n < MinUint64 or n > MaxUint64
+        raise OutOfRangeError, n
+      end
+
+      self << [n & 0xFFFFFFFF, n >> 32].pack("VV")
+    end
+
+    def append_int32(n)
+      if n < MinInt32 or n > MaxInt32
+        raise OutOfRangeError, n
+      end
+
+      append_int64(n)
+    end
+
+    def append_uint32(n)
+      if n < MinUint32 or n > MaxUint32
+        raise OutOfRangeError, n
+      end
+
+      append_uint64(n)
+    end
+
+    def append_int64(n)
+      if n < MinInt64 or n > MaxInt64
+        raise OutOfRangeError, n
+      end
+
+      if n < 0
+        n += (1 << 64)
+      end
+
+      append_uint64(n)
+    end
+
+    def append_sint32(n)
+      append_uint32((n << 1) ^ (n >> 31))
+    end
+
+    def append_sfixed32(n)
+      append_fixed32((n << 1) ^ (n >> 31))
+    end
+
+    def append_sint64(n)
+      append_uint64((n << 1) ^ (n >> 63))
+    end
+
+    def append_sfixed64(n)
+      append_fixed64((n << 1) ^ (n >> 63))
+    end
+
+    def append_uint64(n)
+      if n < MinUint64 or n > MaxUint64
+        raise OutOfRangeError, n
+      end
+
+      while true
+        bits = n & 0x7F
+        n >>= 7
+        if n == 0
+          return self << bits
+        end
+        self << (bits | 0x80)
+      end
+    end
+
+    def append_float(n)
+      self << [n].pack("e")
+    end
+
+    def append_double(n)
+      self << [n].pack("E")
+    end
+
+    def append_bool(n)
+      append_int64(n ? 1 : 0)
+    end
+
+    def append_string(s)
+      append_uint64(s.length)
+      self << s
+    end
+    alias :append_bytes :append_string
+
+  end
+
+end

data/test/buffer_decode_test.rb

@@ -0,0 +1,114 @@
+require 'beefcake/buffer'
+
+class BufferDecodeTest < Test::Unit::TestCase
+
+  B = Beefcake::Buffer
+
+  def setup
+    @buf = B.new
+  end
+
+  def test_read_info
+    @buf.append_info(1, 2)
+    assert_equal [1, 2], @buf.read_info
+
+    @buf.append_info(2, 5)
+    assert_equal [2, 5], @buf.read_info
+  end
+
+  def test_read_string
+    @buf.append_string("testing")
+    assert_equal "testing", @buf.read_string
+  end
+
+  def test_read_fixed32
+    @buf.append_fixed32(123)
+    assert_equal 123, @buf.read_fixed32
+  end
+
+  def test_read_fixed64
+    @buf.append_fixed64(456)
+    assert_equal 456, @buf.read_fixed64
+  end
+
+  def test_read_uint32
+    @buf.append_uint32(1)
+    assert_equal 1, @buf.read_uint32
+  end
+
+  def test_read_int32
+    @buf.append_int32(999)
+    assert_equal 999, @buf.read_int32
+
+    @buf.append_int32(-999)
+    assert_equal -999, @buf.read_int32
+  end
+
+  def test_read_int64
+    @buf.append_int64(999)
+    assert_equal 999, @buf.read_int64
+
+    @buf.append_int64(-999)
+    assert_equal -999, @buf.read_int64
+  end
+
+  def test_read_uint64
+    @buf.append_uint64(1)
+    assert_equal 1, @buf.read_uint64
+  end
+
+  def test_read_float
+    @buf.append_float(0.5)
+    assert_equal 0.5, @buf.read_float
+  end
+
+  def test_read_double
+    @buf.append_double(Math::PI)
+    assert_equal Math::PI, @buf.read_double
+  end
+
+  def test_read_bool
+    @buf.append_bool(true)
+    assert_equal true, @buf.read_bool
+
+    @buf.append_bool(false)
+    assert_equal false, @buf.read_bool
+  end
+
+  def test_read_sint32
+    @buf.append_sint32(B::MinInt32)
+    assert_equal B::MinInt32, @buf.read_sint32
+
+    @buf.buf = ""
+    @buf.append_sint32(B::MaxInt32)
+    assert_equal B::MaxInt32, @buf.read_sint32
+  end
+
+  def test_read_sfixed32
+    @buf.append_sfixed32(B::MinInt32)
+    assert_equal B::MinInt32, @buf.read_sfixed32
+
+    @buf.buf = ""
+    @buf.append_sfixed32(B::MaxInt32)
+    assert_equal B::MaxInt32, @buf.read_sfixed32
+  end
+
+  def test_read_sint64
+    @buf.append_sint64(B::MinInt64)
+    assert_equal B::MinInt64, @buf.read_sint64
+
+    @buf.buf = ""
+    @buf.append_sint64(B::MaxInt64)
+    assert_equal B::MaxInt64, @buf.read_sint64
+  end
+
+  def test_read_sfixed64
+    @buf.append_sfixed64(B::MinInt64)
+    assert_equal B::MinInt64, @buf.read_sfixed64
+
+    @buf.buf = ""
+    @buf.append_sfixed64(B::MaxInt64)
+    assert_equal B::MaxInt64, @buf.read_sfixed64
+  end
+
+end

data/test/buffer_encode_test.rb

@@ -0,0 +1,222 @@
+require 'beefcake/buffer/encode'
+
+class BufferEncodeTest < Test::Unit::TestCase
+
+  B = Beefcake::Buffer
+
+  def setup
+    @buf = B.new
+  end
+
+  def test_append_info
+    @buf.append_info(1, 0)
+    assert_equal "\010", @buf.to_s
+
+    @buf.buf = ""
+    @buf.append_info(2, 1)
+    assert_equal "\021", @buf.to_s
+  end
+
+  def test_append_string
+    @buf.append_string("testing")
+    assert_equal "\007testing", @buf.to_s
+  end
+
+  def test_append_fixed32
+    @buf.append_fixed32(1)
+    assert_equal "\001\0\0\0", @buf.to_s
+
+    @buf.buf = ""
+    @buf.append_fixed32(B::MinUint32)
+    assert_equal "\0\0\0\0", @buf.to_s
+
+    @buf.buf = ""
+    @buf.append_fixed32(B::MaxUint32)
+    assert_equal "\377\377\377\377", @buf.to_s
+
+    assert_raises B::OutOfRangeError do
+      @buf.append_fixed32(B::MinUint32 - 1)
+    end
+
+    assert_raises B::OutOfRangeError do
+      @buf.append_fixed32(B::MaxUint32 + 1)
+    end
+  end
+
+  def test_append_fixed64
+    @buf.append_fixed64(1)
+    assert_equal "\001\0\0\0\0\0\0\0", @buf.to_s
+
+    @buf.buf = ""
+    @buf.append_fixed64(B::MinUint64)
+    assert_equal "\000\0\0\0\0\0\0\0", @buf.to_s
+
+    @buf.buf = ""
+    @buf.append_fixed64(B::MaxUint64)
+    assert_equal "\377\377\377\377\377\377\377\377", @buf.to_s
+
+    assert_raises B::OutOfRangeError do
+      @buf.append_fixed64(B::MinUint64 - 1)
+    end
+
+    assert_raises B::OutOfRangeError do
+      @buf.append_fixed64(B::MaxUint64 + 1)
+    end
+  end
+
+  def test_append_uint32
+    @buf.append_uint32(1)
+    assert_equal "\001", @buf.to_s
+
+    @buf.buf = ""
+    @buf.append_uint32(B::MinUint32)
+    assert_equal "\000", @buf.to_s
+
+    @buf.buf = ""
+    @buf.append_uint32(B::MaxUint32)
+    assert_equal "\377\377\377\377\017", @buf.to_s
+
+    assert_raises B::OutOfRangeError do
+      @buf.append_uint32(B::MinUint32 - 1)
+    end
+
+    assert_raises B::OutOfRangeError do
+      @buf.append_uint32(B::MaxUint32 + 1)
+    end
+  end
+
+  def test_append_int32
+    @buf.append_int32(1)
+    assert_equal "\001", @buf.to_s
+
+    @buf.buf = ""
+    @buf.append_int32(-1)
+    assert_equal "\377\377\377\377\377\377\377\377\377\001", @buf.to_s
+
+    @buf.buf = ""
+    @buf.append_int32(B::MinInt32)
+    assert_equal "\200\200\200\200\370\377\377\377\377\001", @buf.to_s
+
+    @buf.buf = ""
+    @buf.append_int32(B::MaxInt32)
+    assert_equal "\377\377\377\377\007", @buf.to_s
+
+    assert_raises B::OutOfRangeError do
+      @buf.append_int32(B::MinInt32 - 1)
+    end
+
+    assert_raises B::OutOfRangeError do
+      @buf.append_int32(B::MaxInt32 + 1)
+    end
+  end
+
+  def test_append_int64
+    @buf.append_int64(1)
+    assert_equal "\001", @buf.to_s
+
+    @buf.buf = ""
+    @buf.append_int64(-1)
+    assert_equal "\377\377\377\377\377\377\377\377\377\001", @buf.to_s
+
+    @buf.buf = ""
+    @buf.append_int64(B::MinInt64)
+    assert_equal "\200\200\200\200\200\200\200\200\200\001", @buf.to_s
+
+    @buf.buf = ""
+    @buf.append_int64(B::MaxInt64)
+    assert_equal "\377\377\377\377\377\377\377\377\177", @buf.to_s
+
+    assert_raises B::OutOfRangeError do
+      @buf.append_int64(B::MinInt64 - 1)
+    end
+
+    assert_raises B::OutOfRangeError do
+      @buf.append_int64(B::MaxInt64 + 1)
+    end
+  end
+
+  def test_append_uint64
+    @buf.append_uint64(1)
+    assert_equal "\001", @buf.to_s
+
+    @buf.buf = ""
+    @buf.append_uint64(B::MinUint64)
+    assert_equal "\000", @buf.to_s
+
+    @buf.buf = ""
+    @buf.append_uint64(B::MaxUint64)
+    assert_equal "\377\377\377\377\377\377\377\377\377\001", @buf.to_s
+
+    assert_raises B::OutOfRangeError do
+      @buf.append_uint64(B::MinUint64 - 1)
+    end
+
+    assert_raises B::OutOfRangeError do
+      @buf.append_uint64(B::MaxUint64 + 1)
+    end
+  end
+
+  def test_append_float
+    @buf.append_float(3.14)
+    assert_equal "\303\365H@", @buf.to_s
+  end
+
+  def test_append_double
+    @buf.buf = ""
+    @buf.append_float(Math::PI)
+    assert_equal "\333\017I@", @buf.to_s
+  end
+
+  def test_append_bool
+    @buf.append_bool(true)
+    @buf.append_bool(false)
+    assert_equal "\001\000", @buf.to_s
+  end
+
+  def test_append_sint32
+    @buf.append_sint32(-2)
+    assert_equal "\003", @buf.to_s
+
+    @buf.buf = ""
+    @buf.append_sint32(B::MaxInt32)
+    assert_equal "\376\377\377\377\017", @buf.to_s
+
+    @buf.buf = ""
+    @buf.append_sint32(B::MinInt32)
+    assert_equal "\377\377\377\377\017", @buf.to_s
+  end
+
+  def test_append_sfixed32
+    @buf.append_sfixed32(-2)
+    assert_equal "\003\000\000\000", @buf.to_s
+  end
+
+  def test_append_sint64
+    @buf.append_sint64(-2)
+    assert_equal "\003", @buf.to_s
+
+    @buf.buf = ""
+    @buf.append_sint64(B::MaxInt64)
+    assert_equal "\376\377\377\377\377\377\377\377\377\001", @buf.to_s
+
+    @buf.buf = ""
+    @buf.append_sint64(B::MinInt64)
+    assert_equal "\377\377\377\377\377\377\377\377\377\001", @buf.to_s
+  end
+
+  def test_append_sfixed64
+    @buf.append_sfixed64(B::MaxInt64)
+    assert_equal "\376\377\377\377\377\377\377\377", @buf.to_s
+  end
+
+  def test_append_string
+    @buf.append_string("testing")
+    assert_equal "\007testing", @buf.to_s
+  end
+
+  def test_append_bytes
+    @buf.append_bytes("testing")
+    assert_equal "\007testing", @buf.to_s
+  end
+
+end