Merge pull request #86 from eglitobias/modernize-ruby-3

michaelklishin · web-flow · commit 2c07948ca150 · 2026-04-15T12:08:35.000-07:00
Modernize gem for Ruby 3.0+
diff --git a/Gemfile b/Gemfile
@@ -4,8 +4,7 @@ source "https://rubygems.org"
 
 
 group :development do
-  # excludes Windows, Rubinius and JRuby
-  gem "ruby-prof", :platforms => [:mri_19, :mri_20, :mri_21]
+  gem "ruby-prof", platforms: :mri
 
   gem "rake"
 end
diff --git a/amq-protocol.gemspec b/amq-protocol.gemspec
@@ -7,15 +7,15 @@ Gem::Specification.new do |s|
   s.name = "amq-protocol"
   s.version = AMQ::Protocol::VERSION
   s.authors = ["Jakub Stastny", "Michael S. Klishin", "Theo Hultberg", "Mark Abramov"]
-  s.homepage = "http://github.com/ruby-amqp/amq-protocol"
+  s.homepage = "https://github.com/ruby-amqp/amq-protocol"
   s.summary = "AMQP 0.9.1 encoding & decoding library."
   s.description = <<-DESC
   amq-protocol is an AMQP 0.9.1 serialization library for Ruby. It is not a
   client: the library only handles serialization and deserialization.
   DESC
   s.email = ["michael.s.klishin@gmail.com"]
   s.licenses    = ["MIT"]
-  s.required_ruby_version = Gem::Requirement.new(">= 2.2")
+  s.required_ruby_version = ">= 3.0"
 
   # files
   s.files = Dir.glob("lib/**/*.rb") + %w[LICENSE README.md ChangeLog.md]
diff --git a/lib/amq/bit_set.rb b/lib/amq/bit_set.rb
@@ -113,7 +113,7 @@ def init_words(nbits)
 
     def check_range(i)
       if i < 0 || i >= @nbits
-        raise IndexError.new("Cannot access bit #{i} from a BitSet with #{@nbits} bits")
+        raise IndexError, "Cannot access bit #{i} from a BitSet with #{@nbits} bits"
       end
     end # check_range
   end # BitSet
diff --git a/lib/amq/int_allocator.rb b/lib/amq/int_allocator.rb
@@ -26,13 +26,12 @@ class IntAllocator
     # @param [Integer] hi    Upper boundary of the integer range available for allocation
     # @raise [ArgumentError] if upper boundary is not greater than the lower one
     def initialize(lo, hi)
-      raise ArgumentError.new "upper boundary must be greater than the lower one (given: hi = #{hi}, lo = #{lo})" unless hi > lo
+      raise ArgumentError, "upper boundary must be greater than the lower one (given: hi = #{hi}, lo = #{lo})" unless hi > lo
 
       @hi = hi
       @lo = lo
 
       @number_of_bits = hi - lo
-      @range          = Range.new(1, @number_of_bits)
       @free_set       = BitSet.new(@number_of_bits)
     end # initialize(hi, lo)
 
@@ -47,7 +46,7 @@ def allocate
 
       if n = @free_set.next_clear_bit
 
-        if n < @hi - 1 then
+        if n < @hi - 1
           @free_set.set(n)
           n + 1
         else
diff --git a/lib/amq/protocol/client.rb b/lib/amq/protocol/client.rb
@@ -173,9 +173,7 @@ def self.encode_body(body, channel, frame_size)
         limit        = frame_size - 8
         return [BodyFrame.new(body, channel)] if body.bytesize < limit
 
-        # Otherwise String#slice on 1.9 will operate with code points,
-        # and we need bytes. MK.
-        body.force_encoding("ASCII-8BIT") if RUBY_VERSION.to_f >= 1.9 && body.encoding != Encoding::BINARY
+        body.force_encoding("ASCII-8BIT") if body.encoding != Encoding::BINARY
 
         array = Array.new
         while body && !body.empty?
diff --git a/lib/amq/protocol/frame.rb b/lib/amq/protocol/frame.rb
@@ -23,8 +23,8 @@ def self.encoded_payload(payload)
 
       # The channel number is 0 for all frames which are global to the connection and 1-65535 for frames that refer to specific channels.
       def self.encode_to_array(type, payload, channel)
-        raise RuntimeError.new("Channel has to be 0 or an integer in range 1..65535 but was #{channel.inspect}") unless CHANNEL_RANGE.include?(channel)
-        raise RuntimeError.new("Payload can't be nil") if payload.nil?
+        raise RuntimeError, "Channel has to be 0 or an integer in range 1..65535 but was #{channel.inspect}" unless CHANNEL_RANGE.include?(channel)
+        raise RuntimeError, "Payload can't be nil" if payload.nil?
         components = []
         components << [find_type(type), channel, payload.bytesize].pack(PACK_CHAR_UINT16_UINT32)
         components << encoded_payload(payload)
@@ -47,13 +47,13 @@ def self.new(original_type, *args)
       end
 
       def self.find_type(type)
-        type_id = if Symbol === type then TYPES[type] else type end
-        raise FrameTypeError.new(TYPES_OPTIONS) if type == nil || !TYPES_REVERSE.has_key?(type_id)
+        type_id = type.is_a?(Symbol) ? TYPES[type] : type
+        raise FrameTypeError, TYPES_OPTIONS if type.nil? || !TYPES_REVERSE.key?(type_id)
         type_id
       end
 
       def self.decode(*)
-        raise NotImplementedError.new <<-EOF
+        raise NotImplementedError, <<-EOF
 You are supposed to redefine this method, because it's dependent on used IO adapter.
 
 This functionality is part of the https://github.com/ruby-amqp/amq-client library.
@@ -62,12 +62,12 @@ def self.decode(*)
 
       # Optimized header decode using unpack1 for single values where appropriate
       def self.decode_header(header)
-        raise EmptyResponseError if header == nil || header.empty?
+        raise EmptyResponseError if header.nil? || header.empty?
 
         # Use unpack for multiple values - this is the optimal approach
         type_id, channel, size = header.unpack(PACK_CHAR_UINT16_UINT32)
         type = TYPES_REVERSE[type_id]
-        raise FrameTypeError.new(TYPES_OPTIONS) unless type
+        raise FrameTypeError, TYPES_OPTIONS unless type
         [type, channel, size]
       end
 
diff --git a/lib/amq/protocol/table_value_decoder.rb b/lib/amq/protocol/table_value_decoder.rb
@@ -83,7 +83,7 @@ def self.decode_array(data, initial_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!")
+                raise ArgumentError, "unsupported type in a table value: #{type.inspect}, do not know how to decode!"
               end
 
           ary << i
diff --git a/lib/amq/protocol/table_value_encoder.rb b/lib/amq/protocol/table_value_encoder.rb
@@ -72,7 +72,7 @@ def self.encode(value)
               accumulator << [0, value.to_i].pack(PACK_UCHAR_UINT32)
             end
           else
-            raise ArgumentError.new("Unsupported value #{value.inspect} of type #{value.class.name}")
+            raise ArgumentError, "Unsupported value #{value.inspect} of type #{value.class.name}"
           end # if
         end # case
 
diff --git a/lib/amq/uri.rb b/lib/amq/uri.rb
@@ -31,7 +31,9 @@ class URI
 
     def self.parse(connection_string)
       uri = ::URI.parse(connection_string)
-      raise ArgumentError.new("Connection URI must use amqp or amqps schema (example: amqp://bus.megacorp.internal:5766), learn more at http://bit.ly/ks8MXK") unless %w{amqp amqps}.include?(uri.scheme)
+      unless %w{amqp amqps}.include?(uri.scheme)
+        raise ArgumentError, "Connection URI must use amqp or amqps schema (example: amqp://bus.megacorp.internal:5766), learn more at http://bit.ly/ks8MXK"
+      end
 
       opts = DEFAULTS.dup
 
@@ -42,7 +44,9 @@ def self.parse(connection_string)
       opts[:port]   = uri.port || AMQP_DEFAULT_PORTS[uri.scheme]
       opts[:ssl]    = uri.scheme.to_s.downcase =~ /amqps/i # TODO: rename to tls
       if uri.path =~ %r{^/(.*)}
-        raise ArgumentError.new("#{uri} has multiple-segment path; please percent-encode any slashes in the vhost name (e.g. /production => %2Fproduction). Learn more at http://bit.ly/amqp-gem-and-connection-uris") if $1.index('/')
+        if $1.index('/')
+          raise ArgumentError, "#{uri} has multiple-segment path; please percent-encode any slashes in the vhost name (e.g. /production => %2Fproduction). Learn more at http://bit.ly/amqp-gem-and-connection-uris"
+        end
         opts[:vhost] = ::CGI::unescape($1)
       end
 
@@ -63,15 +67,15 @@ def self.parse(connection_string)
 
         %w(cacertfile certfile keyfile).each do |tls_option|
           if query_params[tls_option] && uri.scheme == "amqp"
-            raise ArgumentError.new("The option '#{tls_option}' can only be used in URIs that use amqps schema")
+            raise ArgumentError, "The option '#{tls_option}' can only be used in URIs that use amqps schema"
           else
             opts[tls_option.to_sym] = query_params[tls_option]
           end
         end
 
         %w(verify fail_if_no_peer_cert).each do |tls_option|
           if query_params[tls_option] && uri.scheme == "amqp"
-            raise ArgumentError.new("The option '#{tls_option}' can only be used in URIs that use amqps schema")
+            raise ArgumentError, "The option '#{tls_option}' can only be used in URIs that use amqps schema"
           else
             opts[tls_option.to_sym] = as_boolean(query_params[tls_option])
           end
diff --git a/spec/amq/protocol/frame_spec.rb b/spec/amq/protocol/frame_spec.rb
@@ -55,6 +55,17 @@ module Protocol
         it "should raise FrameTypeError if the type is not one of the accepted" do
           expect { Frame.new(10) }.to raise_error(FrameTypeError)
         end
+
+        it "returns the correct subclass for a valid type" do
+          frame = Frame.new(:body, "test", 1)
+          expect(frame).to be_a(BodyFrame)
+        end
+      end
+
+      describe ".decode" do
+        it "raises NotImplementedError" do
+          expect { Frame.decode("anything") }.to raise_error(NotImplementedError)
+        end
       end
 
       describe '#decode_header' do
@@ -65,6 +76,14 @@ module Protocol
         it 'raises EmptyResponseError if the header is nil' do
           expect { Frame.decode_header(nil) }.to raise_error(EmptyResponseError)
         end
+
+        it "returns type, channel and size for a valid header" do
+          header = "\x03\x00\x01\x00\x00\x00\x04"
+          type, channel, size = Frame.decode_header(header)
+          expect(type).to eq(:body)
+          expect(channel).to eq(1)
+          expect(size).to eq(4)
+        end
       end
 
       describe HeaderFrame do
@@ -121,12 +140,14 @@ module Protocol
       end
 
       describe MethodFrame do
+        subject { MethodFrame.new("\x00\x3C\x00\x28\x00\x00\x00\x00\x00", 1) }
+
+        it "resolves method_class from payload" do
+          expect(subject.method_class).to eq(AMQ::Protocol::Basic::Publish)
+        end
+
         it "is not final when method has content" do
-          # Basic.Publish has content
-          payload = "\x00\x3C\x00\x28\x00\x00\x00\x00\x00"
-          frame = MethodFrame.new(payload, 1)
-          # This will depend on the method class
-          expect(frame).to respond_to(:final?)
+          expect(subject.final?).to eq(false)
         end
       end
 
diff --git a/spec/amq/protocol/table_spec.rb b/spec/amq/protocol/table_spec.rb
@@ -188,6 +188,35 @@ module Protocol
           expect(output).to eq(1677)
         end
 
+        it "decodes TYPE_INTEGER (32-bit unsigned) from raw binary" do
+          # "\x03key" = 1-byte key length + "key", then 'I' type + 4-byte uint32
+          binary = [9].pack("N") + "\x03keyI" + [42].pack("N")
+          expect(Table.decode(binary.force_encoding("BINARY"))).to eq("key" => 42)
+        end
+
+        it "decodes TYPE_BYTE from raw binary" do
+          # "\x01k" = 1-byte key length + "k", then 'b' type + 1-byte value
+          binary = [4].pack("N") + "\x01kb\xFF"
+          expect(Table.decode(binary.force_encoding("BINARY"))).to eq("k" => 255)
+        end
+
+        it "decodes TYPE_SIGNED_16BIT from raw binary" do
+          binary = [5].pack("N") + "\x01ks" + [1000].pack("s>")
+          expect(Table.decode(binary.force_encoding("BINARY"))).to eq("k" => 1000)
+        end
+
+        it "decodes TYPE_32BIT_FLOAT from raw binary" do
+          binary = [7].pack("N") + "\x01kf" + [1.5].pack("f")
+          result = Table.decode(binary.force_encoding("BINARY"))
+          expect(result["k"]).to be_within(0.001).of(1.5)
+        end
+
+        it "raises ArgumentError for unknown type bytes" do
+          # "\x03key" key + unknown type '?'
+          binary = [5].pack("N") + "\x03key?"
+          expect { Table.decode(binary.force_encoding("BINARY")) }.to raise_error(ArgumentError, /Not a valid type/)
+        end
+
         it "is capable of decoding tables" do
           input   = {
             "boolval"      => true,
diff --git a/spec/amq/protocol/value_decoder_spec.rb b/spec/amq/protocol/value_decoder_spec.rb
@@ -178,6 +178,77 @@ module Protocol
           expect(value).to eq({"nested" => "value"})
         end
       end
+
+      describe ".decode_array type dispatch" do
+        # Builds binary for decode_array(data, 1):
+        # byte 0 = dummy (TYPE_ARRAY tag), bytes 1-4 = content length, bytes 5+ = elements.
+        def array_binary(element_bytes)
+          "\x00" + [element_bytes.bytesize].pack("N") + element_bytes
+        end
+
+        it "decodes TYPE_INTEGER (32-bit unsigned)" do
+          data = array_binary("I" + [99].pack("N"))
+          result, _ = described_class.decode_array(data, 1)
+          expect(result).to eq([99])
+        end
+
+        it "decodes TYPE_DECIMAL" do
+          data = array_binary("D" + "\x02" + [314].pack("N"))
+          result, _ = described_class.decode_array(data, 1)
+          expect(result.first).to be_a(BigDecimal)
+          expect(result.first).to eq(BigDecimal("3.14"))
+        end
+
+        it "decodes TYPE_TIME" do
+          ts = 1_700_000_000
+          data = array_binary("T" + [ts].pack("Q>"))
+          result, _ = described_class.decode_array(data, 1)
+          expect(result.first.to_i).to eq(ts)
+        end
+
+        it "decodes TYPE_BYTE_ARRAY" do
+          data = array_binary("x" + [3].pack("N") + "foo")
+          result, _ = described_class.decode_array(data, 1)
+          expect(result).to eq(["foo"])
+        end
+
+        it "decodes TYPE_32BIT_FLOAT" do
+          data = array_binary("f" + [1.5].pack("f"))
+          result, _ = described_class.decode_array(data, 1)
+          expect(result.first).to be_within(0.001).of(1.5)
+        end
+
+        it "decodes TYPE_BOOLEAN" do
+          # Two booleans make content length 4, enough for the loop to enter once
+          data = array_binary("t\x01t\x00")
+          result, _ = described_class.decode_array(data, 1)
+          expect(result).to include(true)
+        end
+
+        it "decodes TYPE_BYTE" do
+          data = array_binary("b\xFFb\x01")
+          result, _ = described_class.decode_array(data, 1)
+          expect(result).to include(255)
+        end
+
+        it "decodes TYPE_SIGNED_16BIT" do
+          data = array_binary("s" + [1000].pack("s>") + "s" + [2000].pack("s>"))
+          result, _ = described_class.decode_array(data, 1)
+          expect(result).to include(1000)
+        end
+
+        it "decodes TYPE_VOID as nil" do
+          data = array_binary("VVVV")
+          result, _ = described_class.decode_array(data, 1)
+          expect(result).to include(nil)
+        end
+
+        it "raises ArgumentError for unsupported types" do
+          data = array_binary("?\x00\x00\x00")
+          expect { described_class.decode_array(data, 1) }
+            .to raise_error(ArgumentError, /unsupported type/)
+        end
+      end
     end
   end
 end
diff --git a/spec/amq/uri_parsing_spec.rb b/spec/amq/uri_parsing_spec.rb
@@ -25,25 +25,12 @@
         end
       end
 
-      if RUBY_VERSION >= "2.2"
-        context "absent" do
-          let(:uri) { "amqp://" }
-
-          # Note that according to the ABNF, the host component may not be absent, but it may be zero-length.
-          it "falls back to a blank value" do
-            expect(subject[:host]).to be_nil
-          end
-        end
-      end
-
-      if RUBY_VERSION < "2.2"
-        context "absent" do
-          let(:uri) { "amqp://" }
+      context "absent" do
+        let(:uri) { "amqp://" }
 
-          # Note that according to the ABNF, the host component may not be absent, but it may be zero-length.
-          it "raises InvalidURIError" do
-            expect { subject[:host] }.to raise_error(URI::InvalidURIError, /bad URI\(absolute but no path\)/)
-          end
+        # Note that according to the ABNF, the host component may not be absent, but it may be zero-length.
+        it "falls back to a blank value" do
+          expect(subject[:host]).to be_nil
         end
       end
     end

Original file line number	Diff line number	Diff line change
`@@ -83,7 +83,7 @@ def self.decode_array(data, initial_offset)`
`83`	`83`	`v, offset = decode_array(data, offset)`
`84`	`84`	`v`
`85`	`85`	`else`
`86`		`- raise ArgumentError.new("unsupported type in a table value: #{type.inspect}, do not know how to decode!")`
	`86`	`+ raise ArgumentError, "unsupported type in a table value: #{type.inspect}, do not know how to decode!"`
`87`	`87`	`end`
`88`	`88`
`89`	`89`	`ary << i`