amq-protocol 2.3.4 → 2.4.0

data/lib/amq/bit_set.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module AMQ
   # Very minimalistic, pure Ruby implementation of bit set. Inspired by java.util.BitSet,

data/lib/amq/endianness.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AMQ
   module Endianness
     BIG_ENDIAN = ([1].pack("s") == "\x00\x01")

data/lib/amq/int_allocator.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 require "amq/bit_set"
 

data/lib/amq/pack.rb

@@ -1,54 +1,45 @@
 # encoding: binary
-
-require 'amq/endianness'
+# frozen_string_literal: true
 
 module AMQ
-  # Implements pack to/unpack from 64bit string in network byte order
-  # compatible with Ruby 1.8+.
+  # Implements pack to/unpack from 64bit string in network byte order.
+  # Uses native Ruby pack directives with explicit endianness (Ruby 1.9.3+).
   module Pack
-    UINT64 = "Q".freeze
-    UINT16_BE  = "n".freeze
-    INT16 = "c".freeze
-
-    if Endianness.big_endian?
-      def self.pack_uint64_big_endian(long_long)
-        [long_long].pack(UINT64)
-      end
-
-      def self.unpack_uint64_big_endian(data)
-        data.unpack(UINT64)
-      end
-
-      def self.pack_int16_big_endian(short)
-        [long_long].pack(INT16)
-      end
-
-      def self.unpack_int16_big_endian(data)
-        data.unpack(INT16)
-      end
-    else
-      def self.pack_uint64_big_endian(long_long)
-        result = [long_long].pack(UINT64)
-        result.bytes.to_a.reverse.map(&:chr).join
-      end
+    # Pack format strings - frozen for performance
+    UINT64_BE = 'Q>'.freeze  # 64-bit unsigned, big-endian
+    INT64_BE  = 'q>'.freeze  # 64-bit signed, big-endian
+    INT16_BE  = 's>'.freeze  # 16-bit signed, big-endian
+    UINT16_BE = 'n'.freeze   # 16-bit unsigned, big-endian (network order)
+
+    # Packs a 64-bit unsigned integer to big-endian binary string.
+    # @param long_long [Integer] The value to pack
+    # @return [String] 8-byte binary string in big-endian order
+    def self.pack_uint64_big_endian(long_long)
+      [long_long].pack(UINT64_BE)
+    end
 
-      def self.unpack_uint64_big_endian(data)
-        data = data.bytes.to_a.reverse.map(&:chr).join
-        data.unpack(UINT64)
-      end
+    # Unpacks a big-endian binary string to a 64-bit unsigned integer.
+    # @param data [String] 8-byte binary string in big-endian order
+    # @return [Array<Integer>] Single-element array containing the unpacked value
+    def self.unpack_uint64_big_endian(data)
+      data.unpack(UINT64_BE)
+    end
 
-      def self.pack_int16_big_endian(short)
-        result = [long_long].pack(INT16)
-        result.bytes.to_a.reverse.map(&:chr).join
-      end
+    # Packs a 16-bit signed integer to big-endian binary string.
+    # @param short [Integer] The value to pack
+    # @return [String] 2-byte binary string in big-endian order
+    def self.pack_int16_big_endian(short)
+      [short].pack(INT16_BE)
+    end
 
-      def self.unpack_int16_big_endian(data)
-        value = data.bytes.to_a.map(&:chr).join.unpack(UINT16_BE)[0]
-        [(value & ~(1 << 15)) - (value & (1 << 15))]
-      end
+    # Unpacks a big-endian binary string to a 16-bit signed integer.
+    # @param data [String] 2-byte binary string in big-endian order
+    # @return [Array<Integer>] Single-element array containing the unpacked value
+    def self.unpack_int16_big_endian(data)
+      data.unpack(INT16_BE)
     end
   end
 
-  # Backwards compatibility
+  # Backwards compatibility alias
   Hacks = Pack
 end

data/lib/amq/protocol/constants.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AMQ
   module Protocol
     TLS_PORT         = 5671

data/lib/amq/protocol/exceptions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AMQ
   module Protocol
     class Error < StandardError
@@ -41,7 +43,7 @@ module AMQ
 
     class BadResponseError < Protocol::Error
       def initialize(argument, expected, actual)
-        super("Argument #{argument} has to be #{expected.inspect}, was #{data.inspect}")
+        super("Argument #{argument} has to be #{expected.inspect}, was #{actual.inspect}")
       end
     end
 

data/lib/amq/protocol/float_32bit.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AMQ
   module Protocol
     # Allows distinguishing between 32-bit and 64-bit floats in Ruby.

data/lib/amq/protocol/frame.rb

@@ -1,4 +1,5 @@
 # encoding: binary
+# frozen_string_literal: true
 
 module AMQ
   module Protocol
@@ -9,6 +10,9 @@ module AMQ
       CHANNEL_RANGE = (0..65535).freeze
       FINAL_OCTET   = "\xCE".freeze # 206
 
+      # Pack format for 64-bit unsigned big-endian
+      PACK_UINT64_BE = 'Q>'.freeze
+
       def self.encoded_payload(payload)
         if payload.respond_to?(:force_encoding) && payload.encoding.name != 'BINARY'
           # Only copy if we have to.
@@ -130,7 +134,7 @@ This functionality is part of the https://github.com/ruby-amqp/amq-client librar
       end # final?
 
       def decode_payload
-        self.method_class.decode(@payload[4..-1])
+        self.method_class.decode(@payload.byteslice(4..-1))
       end
     end
 
@@ -167,8 +171,8 @@ This functionality is part of the https://github.com/ruby-amqp/amq-client librar
                                # the total size of the content body, that is, the sum of the body sizes for the
                                # following content body frames. Zero indicates that there are no content body frames.
                                # So this is NOT related to this very header frame!
-                               @body_size         = AMQ::Hacks.unpack_uint64_big_endian(@payload[4..11]).first
-                               @data              = @payload[12..-1]
+                               @body_size         = @payload.byteslice(4, 8).unpack1(PACK_UINT64_BE)
+                               @data              = @payload.byteslice(12..-1)
                                @properties        = Basic.decode_properties(@data)
                              end
       end

data/lib/amq/protocol/table.rb

@@ -1,4 +1,5 @@
 # encoding: binary
+# frozen_string_literal: true
 
 require "amq/protocol/type_constants"
 require "amq/protocol/table_value_encoder"
@@ -14,6 +15,8 @@ module AMQ
 
       include TypeConstants
 
+      # Pack format string
+      PACK_UINT32_BE = 'N'.freeze
 
       #
       # API
@@ -27,16 +30,16 @@ module AMQ
 
 
       def self.encode(table)
-        buffer = String.new
+        buffer = +''
 
         table ||= {}
 
         table.each do |key, value|
           key = key.to_s # it can be a symbol as well
-          buffer << key.bytesize.chr + key
+          buffer << key.bytesize.chr << key
 
           case value
-          when Hash then
+          when Hash
             buffer << TYPE_HASH
             buffer << self.encode(value)
           else
@@ -44,15 +47,15 @@ module AMQ
           end
         end
 
-        [buffer.bytesize].pack(PACK_UINT32).force_encoding(buffer.encoding) + buffer
+        [buffer.bytesize].pack(PACK_UINT32_BE) << buffer
       end
 
 
 
 
       def self.decode(data)
-        table        = Hash.new
-        table_length = data.unpack(PACK_UINT32).first
+        table        = {}
+        table_length = data.unpack1(PACK_UINT32_BE)
 
         return table if table_length.zero?
 
@@ -86,19 +89,19 @@ module AMQ
                        when TYPE_BOOLEAN
                          v, offset = TableValueDecoder.decode_boolean(data, offset)
                          v
-                      when TYPE_BYTE  then
+                       when TYPE_BYTE
                          v, offset = TableValueDecoder.decode_byte(data, offset)
                          v
-                       when TYPE_SIGNED_16BIT then
+                       when TYPE_SIGNED_16BIT
                          v, offset = TableValueDecoder.decode_short(data, offset)
                          v
-                       when TYPE_SIGNED_64BIT then
+                       when TYPE_SIGNED_64BIT
                          v, offset = TableValueDecoder.decode_long(data, offset)
                          v
-                       when TYPE_32BIT_FLOAT then
+                       when TYPE_32BIT_FLOAT
                          v, offset = TableValueDecoder.decode_32bit_float(data, offset)
                          v
-                       when TYPE_64BIT_FLOAT then
+                       when TYPE_64BIT_FLOAT
                          v, offset = TableValueDecoder.decode_64bit_float(data, offset)
                          v
                        when TYPE_VOID
@@ -112,11 +115,11 @@ module AMQ
         end
 
         table
-      end # self.decode
+      end
 
 
       def self.length(data)
-        data.unpack(PACK_UINT32).first
+        data.unpack1(PACK_UINT32_BE)
       end
 
 
@@ -128,17 +131,17 @@ module AMQ
         end
 
         acc
-      end # self.hash_size(value)
+      end
 
 
       def self.decode_table_key(data, offset)
-        key_length = data.slice(offset, 1).unpack(PACK_CHAR).first
+        key_length = data.getbyte(offset)
         offset += 1
-        key = data.slice(offset, key_length)
+        key = data.byteslice(offset, key_length)
         offset += key_length
 
         [key, offset]
-      end # self.decode_table_key(data, offset)
+      end
 
 
 

data/lib/amq/protocol/table_value_decoder.rb

@@ -1,6 +1,6 @@
 # encoding: binary
+# frozen_string_literal: true
 
-require "amq/endianness"
 require "amq/protocol/type_constants"
 require "amq/protocol/float_32bit"
 
@@ -15,15 +15,23 @@ module AMQ
 
       include TypeConstants
 
+      # Pack format strings use explicit endianness (available as of Ruby 1.9.3)
+      PACK_UINT32_BE   = 'N'.freeze
+      PACK_INT64_BE    = 'q>'.freeze
+      PACK_INT16_BE    = 's>'.freeze
+      PACK_UINT64_BE   = 'Q>'.freeze
+      PACK_FLOAT32     = 'f'.freeze  # single precision float (native endian, matches encoder)
+      PACK_FLOAT64     = 'G'.freeze  # big-endian double precision float
+      PACK_UCHAR_UINT32 = 'CN'.freeze
 
       #
       # API
       #
 
       def self.decode_array(data, initial_offset)
-        array_length = data.slice(initial_offset, 4).unpack(PACK_UINT32).first
+        array_length = data.byteslice(initial_offset, 4).unpack1(PACK_UINT32_BE)
 
-        ary    = Array.new
+        ary    = []
         offset = initial_offset + 4
 
         while offset <= (initial_offset + array_length)
@@ -54,25 +62,25 @@ module AMQ
               when TYPE_BOOLEAN
                 v, offset = decode_boolean(data, offset)
                 v
-              when TYPE_BYTE then
+              when TYPE_BYTE
                 v, offset = decode_byte(data, offset)
                 v
-              when TYPE_SIGNED_16BIT then
+              when TYPE_SIGNED_16BIT
                 v, offset = decode_short(data, offset)
                 v
-              when TYPE_SIGNED_64BIT then
+              when TYPE_SIGNED_64BIT
                 v, offset = decode_long(data, offset)
                 v
-              when TYPE_32BIT_FLOAT then
+              when TYPE_32BIT_FLOAT
                 v, offset = decode_32bit_float(data, offset)
                 v
-              when TYPE_64BIT_FLOAT then
+              when TYPE_64BIT_FLOAT
                 v, offset = decode_64bit_float(data, offset)
                 v
               when TYPE_VOID
                 nil
               when TYPE_ARRAY
-                v, offset = TableValueDecoder.decode_array(data, offset)
+                v, offset = decode_array(data, offset)
                 v
               else
                 raise ArgumentError.new("unsupported type in a table value: #{type.inspect}, do not know how to decode!")
@@ -83,113 +91,101 @@ module AMQ
 
 
         [ary, initial_offset + array_length + 4]
-      end # self.decode_array(data, initial_offset)
+      end
 
 
       def self.decode_string(data, offset)
-        length = data.slice(offset, 4).unpack(PACK_UINT32).first
+        length = data.byteslice(offset, 4).unpack1(PACK_UINT32_BE)
         offset += 4
-        v = data.slice(offset, length)
+        v = data.byteslice(offset, length)
         offset += length
 
         [v, offset]
-      end # self.decode_string(data, offset)
+      end
 
 
       def self.decode_integer(data, offset)
-        v = data.slice(offset, 4).unpack(PACK_UINT32).first
+        v = data.byteslice(offset, 4).unpack1(PACK_UINT32_BE)
         offset += 4
 
         [v, offset]
-      end # self.decode_integer(data, offset)
-
+      end
 
-      if AMQ::Endianness.big_endian?
-        def self.decode_long(data, offset)
-          v    = data.slice(offset, 8).unpack(PACK_INT64)
 
-          offset += 8
-          [v, offset]
-        end
-      else
-        def self.decode_long(data, offset)
-          slice = data.slice(offset, 8).bytes.to_a.reverse.map(&:chr).join
-          v     = slice.unpack(PACK_INT64).first
-
-          offset += 8
-          [v, offset]
-        end
+      def self.decode_long(data, offset)
+        v = data.byteslice(offset, 8).unpack1(PACK_INT64_BE)
+        offset += 8
+        [v, offset]
       end
 
 
       def self.decode_big_decimal(data, offset)
-        decimals, raw = data.slice(offset, 5).unpack(PACK_UCHAR_UINT32)
+        decimals, raw = data.byteslice(offset, 5).unpack(PACK_UCHAR_UINT32)
         offset += 5
         v = BigDecimal(raw.to_s) * (BigDecimal(TEN) ** -decimals)
 
         [v, offset]
-      end # self.decode_big_decimal(data, offset)
+      end
 
 
       def self.decode_time(data, offset)
-        timestamp = data.slice(offset, 8).unpack(PACK_UINT64_BE).last
+        timestamp = data.byteslice(offset, 8).unpack1(PACK_UINT64_BE)
         v = Time.at(timestamp)
         offset += 8
 
         [v, offset]
-      end # self.decode_time(data, offset)
+      end
 
 
       def self.decode_boolean(data, offset)
-        integer = data.slice(offset, 2).unpack(PACK_CHAR).first # 0 or 1
+        byte = data.getbyte(offset)
         offset += 1
-        [(integer == 1), offset]
-      end # self.decode_boolean(data, offset)
+        [(byte == 1), offset]
+      end
 
 
       def self.decode_32bit_float(data, offset)
-        v = data.slice(offset, 4).unpack(PACK_32BIT_FLOAT).first
+        v = data.byteslice(offset, 4).unpack1(PACK_FLOAT32)
         offset += 4
 
         [v, offset]
-      end # self.decode_32bit_float(data, offset)
+      end
 
 
       def self.decode_64bit_float(data, offset)
-        v = data.slice(offset, 8).unpack(PACK_64BIT_FLOAT).first
+        v = data.byteslice(offset, 8).unpack1(PACK_FLOAT64)
         offset += 8
 
         [v, offset]
-      end # self.decode_64bit_float(data, offset)
+      end
 
 
       def self.decode_value_type(data, offset)
-        [data.slice(offset, 1), offset + 1]
-      end # self.decode_value_type(data, offset)
-
+        [data.byteslice(offset, 1), offset + 1]
+      end
 
 
       def self.decode_hash(data, offset)
-        length = data.slice(offset, 4).unpack(PACK_UINT32).first
-        v = Table.decode(data.slice(offset, length + 4))
+        length = data.byteslice(offset, 4).unpack1(PACK_UINT32_BE)
+        v = Table.decode(data.byteslice(offset, length + 4))
         offset += 4 + length
 
         [v, offset]
-      end # self.decode_hash(data, offset)
+      end
 
 
       # Decodes/Converts a byte value from the data at the provided offset.
       #
-      # @param [Array] data - A big-endian ordered array of bytes.
-      # @param [Fixnum] offset - The offset which bytes the byte is consumed.
-      # @return [Array] - The Fixnum value and new offset pair.
+      # @param [String] data - Binary data string
+      # @param [Integer] offset - The offset from which to read the byte
+      # @return [Array] - The Integer value and new offset pair
       def self.decode_byte(data, offset)
-        [data.slice(offset, 1).unpack(PACK_CHAR).first, offset += 1]
+        [data.getbyte(offset), offset + 1]
       end
 
 
       def self.decode_short(data, offset)
-        v = AMQ::Hacks.unpack_int16_big_endian(data.slice(offset, 2)).first
+        v = data.byteslice(offset, 2).unpack1(PACK_INT16_BE)
         offset += 2
         [v, offset]
       end

data/lib/amq/protocol/table_value_encoder.rb

@@ -1,4 +1,5 @@
 # encoding: binary
+# frozen_string_literal: true
 
 require "amq/protocol/type_constants"
 require "date"

data/lib/amq/protocol/type_constants.rb

@@ -1,4 +1,5 @@
 # encoding: binary
+# frozen_string_literal: true
 
 module AMQ
   module Protocol

data/lib/amq/protocol/version.rb

@@ -1,5 +1,5 @@
 module AMQ
   module Protocol
-    VERSION = "2.3.4"
+    VERSION = "2.4.0"
   end # Protocol
 end # AMQ

data/lib/amq/settings.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 require "amq/protocol/client"
 require "amq/uri"

data/spec/amq/bit_set_spec.rb

@@ -223,5 +223,27 @@ RSpec.describe AMQ::BitSet do
       subject.unset(254)
       expect(subject.get(254)).to be_falsey
     end # it
+
+    it "returns -1 when all bits are set" do
+      bs = described_class.new(64)
+      0.upto(63) { |i| bs.set(i) }
+      expect(bs.next_clear_bit).to eq(-1)
+    end
+  end # describe
+
+  describe "#to_s" do
+    it "returns a string representation of the bit set" do
+      bs = described_class.new(64)
+      result = bs.to_s
+      expect(result).to be_a(String)
+      expect(result).to include(":")
+    end
+
+    it "shows set bits" do
+      bs = described_class.new(64)
+      bs.set(0)
+      result = bs.to_s
+      expect(result).to end_with("1:")
+    end
   end # describe
 end

data/spec/amq/endianness_spec.rb

@@ -0,0 +1,23 @@
+# encoding: binary
+
+require "amq/endianness"
+
+RSpec.describe AMQ::Endianness do
+  describe ".big_endian?" do
+    it "returns a boolean" do
+      expect([true, false]).to include(described_class.big_endian?)
+    end
+  end
+
+  describe ".little_endian?" do
+    it "returns the opposite of big_endian?" do
+      expect(described_class.little_endian?).to eq(!described_class.big_endian?)
+    end
+  end
+
+  describe "BIG_ENDIAN constant" do
+    it "is a boolean" do
+      expect([true, false]).to include(AMQ::Endianness::BIG_ENDIAN)
+    end
+  end
+end

data/spec/amq/int_allocator_spec.rb

@@ -11,13 +11,17 @@ RSpec.describe AMQ::IntAllocator do
   end
 
 
-  # ...
-
-
   #
   # Examples
   #
 
+  describe "#initialize" do
+    it "raises ArgumentError when hi <= lo" do
+      expect { described_class.new(5, 5) }.to raise_error(ArgumentError)
+      expect { described_class.new(10, 5) }.to raise_error(ArgumentError)
+    end
+  end
+
   describe "#number_of_bits" do
     it "returns number of bits available for allocation" do
       expect(subject.number_of_bits).to eq(4)
@@ -110,4 +114,23 @@ RSpec.describe AMQ::IntAllocator do
       end
     end
   end
+
+  describe "#release" do
+    it "is an alias for #free" do
+      subject.allocate
+      expect(subject.allocated?(1)).to be_truthy
+      subject.release(1)
+      expect(subject.allocated?(1)).to be_falsey
+    end
+  end
+
+  describe "#reset" do
+    it "releases all allocations" do
+      4.times { subject.allocate }
+      expect(subject.allocate).to eq(-1)
+
+      subject.reset
+      expect(subject.allocate).to eq(1)
+    end
+  end
 end