amq-protocol 0.7.0.beta2 → 0.7.0

data/Gemfile

@@ -25,4 +25,5 @@ end
 group(:test) do
   gem "rspec", ">=2.0.0"
   gem "simplecov", :platform => :mri_19
+  gem "effin_utf8"
 end

data/lib/amq/protocol/table.rb

@@ -1,6 +1,9 @@
 # encoding: binary
 
 require "amq/protocol/client"
+require "amq/protocol/type_constants"
+require "amq/protocol/table_value_encoder"
+require "amq/protocol/table_value_decoder"
 
 # We will need to introduce concept of mappings, because
 # AMQP 0.9, 0.9.1 and RabbitMQ uses different letters for entities
@@ -8,146 +11,129 @@ require "amq/protocol/client"
 module AMQ
   module Protocol
     class Table
+
+      #
+      # Behaviors
+      #
+
+      include TypeConstants
+
+
+      #
+      # API
+      #
+
       class InvalidTableError < StandardError
         def initialize(key, value)
           super("Invalid table value on key #{key}: #{value.inspect} (#{value.class})")
         end
       end
 
-      TYPE_STRING = 'S'.freeze
-      TYPE_INTEGER = 'I'.freeze
-      TYPE_HASH = 'F'.freeze
-      TYPE_TIME = 'T'.freeze
-      TYPE_DECIMAL = 'D'.freeze
-      TYPE_BOOLEAN = 't'.freeze
-      TYPE_SIGNED_8BIT = 'b'.freeze
-      TYPE_SIGNED_16BIT = 's'.freeze
-      TYPE_SIGNED_64BIT = 'l'.freeze
-      TYPE_32BIT_FLOAT = 'f'.freeze
-      TYPE_64BIT_FLOAT = 'd'.freeze
-      TYPE_VOID = 'V'.freeze
-      TYPE_BYTE_ARRAY = 'x'.freeze
-      TEN = '10'.freeze
-
-      BOOLEAN_TRUE  = "\x01".freeze
-      BOOLEAN_FALSE = "\x00".freeze
-
 
       def self.encode(table)
         buffer = String.new
+
         table ||= {}
+
         table.each do |key, value|
           key = key.to_s # it can be a symbol as well
           buffer << key.bytesize.chr + key
 
           case value
-          when String then
-            buffer << TYPE_STRING
-            buffer << [value.bytesize].pack(PACK_UINT32)
-            buffer << value
-          when Integer then
-            buffer << TYPE_INTEGER
-            buffer << [value].pack(PACK_UINT32)
-          when Float then
-            buffer << TYPE_64BIT_FLOAT
-            buffer << [value].pack(PACK_64BIT_FLOAT)
-          when true, false then
-            buffer << TYPE_BOOLEAN
-            buffer << (value ? BOOLEAN_TRUE : BOOLEAN_FALSE)
           when Hash then
-            buffer << TYPE_HASH # TODO: encoding support
+            buffer << TYPE_HASH
             buffer << self.encode(value)
-          when Time then
-            buffer << TYPE_TIME
-            buffer << [value.to_i].pack(PACK_INT64).reverse # FIXME: there has to be a more efficient way
-          when nil then
-            buffer << TYPE_VOID
           else
-            # We don't want to require these libraries.
-            if defined?(BigDecimal) && value.is_a?(BigDecimal)
-              buffer << TYPE_DECIMAL
-              if value.exponent < 0
-                decimals = -value.exponent
-                # p [value.exponent] # normalize
-                raw = (value * (decimals ** 10)).to_i
-                #pieces.append(struct.pack('>cBI', 'D', decimals, raw)) # byte integer
-                buffer << [decimals + 1, raw].pack(PACK_UCHAR_UINT32) # somewhat like floating point
-              else
-                # per spec, the "decimals" octet is unsigned (!)
-                buffer << [0, value.to_i].pack(PACK_UCHAR_UINT32)
-              end
-            else
-              raise InvalidTableError.new(key, value)
-            end
+            buffer << TableValueEncoder.encode(value)
           end
         end
 
         [buffer.bytesize].pack(PACK_UINT32) + buffer
       end
 
-      def self.length(data)
-        data.unpack(PACK_UINT32).first
-      end
+
+
 
       def self.decode(data)
-        table = Hash.new
-        size = data.unpack(PACK_UINT32).first
-        offset = 4
-        while offset < size
-          key_length = data.slice(offset, 1).unpack(PACK_CHAR).first
-          offset += 1
-          key = data.slice(offset, key_length)
-          offset += key_length
-          type = data.slice(offset, 1)
-          offset += 1
-
-          case type
-          when TYPE_STRING
-            length = data.slice(offset, 4).unpack(PACK_UINT32).first
-            offset += 4
-            value = data.slice(offset, length)
-            offset += length
-          when TYPE_INTEGER
-            value = data.slice(offset, 4).unpack(PACK_UINT32).first
-            offset += 4
-          when TYPE_DECIMAL
-            decimals, raw = data.slice(offset, 5).unpack(PACK_UCHAR_UINT32)
-            offset += 5
-            value = BigDecimal.new(raw.to_s) * (BigDecimal.new(TEN) ** -decimals)
-          when TYPE_TIME
-            timestamp = data.slice(offset, 8).unpack(PACK_UINT32_X2).last
-            value = Time.at(timestamp)
-            offset += 8
-          when TYPE_HASH
-            length = data.slice(offset, 4).unpack(PACK_UINT32).first
-            value = self.decode(data.slice(offset, length + 4))
-            offset += 4 + length
-          when TYPE_BOOLEAN
-            value  = data.slice(offset, 2)
-            integer = value.unpack(PACK_CHAR).first # 0 or 1
-            value = (integer == 1)
-            offset += 1
-            value
-          when TYPE_SIGNED_8BIT then raise NotImplementedError.new
-          when TYPE_SIGNED_16BIT then raise NotImplementedError.new
-          when TYPE_SIGNED_64BIT then raise NotImplementedError.new
-          when TYPE_32BIT_FLOAT then
-            value = data.slice(offset, 4).unpack(PACK_32BIT_FLOAT).first
-            offset += 4
-          when TYPE_64BIT_FLOAT then
-            value = data.slice(offset, 8).unpack(PACK_64BIT_FLOAT).first
-            offset += 8
-          when TYPE_VOID
-            value = nil
-          when TYPE_BYTE_ARRAY
-          else
-            raise "Not a valid type: #{type.inspect}\nData: #{data.inspect}\nUnprocessed data: #{data[offset..-1].inspect}\nOffset: #{offset}\nTotal size: #{size}\nProcessed data: #{table.inspect}"
-          end
-          table[key] = value
+        table        = Hash.new
+        table_length = data.unpack(PACK_UINT32).first
+
+        return table if table_length.zero?
+
+        offset       = 4
+        while offset <= table_length
+          key, offset  = decode_table_key(data, offset)
+          type, offset = TableValueDecoder.decode_value_type(data, offset)
+
+          table[key] = case type
+                       when TYPE_STRING
+                         v, offset = TableValueDecoder.decode_string(data, offset)
+                         v
+                       when TYPE_INTEGER
+                         v, offset = TableValueDecoder.decode_integer(data, offset)
+                         v
+                       when TYPE_DECIMAL
+                         v, offset = TableValueDecoder.decode_big_decimal(data, offset)
+                         v
+                       when TYPE_TIME
+                         v, offset = TableValueDecoder.decode_time(data, offset)
+                         v
+                       when TYPE_HASH
+                         v, offset = TableValueDecoder.decode_hash(data, offset)
+                         v
+                       when TYPE_BOOLEAN
+                         v, offset = TableValueDecoder.decode_boolean(data, offset)
+                         v
+                       when TYPE_SIGNED_8BIT  then raise NotImplementedError.new
+                       when TYPE_SIGNED_16BIT then raise NotImplementedError.new
+                       when TYPE_SIGNED_64BIT then raise NotImplementedError.new
+                       when TYPE_32BIT_FLOAT then
+                         v, offset = TableValueDecoder.decode_32bit_float(data, offset)
+                         v
+                       when TYPE_64BIT_FLOAT then
+                         v, offset = TableValueDecoder.decode_64bit_float(data, offset)
+                         v
+                       when TYPE_VOID
+                         nil
+                       when TYPE_ARRAY
+                         v, offset = TableValueDecoder.decode_array(data, offset)
+                         v
+                       else
+                         raise ArgumentError, "Not a valid type: #{type.inspect}\nData: #{data.inspect}\nUnprocessed data: #{data[offset..-1].inspect}\nOffset: #{offset}\nTotal size: #{table_length}\nProcessed data: #{table.inspect}"
+                       end
         end
 
         table
+      end # self.decode
+
+
+      def self.length(data)
+        data.unpack(PACK_UINT32).first
       end
-    end
-  end
-end
+
+
+      def self.hash_size(value)
+        acc = 0
+        value.each do |k, v|
+          acc += (1 + k.to_s.bytesize)
+          acc += TableValueEncoder.field_value_size(v)
+        end
+
+        acc
+      end # self.hash_size(value)
+
+
+      def self.decode_table_key(data, offset)
+        key_length = data.slice(offset, 1).unpack(PACK_CHAR).first
+        offset += 1
+        key = data.slice(offset, key_length)
+        offset += key_length
+
+        [key, offset]
+      end # self.decode_table_key(data, offset)
+
+
+
+    end # Table
+  end # Protocol
+end # AMQ

data/lib/amq/protocol/table_value_decoder.rb

@@ -0,0 +1,151 @@
+# encoding: binary
+
+require "amq/protocol/client"
+require "amq/protocol/type_constants"
+require "amq/protocol/table"
+
+module AMQ
+  module Protocol
+
+    class TableValueDecoder
+
+      #
+      # Behaviors
+      #
+
+      include TypeConstants
+
+
+      #
+      # API
+      #
+
+      def self.decode_array(data, initial_offset)
+        array_length = data.slice(initial_offset, 4).unpack(PACK_UINT32).first
+
+        ary    = Array.new
+        offset = initial_offset + 4
+
+        while offset <= (initial_offset + array_length)
+          type, offset = decode_value_type(data, offset)
+
+          i = case type
+                 when TYPE_STRING
+                   v, offset = decode_string(data, offset)
+                   v
+                 when TYPE_INTEGER
+                   v, offset = decode_integer(data, offset)
+                   v
+                 when TYPE_DECIMAL
+                   v, offset = decode_big_decimal(data, offset)
+                   v
+                 when TYPE_TIME
+                   v, offset = decode_time(data, offset)
+                   v
+                 when TYPE_HASH
+                   v, offset = decode_hash(data, offset)
+                   v
+                 when TYPE_BOOLEAN
+                   v, offset = decode_boolean(data, offset)
+                   v
+                 when TYPE_SIGNED_8BIT then raise NotImplementedError.new
+                 when TYPE_SIGNED_16BIT then raise NotImplementedError.new
+                 when TYPE_SIGNED_64BIT then raise NotImplementedError.new
+                 when TYPE_32BIT_FLOAT then
+                   v, offset = decode_32bit_float(data, offset)
+                   v
+                 when TYPE_64BIT_FLOAT then
+                   v, offset = decode_64bit_float(data, offset)
+                   v
+                 when TYPE_VOID
+                   nil
+                 when TYPE_ARRAY
+                   v, offset = TableValueDecoder.decode_array(data, offset)
+                   v
+                 else
+                   raise ArgumentError.new("unsupported type: #{type.inspect}")
+                 end
+
+          ary << i
+        end
+
+
+        [ary, initial_offset + array_length + 4]
+      end # self.decode_array(data, initial_offset)
+
+
+      def self.decode_string(data, offset)
+        length = data.slice(offset, 4).unpack(PACK_UINT32).first
+        offset += 4
+        v = data.slice(offset, length)
+        offset += length
+
+        [v, offset]
+      end # self.decode_string(data, offset)
+
+
+      def self.decode_integer(data, offset)
+        v = data.slice(offset, 4).unpack(PACK_UINT32).first
+        offset += 4
+
+        [v, offset]
+      end # self.decode_integer(data, offset)
+
+
+      def self.decode_big_decimal(data, offset)
+        decimals, raw = data.slice(offset, 5).unpack(PACK_UCHAR_UINT32)
+        offset += 5
+        v = BigDecimal.new(raw.to_s) * (BigDecimal.new(TEN) ** -decimals)
+
+        [v, offset]
+      end # self.decode_big_decimal(data, offset)
+
+
+      def self.decode_time(data, offset)
+        timestamp = data.slice(offset, 8).unpack(PACK_UINT32_X2).last
+        v = Time.at(timestamp)
+        offset += 8
+
+        [v, offset]
+      end # self.decode_time(data, offset)
+
+
+      def self.decode_boolean(data, offset)
+        integer = data.slice(offset, 2).unpack(PACK_CHAR).first # 0 or 1
+        offset += 1
+        [(integer == 1), offset]
+      end # self.decode_boolean(data, offset)
+
+
+      def self.decode_32bit_float(data, offset)
+        v = data.slice(offset, 4).unpack(PACK_32BIT_FLOAT).first
+        offset += 4
+
+        [v, offset]
+      end # self.decode_32bit_float(data, offset)
+
+
+      def self.decode_64bit_float(data, offset)
+        v = data.slice(offset, 8).unpack(PACK_64BIT_FLOAT).first
+        offset += 8
+
+        [v, offset]
+      end # self.decode_64bit_float(data, offset)
+
+
+      def self.decode_value_type(data, offset)
+        [data.slice(offset, 1), offset + 1]
+      end # self.decode_value_type(data, offset)
+
+
+
+      def self.decode_hash(data, offset)
+        length = data.slice(offset, 4).unpack(PACK_UINT32).first
+        v = Table.decode(data.slice(offset, length + 4))
+        offset += 4 + length
+
+        [v, offset]
+      end # self.decode_hash(data, offset)
+    end # TableValueDecoder
+  end # Protocol
+end # AMQ

data/lib/amq/protocol/table_value_encoder.rb

@@ -0,0 +1,117 @@
+# encoding: binary
+
+require "amq/protocol/client"
+require "amq/protocol/type_constants"
+require "amq/protocol/table"
+
+module AMQ
+  module Protocol
+
+    class TableValueEncoder
+
+      #
+      # Behaviors
+      #
+
+      include TypeConstants
+
+      #
+      # API
+      #
+
+      def self.encode(value)
+        accumulator = String.new
+
+        case value
+        when String then
+          accumulator << TYPE_STRING
+          accumulator << [value.bytesize].pack(PACK_UINT32)
+          accumulator << value
+        when Symbol then
+          v = value.to_s
+          accumulator << TYPE_STRING
+          accumulator << [v.bytesize].pack(PACK_UINT32)
+          accumulator << v
+        when Integer then
+          accumulator << TYPE_INTEGER
+          accumulator << [value].pack(PACK_UINT32)
+        when Float then
+          accumulator << TYPE_64BIT_FLOAT
+          accumulator << [value].pack(PACK_64BIT_FLOAT)
+        when true, false then
+          accumulator << TYPE_BOOLEAN
+          accumulator << (value ? BOOLEAN_TRUE : BOOLEAN_FALSE)
+        when Time then
+          accumulator << TYPE_TIME
+          accumulator << [value.to_i].pack(PACK_INT64).reverse # FIXME: there has to be a more efficient way
+        when nil then
+          accumulator << TYPE_VOID
+        when Array then
+          accumulator << TYPE_ARRAY
+          accumulator << [self.array_size(value)].pack(PACK_UINT32)
+
+          value.each { |v| accumulator << self.encode(v) }
+        when Hash then
+          accumulator << TYPE_HASH
+          accumulator << AMQ::Protocol::Table.encode(value)
+        else
+          # We don't want to require these libraries.
+          if defined?(BigDecimal) && value.is_a?(BigDecimal)
+            accumulator << TYPE_DECIMAL
+            if value.exponent < 0
+              decimals = -value.exponent
+              raw = (value * (decimals ** 10)).to_i
+              accumulator << [decimals + 1, raw].pack(PACK_UCHAR_UINT32) # somewhat like floating point
+            else
+              # per spec, the "decimals" octet is unsigned (!)
+              accumulator << [0, value.to_i].pack(PACK_UCHAR_UINT32)
+            end
+          else
+            raise ArgumentError.new("Unsupported value #{value.inspect} of type #{value.class.name}")
+          end # if
+        end # case
+
+        accumulator
+      end # self.encode(value)
+
+
+
+
+      def self.field_value_size(value)
+        # the type tag takes 1 byte
+        acc = 1
+
+        case value
+        when String then
+          acc += (value.bytesize + 4)
+        when Integer then
+          acc += 4
+        when Float then
+          acc += 8
+        when Time, DateTime then
+          acc += 8
+        when true, false then
+          acc += 1
+        when nil then
+          # nothing, type tag alone is enough
+        when Hash then
+          acc += (4 + Table.hash_size(value))
+        when Array then
+          acc += (4 + self.array_size(value))
+        end
+
+        acc
+      end # self.field_value_size(value)
+
+
+      def self.array_size(value)
+        acc = 0
+        value.each { |v| acc += self.field_value_size(v) }
+
+        acc
+      end # self.array_size(value)
+
+    end # TableValueEncoder
+
+  end # Protocol
+end # AMQ

data/lib/amq/protocol/type_constants.rb

@@ -0,0 +1,26 @@
+# encoding: binary
+
+module AMQ
+  module Protocol
+    module TypeConstants
+      TYPE_STRING       = 'S'.freeze
+      TYPE_INTEGER      = 'I'.freeze
+      TYPE_HASH         = 'F'.freeze
+      TYPE_TIME         = 'T'.freeze
+      TYPE_DECIMAL      = 'D'.freeze
+      TYPE_BOOLEAN      = 't'.freeze
+      TYPE_SIGNED_8BIT  = 'b'.freeze
+      TYPE_SIGNED_16BIT = 's'.freeze
+      TYPE_SIGNED_64BIT = 'l'.freeze
+      TYPE_32BIT_FLOAT  = 'f'.freeze
+      TYPE_64BIT_FLOAT  = 'd'.freeze
+      TYPE_VOID         = 'V'.freeze
+      TYPE_BYTE_ARRAY   = 'x'.freeze
+      TYPE_ARRAY        = 'A'.freeze
+      TEN               = '10'.freeze
+
+      BOOLEAN_TRUE  = "\x01".freeze
+      BOOLEAN_FALSE = "\x00".freeze
+    end # TypeConstants
+  end # Protocol
+end # AMQ

data/lib/amq/protocol/version.rb

@@ -1,5 +1,5 @@
 module AMQ
   module Protocol
-    VERSION = "0.7.0.beta2"
+    VERSION = "0.7.0"
   end # Protocol
 end # AMQ

data/spec/amq/protocol/table_spec.rb

@@ -84,7 +84,7 @@ module AMQ
         end # DATA.each
 
 
-        it "is capable of decoding booleans" do
+        it "is capable of decoding boolean table values" do
           input1   = { "boolval" => true }
           Table.decode(Table.encode(input1)).should == input1
 
@@ -95,6 +95,76 @@ module AMQ
 
 
 
+        it "is capable of decoding string table values" do
+          input   = { "stringvalue" => "string" }
+          Table.decode(Table.encode(input)).should == input
+        end
+
+
+
+        it "is capable of decoding integer table values" do
+          input   = { "intvalue" => 10 }
+          Table.decode(Table.encode(input)).should == input
+        end
+
+
+
+        it "is capable of decoding long table values" do
+          input   = { "longvalue" => 912598613 }
+          Table.decode(Table.encode(input)).should == input
+        end
+
+
+
+        it "is capable of decoding float table values" do
+          input   = { "floatvalue" => 100.0 }
+          Table.decode(Table.encode(input)).should == input
+        end
+
+
+
+        it "is capable of decoding time table values" do
+          input   = { "intvalue" => Time.parse("2011-07-14 01:17:46 +0400") }
+          Table.decode(Table.encode(input)).should == input
+        end
+
+
+
+        it "is capable of decoding empty hash table values" do
+          input   = { "hashvalue" => Hash.new }
+          Table.decode(Table.encode(input)).should == input
+        end
+
+
+
+        xit "is capable of decoding empty array table values" do
+          input   = { "arrayvalue" => Array.new }
+          Table.decode(Table.encode(input)).should == input
+        end
+
+
+        xit "is capable of decoding single string value array table values" do
+          input   = { "arrayvalue" => ["amq-protocol"] }
+          Table.decode(Table.encode(input)).should == input
+        end
+
+
+
+        it "is capable of decoding simple nested hash table values" do
+          input   = { "hashvalue" => { "a" => "b" } }
+          Table.decode(Table.encode(input)).should == input
+        end
+
+
+
+        it "is capable of decoding nil table values" do
+          input   = { "nil" => nil }
+          Table.decode(Table.encode(input)).should == input
+        end
+
+
+
+
         it "is capable of decoding tables" do
           input   = {
             "boolval"      => true,
@@ -108,6 +178,56 @@ module AMQ
           Table.decode(Table.encode(input)).should == input
         end
 
+
+
+        it "is capable of decoding deeply nested tables" do
+          input   = {
+            "hashval"    => {
+              "protocol" => {
+                "name"  => "AMQP",
+                "major" => 0,
+                "minor" => "9",
+                "rev"   => 1.0,
+                "spec"  => {
+                  "url"  => "http://bit.ly/hw2ELX",
+                  "utf8" => "à bientôt"
+                }
+              },
+              "true"     => true,
+              "false"    => false,
+              "nil"      => nil
+            }
+          }
+          Table.decode(Table.encode(input)).should == input
+        end
+
+
+
+        it "is capable of decoding array values in tables" do
+          input1   = {
+            "arrayval1" => [198, 3, 77, 8.0, ["inner", "array", { "oh" => "well", "it" => "should work", "3" => 6 }], "two", { "a" => "value", "is" => nil }],
+            "arrayval2" => [198, 3, 77, "two", { "a" => "value", "is" => nil }, 8.0, ["inner", "array", { "oh" => "well", "it" => "should work", "3" => 6 }]]
+          }
+          Table.decode(Table.encode(input1)).should == input1
+
+
+          input2 = {
+                       "coordinates" => {
+                         "latitude"  => 59.35,
+                         "longitude" => 18.066667
+                       },
+                       "time"         => @now,
+                       "participants" => 11,
+                       "venue"        => "Stockholm",
+                       "true_field"   => true,
+                       "false_field"  => false,
+                       "nil_field"    => nil,
+                       "ary_field"    => ["one", 2.0, 3]
+                     }
+
+          Table.decode(Table.encode(input2)).should == input2
+        end
+
       end # describe
     end
   end

data/spec/amq/protocol/value_decoder_spec.rb

@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*-
+require File.expand_path('../../../spec_helper', __FILE__)
+
+require 'time'
+require "amq/protocol/table_value_decoder"
+
+module AMQ
+  module Protocol
+    describe TableValueDecoder do
+
+      it "is capable of decoding basic arrays TableValueEncoder encodes" do
+        input1 = [1, 2, 3]
+
+        value, offset = described_class.decode_array(TableValueEncoder.encode(input1), 1)
+        value.size.should == 3
+        value.first.should == 1
+        value.should == input1
+
+
+
+        input2 = ["one", 2, "three"]
+
+        value, offset = described_class.decode_array(TableValueEncoder.encode(input2), 1)
+        value.size.should == 3
+        value.first.should == "one"
+        value.should == input2
+
+
+
+        input3 = ["one", 2, "three", 4.0, 5000000.0]
+
+        value, offset = described_class.decode_array(TableValueEncoder.encode(input3), 1)
+        value.size.should == 5
+        value.last.should == 5000000.0
+        value.should == input3
+      end
+
+
+
+      it "is capable of decoding arrays TableValueEncoder encodes" do
+        input1 = [{ "one" => 2 }, 3]
+        data1  = TableValueEncoder.encode(input1)
+
+        # puts(TableValueEncoder.encode({ "one" => 2 }).inspect)
+        # puts(TableValueEncoder.encode(input1).inspect)
+
+
+        value, offset = described_class.decode_array(data1, 1)
+        value.size.should == 2
+        value.first.should == Hash["one" => 2]
+        value.should == input1
+
+
+
+        input2 = ["one", 2, { "three" => { "four" => 5.0 } }]
+
+        value, offset = described_class.decode_array(TableValueEncoder.encode(input2), 1)
+        value.size.should == 3
+        value.last["three"]["four"].should == 5.0
+        value.should == input2
+      end
+
+
+    end
+  end
+end

data/spec/amq/protocol/value_encoder_spec.rb

@@ -0,0 +1,138 @@
+# -*- coding: utf-8 -*-
+require File.expand_path('../../../spec_helper', __FILE__)
+
+require 'time'
+require "amq/protocol/table_value_encoder"
+
+module AMQ
+  module Protocol
+    describe TableValueEncoder do
+
+
+      it "calculates size of string field values" do
+        described_class.field_value_size("amqp").should == 9
+        described_class.encode("amqp").bytesize.should == 9
+
+        described_class.field_value_size("amq-protocol").should == 17
+        described_class.encode("amq-protocol").bytesize.should == 17
+
+        described_class.field_value_size("à bientôt").should == 16
+        described_class.encode("à bientôt").bytesize.should == 16
+      end
+
+      it "calculates size of integer field values" do
+        described_class.field_value_size(10).should == 5
+        described_class.encode(10).bytesize.should == 5
+      end
+
+      it "calculates size of float field values (considering them to be 64-bit)" do
+        described_class.field_value_size(10.0).should == 9
+        described_class.encode(10.0).bytesize.should == 9
+
+        described_class.field_value_size(120000.0).should == 9
+        described_class.encode(120000.0).bytesize.should == 9
+      end
+
+      it "calculates size of boolean field values" do
+        described_class.field_value_size(true).should == 2
+        described_class.encode(true).bytesize.should == 2
+
+        described_class.field_value_size(false).should == 2
+        described_class.encode(false).bytesize.should == 2
+      end
+
+      it "calculates size of void field values" do
+        described_class.field_value_size(nil).should == 1
+        described_class.encode(nil).bytesize.should == 1
+      end
+
+      it "calculates size of time field values" do
+        t = Time.parse("2011-07-14 01:17:46 +0400")
+
+        described_class.field_value_size(t).should == 9
+        described_class.encode(t).bytesize.should == 9
+      end
+
+
+      it "calculates size of basic table field values" do
+        input1   = { "key" => "value" }
+        described_class.field_value_size(input1).should == 19
+        described_class.encode(input1).bytesize.should == 19
+
+
+        input2   = { "intval" => 1 }
+        described_class.field_value_size(input2).should == 17
+        described_class.encode(input2).bytesize.should == 17
+
+
+        input3   = { "intval" => 1, "key" => "value" }
+        described_class.field_value_size(input3).should == 31
+        described_class.encode(input3).bytesize.should == 31
+      end
+
+
+      it "calculates size of table field values" do
+        input1   = {
+          "hashval"    => {
+            "protocol" => {
+              "name"  => "AMQP",
+              "major" => 0,
+              "minor" => "9",
+              "rev"   => 1.0,
+              "spec"  => {
+                "url"  => "http://bit.ly/hw2ELX",
+                "utf8" => one_point_eight? ? "à bientôt" : "à bientôt".force_encoding(::Encoding::ASCII_8BIT)
+              }
+            },
+            "true"     => true,
+            "false"    => false,
+            "nil"      => nil
+          }
+        }
+
+        described_class.field_value_size(input1).should == 162
+        # puts(described_class.encode(input1).inspect)
+        described_class.encode(input1).bytesize.should == 162
+
+
+
+        input2   = {
+          "boolval"      => true,
+          "intval"       => 1,
+          "strval"       => "Test",
+          "timestampval" => Time.parse("2011-07-14 01:17:46 +0400"),
+          "floatval"     => 3.14,
+          "longval"      => 912598613,
+          "hashval"      => { "protocol" => "AMQP091", "true" => true, "false" => false, "nil" => nil }
+        }
+
+        described_class.field_value_size(input2).should == 150
+        described_class.encode(input2).bytesize.should == 150
+      end
+
+      it "calculates size of basic array field values" do
+        input1 = [1, 2, 3]
+
+        described_class.field_value_size(input1).should == 20
+        described_class.encode(input1).bytesize.should == 20
+
+
+        input2 = ["one", "two", "three"]
+        described_class.field_value_size(input2).should == 31
+        described_class.encode(input2).bytesize.should == 31
+
+
+        input3 = ["one", 2, "three"]
+        described_class.field_value_size(input3).should == 28
+        described_class.encode(input3).bytesize.should == 28
+
+
+        input4 = ["one", 2, "three", ["four", 5, [6.0]]]
+        described_class.field_value_size(input4).should == 61
+        described_class.encode(input4).bytesize.should == 61
+      end
+
+
+    end # TableValueEncoder
+  end # Protocol
+end # AMQ

metadata

@@ -1,15 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: amq-protocol
 version: !ruby/object:Gem::Version 
-  hash: 62196439
-  prerelease: 6
+  hash: 3
+  prerelease: 
   segments: 
   - 0
   - 7
   - 0
-  - beta
-  - 2
-  version: 0.7.0.beta2
+  version: 0.7.0
 platform: ruby
 authors: 
 - Jakub Stastny
@@ -20,7 +18,8 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-14 00:00:00 Z
+date: 2011-07-17 00:00:00 +04:00
+default_executable: 
 dependencies: []
 
 description: "  amq-protocol is an AMQP 0.9.1 serialization library for Ruby. It is not an\n  AMQP client: amq-protocol only handles serialization and deserialization.\n  If you want to write your own AMQP client, this gem can help you with that.\n"
@@ -53,6 +52,9 @@ files:
 - lib/amq/protocol/client.rb
 - lib/amq/protocol/frame.rb
 - lib/amq/protocol/table.rb
+- lib/amq/protocol/table_value_decoder.rb
+- lib/amq/protocol/table_value_encoder.rb
+- lib/amq/protocol/type_constants.rb
 - lib/amq/protocol/version.rb
 - post-processing.rb
 - protocol.rb.pytemplate
@@ -67,9 +69,12 @@ files:
 - spec/amq/protocol/queue_spec.rb
 - spec/amq/protocol/table_spec.rb
 - spec/amq/protocol/tx_spec.rb
+- spec/amq/protocol/value_decoder_spec.rb
+- spec/amq/protocol/value_encoder_spec.rb
 - spec/amq/protocol_spec.rb
 - spec/spec_helper.rb
 - tasks.rb
+has_rdoc: true
 homepage: http://github.com/ruby-amqp/amq-protocol
 licenses: []
 
@@ -90,18 +95,16 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version 
-      hash: 25
+      hash: 3
       segments: 
-      - 1
-      - 3
-      - 1
-      version: 1.3.1
+      - 0
+      version: "0"
 requirements: []
 
 rubyforge_project: amq-protocol
-rubygems_version: 1.8.5
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: AMQP 0.9.1 encoder & decoder.