nats-pure 2.3.0 → 2.5.0

data/lib/nats/io/jetstream/manager.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright 2021 The NATS Authors
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -31,15 +33,15 @@ module NATS
       # @param params [Hash] Options to customize API request.
       # @option params [Float] :timeout Time to wait for response.
       # @return [JetStream::API::StreamCreateResponse] The result of creating a Stream.
-      def add_stream(config, params={})
-        config = if not config.is_a?(JetStream::API::StreamConfig)
-                   JetStream::API::StreamConfig.new(config)
-                 else
-                   config
-                 end
+      def add_stream(config, params = {})
+        config = if !config.is_a?(JetStream::API::StreamConfig)
+          JetStream::API::StreamConfig.new(config)
+        else
+          config
+        end
         stream = config[:name]
         raise ArgumentError.new(":name is required to create streams") unless stream
-        raise ArgumentError.new("Spaces, tabs, period (.), greater than (>) or asterisk (*) are prohibited in stream names") if stream =~ /(\s|\.|\>|\*)/
+        raise ArgumentError.new("Spaces, tabs, period (.), greater than (>) or asterisk (*) are prohibited in stream names") if stream =~ /(\s|\.|>|\*)/
         req_subject = "#{@prefix}.STREAM.CREATE.#{stream}"
 
         cfg = config.to_h.compact
@@ -52,11 +54,11 @@ module NATS
       # @param params [Hash] Options to customize API request.
       # @option params [Float] :timeout Time to wait for response.
       # @return [JetStream::API::StreamInfo] The latest StreamInfo of the stream.
-      def stream_info(stream, params={})
-        raise JetStream::Error::InvalidStreamName.new("nats: invalid stream name") if stream.nil? or stream.empty?
+      def stream_info(stream, params = {})
+        raise JetStream::Error::InvalidStreamName.new("nats: invalid stream name") if stream.nil? || stream.empty?
 
         req_subject = "#{@prefix}.STREAM.INFO.#{stream}"
-        result = api_request(req_subject, '', params)
+        result = api_request(req_subject, "", params)
         JetStream::API::StreamInfo.new(result)
       end
 
@@ -65,15 +67,15 @@ module NATS
       # @param params [Hash] Options to customize API request.
       # @option params [Float] :timeout Time to wait for response.
       # @return [JetStream::API::StreamCreateResponse] The result of creating a Stream.
-      def update_stream(config, params={})
-        config = if not config.is_a?(JetStream::API::StreamConfig)
-                   JetStream::API::StreamConfig.new(config)
-                 else
-                   config
-                 end
+      def update_stream(config, params = {})
+        config = if !config.is_a?(JetStream::API::StreamConfig)
+          JetStream::API::StreamConfig.new(config)
+        else
+          config
+        end
         stream = config[:name]
         raise ArgumentError.new(":name is required to create streams") unless stream
-        raise ArgumentError.new("Spaces, tabs, period (.), greater than (>) or asterisk (*) are prohibited in stream names") if stream =~ /(\s|\.|\>|\*)/
+        raise ArgumentError.new("Spaces, tabs, period (.), greater than (>) or asterisk (*) are prohibited in stream names") if stream =~ /(\s|\.|>|\*)/
         req_subject = "#{@prefix}.STREAM.UPDATE.#{stream}"
         cfg = config.to_h.compact
         result = api_request(req_subject, cfg.to_json, params)
@@ -85,11 +87,11 @@ module NATS
       # @param params [Hash] Options to customize API request.
       # @option params [Float] :timeout Time to wait for response.
       # @return [Boolean]
-      def delete_stream(stream, params={})
-        raise JetStream::Error::InvalidStreamName.new("nats: invalid stream name") if stream.nil? or stream.empty?
+      def delete_stream(stream, params = {})
+        raise JetStream::Error::InvalidStreamName.new("nats: invalid stream name") if stream.nil? || stream.empty?
 
         req_subject = "#{@prefix}.STREAM.DELETE.#{stream}"
-        result = api_request(req_subject, '', params)
+        result = api_request(req_subject, "", params)
         result[:success]
       end
 
@@ -99,27 +101,45 @@ module NATS
       # @param params [Hash] Options to customize API request.
       # @option params [Float] :timeout Time to wait for response.
       # @return [JetStream::API::ConsumerInfo] The result of creating a Consumer.
-      def add_consumer(stream, config, params={})
-        raise JetStream::Error::InvalidStreamName.new("nats: invalid stream name") if stream.nil? or stream.empty?
-        config = if not config.is_a?(JetStream::API::ConsumerConfig)
-                   JetStream::API::ConsumerConfig.new(config)
-                 else
-                   config
-                 end
-
-        req_subject = case
-                      when config[:name]
-                        # NOTE: Only supported after nats-server v2.9.0
-                        if config[:filter_subject] && config[:filter_subject] != ">"
-                          "#{@prefix}.CONSUMER.CREATE.#{stream}.#{config[:name]}.#{config[:filter_subject]}"
-                        else
-                          "#{@prefix}.CONSUMER.CREATE.#{stream}.#{config[:name]}"
-                        end
-                      when config[:durable_name]
-                        "#{@prefix}.CONSUMER.DURABLE.CREATE.#{stream}.#{config[:durable_name]}"
-                      else
-                        "#{@prefix}.CONSUMER.CREATE.#{stream}"
-                      end
+      def add_consumer(stream, config, params = {})
+        raise JetStream::Error::InvalidStreamName.new("nats: invalid stream name") if stream.nil? || stream.empty?
+        config = if !config.is_a?(JetStream::API::ConsumerConfig)
+          JetStream::API::ConsumerConfig.new(config)
+        else
+          config
+        end
+        config[:name] ||= config[:durable_name]
+        req_subject = if config[:name]
+          ###############################################################################
+          #                                                                             #
+          #  Using names is the supported way of creating consumers (NATS +v2.9.0.      #
+          #                                                                             #
+          ###############################################################################
+          if config[:filter_subject] && config[:filter_subject] != ">"
+            "#{@prefix}.CONSUMER.CREATE.#{stream}.#{config[:name]}.#{config[:filter_subject]}"
+          else
+            ##############################################################################
+            #                                                                            #
+            # Endpoint to support creating ANY consumer with multi-filters (NATS +v2.10) #
+            #                                                                            #
+            ##############################################################################
+            "#{@prefix}.CONSUMER.CREATE.#{stream}.#{config[:name]}"
+          end
+        elsif config[:durable_name]
+          ###############################################################################
+          #                                                                             #
+          # Endpoint to support creating DURABLES before NATS v2.9.0.                   #
+          #                                                                             #
+          ###############################################################################
+          "#{@prefix}.CONSUMER.DURABLE.CREATE.#{stream}.#{config[:durable_name]}"
+        else
+          ###############################################################################
+          #                                                                             #
+          # Endpoint to support creating EPHEMERALS before NATS v2.9.0.                 #
+          #                                                                             #
+          ###############################################################################
+          "#{@prefix}.CONSUMER.CREATE.#{stream}"
+        end
 
         config[:ack_policy] ||= JS::Config::AckExplicit
         # Check if have to normalize ack wait so that it is in nanoseconds for Go compat.
@@ -131,6 +151,10 @@ module NATS
           raise ArgumentError.new("nats: invalid inactive threshold") unless config[:inactive_threshold].is_a?(Integer)
           config[:inactive_threshold] = config[:inactive_threshold] * ::NATS::NANOSECONDS
         end
+        if config[:idle_heartbeat]
+          raise ArgumentError.new("nats: invalid idle heartbeat") unless config[:idle_heartbeat].is_a?(Integer)
+          config[:idle_heartbeat] = config[:idle_heartbeat] * ::NATS::NANOSECONDS
+        end
 
         cfg = config.to_h.compact
         req = {
@@ -148,12 +172,12 @@ module NATS
       # @param params [Hash] Options to customize API request.
       # @option params [Float] :timeout Time to wait for response.
       # @return [JetStream::API::ConsumerInfo] The latest ConsumerInfo of the consumer.
-      def consumer_info(stream, consumer, params={})
-        raise JetStream::Error::InvalidStreamName.new("nats: invalid stream name") if stream.nil? or stream.empty?
-        raise JetStream::Error::InvalidConsumerName.new("nats: invalid consumer name") if consumer.nil? or consumer.empty?
+      def consumer_info(stream, consumer, params = {})
+        raise JetStream::Error::InvalidStreamName.new("nats: invalid stream name") if stream.nil? || stream.empty?
+        raise JetStream::Error::InvalidConsumerName.new("nats: invalid consumer name") if consumer.nil? || consumer.empty?
 
         req_subject = "#{@prefix}.CONSUMER.INFO.#{stream}.#{consumer}"
-        result = api_request(req_subject, '', params)
+        result = api_request(req_subject, "", params)
         JetStream::API::ConsumerInfo.new(result)
       end
 
@@ -163,12 +187,12 @@ module NATS
       # @param params [Hash] Options to customize API request.
       # @option params [Float] :timeout Time to wait for response.
       # @return [Boolean]
-      def delete_consumer(stream, consumer, params={})
-        raise JetStream::Error::InvalidStreamName.new("nats: invalid stream name") if stream.nil? or stream.empty?
-        raise JetStream::Error::InvalidConsumerName.new("nats: invalid consumer name") if consumer.nil? or consumer.empty?
+      def delete_consumer(stream, consumer, params = {})
+        raise JetStream::Error::InvalidStreamName.new("nats: invalid stream name") if stream.nil? || stream.empty?
+        raise JetStream::Error::InvalidConsumerName.new("nats: invalid consumer name") if consumer.nil? || consumer.empty?
 
         req_subject = "#{@prefix}.CONSUMER.DELETE.#{stream}.#{consumer}"
-        result = api_request(req_subject, '', params)
+        result = api_request(req_subject, "", params)
         result[:success]
       end
 
@@ -178,9 +202,9 @@ module NATS
       # @param params [Hash] Options to customize API request.
       # @option params [Float] :timeout Time to wait for response.
       # @return [String] The name of the JetStream stream for the subject.
-      def find_stream_name_by_subject(subject, params={})
+      def find_stream_name_by_subject(subject, params = {})
         req_subject = "#{@prefix}.STREAM.NAMES"
-        req = { subject: subject }
+        req = {subject: subject}
         result = api_request(req_subject, req.to_json, params)
         raise JetStream::Error::NotFound unless result[:streams]
 
@@ -194,23 +218,22 @@ module NATS
       # @option seq [Integer] Sequence number of a message.
       # @option subject [String] Subject of the message.
       # @option direct [Boolean] Use direct mode to for faster access (requires NATS v2.9.0)
-      def get_msg(stream_name, params={})
+      def get_msg(stream_name, params = {})
         req = {}
-        case
-        when params[:next]
+        if params[:next]
           req[:seq] = params[:seq]
           req[:next_by_subj] = params[:subject]
-        when params[:seq]
+        elsif params[:seq]
           req[:seq] = params[:seq]
-        when params[:subject]
+        elsif params[:subject]
           req[:last_by_subj] = params[:subject]
         end
 
         data = req.to_json
         if params[:direct]
-          if params[:subject] and not params[:seq]
+          if params[:subject] && !(params[:seq])
             # last_by_subject type request requires no payload.
-            data = ''
+            data = ""
             req_subject = "#{@prefix}.DIRECT.GET.#{stream_name}.#{params[:subject]}"
           else
             req_subject = "#{@prefix}.DIRECT.GET.#{stream_name}"
@@ -219,16 +242,14 @@ module NATS
           req_subject = "#{@prefix}.STREAM.MSG.GET.#{stream_name}"
         end
         resp = api_request(req_subject, data, direct: params[:direct])
-        msg = if params[:direct]
-                _lift_msg_to_raw_msg(resp)
-              else
-                JetStream::API::RawStreamMsg.new(resp[:message])
-              end
-
-        msg
+        if params[:direct]
+          _lift_msg_to_raw_msg(resp)
+        else
+          JetStream::API::RawStreamMsg.new(resp[:message])
+        end
       end
 
-      def get_last_msg(stream_name, subject, params={})
+      def get_last_msg(stream_name, subject, params = {})
         params[:subject] = subject
         get_msg(stream_name, params)
       end
@@ -239,20 +260,20 @@ module NATS
 
       private
 
-      def api_request(req_subject, req="", params={})
+      def api_request(req_subject, req = "", params = {})
         params[:timeout] ||= @opts[:timeout]
         msg = begin
-                @nc.request(req_subject, req, **params)
-              rescue NATS::IO::NoRespondersError
-                raise JetStream::Error::ServiceUnavailable
-              end
+          @nc.request(req_subject, req, **params)
+        rescue NATS::IO::NoRespondersError
+          raise JetStream::Error::ServiceUnavailable
+        end
 
         result = if params[:direct]
-                   msg
-                 else
-                   JSON.parse(msg.data, symbolize_names: true)
-                 end
-        if result.is_a?(Hash) and result[:error]
+          msg
+        else
+          JSON.parse(msg.data, symbolize_names: true)
+        end
+        if result.is_a?(Hash) && result[:error]
           raise JS.from_error(result[:error])
         end
 
@@ -260,21 +281,21 @@ module NATS
       end
 
       def _lift_msg_to_raw_msg(msg)
-        if msg.header and msg.header['Status']
-          status = msg.header['Status']
-          if status == '404'
+        if msg.header && msg.header["Status"]
+          status = msg.header["Status"]
+          if status == "404"
             raise ::NATS::JetStream::Error::NotFound.new
           else
             raise JS.from_msg(msg)
           end
         end
-        subject = msg.header['Nats-Subject']
-        seq = msg.header['Nats-Sequence']
+        subject = msg.header["Nats-Subject"]
+        seq = msg.header["Nats-Sequence"]
         raw_msg = JetStream::API::RawStreamMsg.new(
           subject: subject,
           seq: seq,
-          headers: msg.header,
-          )
+          headers: msg.header
+        )
         raw_msg.data = msg.data
 
         raw_msg

data/lib/nats/io/jetstream/msg/ack.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright 2021 The NATS Authors
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -16,19 +18,21 @@ module NATS
   class JetStream
     module Msg
       module Ack
+        # rubocop:disable Naming/ConstantName
+
         # Ack types
-        Ack      = ("+ACK".freeze)
-        Nak      = ("-NAK".freeze)
-        Progress = ("+WPI".freeze)
-        Term     = ("+TERM".freeze)
+        Ack = "+ACK"
+        Nak = "-NAK"
+        Progress = "+WPI"
+        Term = "+TERM"
 
-        Empty = (''.freeze)
-        DotSep = ('.'.freeze)
-        NoDomainName = ('_'.freeze)
+        Empty = ""
+        DotSep = "."
+        NoDomainName = "_"
 
         # Position
-        Prefix0 = ('$JS'.freeze)
-        Prefix1 = ('ACK'.freeze)
+        Prefix0 = "$JS"
+        Prefix1 = "ACK"
         Domain = 2
         AccHash = 3
         Stream = 4
@@ -50,6 +54,8 @@ module NATS
         V2TokenCounts = 12
 
         SequencePair = Struct.new(:stream, :consumer)
+
+        # rubocop:enable Naming/ConstantName
       end
       private_constant :Ack
     end

data/lib/nats/io/jetstream/msg/ack_methods.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright 2021 The NATS Authors
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -20,10 +22,10 @@ module NATS
           ensure_is_acked_once!
 
           resp = if params[:timeout]
-                   @nc.request(@reply, Ack::Ack, **params)
-                 else
-                   @nc.publish(@reply, Ack::Ack)
-                 end
+            @nc.request(@reply, Ack::Ack, **params)
+          else
+            @nc.publish(@reply, Ack::Ack)
+          end
           @sub.synchronize { @ackd = true }
 
           resp
@@ -42,15 +44,15 @@ module NATS
         def nak(**params)
           ensure_is_acked_once!
           payload = if params[:delay]
-                      payload = "#{Ack::Nak} #{{ delay: params[:delay] }.to_json}"
-                    else
-                      Ack::Nak
-                    end
+            "#{Ack::Nak} #{{delay: params[:delay]}.to_json}"
+          else
+            Ack::Nak
+          end
           resp = if params[:timeout]
-                   @nc.request(@reply, payload, **params)
-                 else
-                   @nc.publish(@reply, payload)
-                 end
+            @nc.request(@reply, payload, **params)
+          else
+            @nc.publish(@reply, payload)
+          end
           @sub.synchronize { @ackd = true }
 
           resp
@@ -60,10 +62,10 @@ module NATS
           ensure_is_acked_once!
 
           resp = if params[:timeout]
-                   @nc.request(@reply, Ack::Term, **params)
-                 else
-                   @nc.publish(@reply, Ack::Term)
-                 end
+            @nc.request(@reply, Ack::Term, **params)
+          else
+            @nc.publish(@reply, Ack::Term)
+          end
           @sub.synchronize { @ackd = true }
 
           resp
@@ -74,7 +76,7 @@ module NATS
         end
 
         def metadata
-          @meta ||= parse_metadata(reply)
+          @meta ||= parse_metadata(@reply)
         end
 
         private
@@ -88,18 +90,18 @@ module NATS
         end
 
         def parse_metadata(reply)
+          return unless reply && !reply.empty?
           tokens = reply.split(Ack::DotSep)
           n = tokens.count
 
-          case
-          when n < Ack::V1TokenCounts || (n > Ack::V1TokenCounts and n < Ack::V2TokenCounts)
+          if n < Ack::V1TokenCounts || ((n > Ack::V1TokenCounts) && (n < Ack::V2TokenCounts))
             raise NotJSMessage.new("nats: not a jetstream message")
-          when tokens[0] != Ack::Prefix0 || tokens[1] != Ack::Prefix1
+          elsif tokens[0] != Ack::Prefix0 || tokens[1] != Ack::Prefix1
             raise NotJSMessage.new("nats: not a jetstream message")
-          when n == Ack::V1TokenCounts
+          elsif n == Ack::V1TokenCounts
             tokens.insert(Ack::Domain, Ack::Empty)
             tokens.insert(Ack::AccHash, Ack::Empty)
-          when tokens[Ack::Domain] == Ack::NoDomainName
+          elsif tokens[Ack::Domain] == Ack::NoDomainName
             tokens[Ack::Domain] = Ack::Empty
           end
 

data/lib/nats/io/jetstream/msg/metadata.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright 2021 The NATS Authors
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,7 +14,7 @@
 # limitations under the License.
 #
 
-require 'time'
+require "time"
 
 module NATS
   class JetStream
@@ -21,13 +23,13 @@ module NATS
         attr_reader :sequence, :num_delivered, :num_pending, :timestamp, :stream, :consumer, :domain
 
         def initialize(opts)
-          @sequence      = Ack::SequencePair.new(opts[Ack::StreamSeq].to_i, opts[Ack::ConsumerSeq].to_i)
-          @domain        = opts[Ack::Domain]
+          @sequence = Ack::SequencePair.new(opts[Ack::StreamSeq].to_i, opts[Ack::ConsumerSeq].to_i)
+          @domain = opts[Ack::Domain]
           @num_delivered = opts[Ack::NumDelivered].to_i
-          @num_pending   = opts[Ack::NumPending].to_i
-          @timestamp     = Time.at((opts[Ack::Timestamp].to_i / 1_000_000_000.0))
-          @stream        = opts[Ack::Stream]
-          @consumer      = opts[Ack::Consumer]
+          @num_pending = opts[Ack::NumPending].to_i
+          @timestamp = Time.at((opts[Ack::Timestamp].to_i / 1_000_000_000.0))
+          @stream = opts[Ack::Stream]
+          @consumer = opts[Ack::Consumer]
           # TODO: Not exposed in Go client either right now.
           # account      = opts[Ack::AccHash]
         end

data/lib/nats/io/jetstream/msg.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright 2021 The NATS Authors
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,9 +14,9 @@
 # limitations under the License.
 #
 
-require_relative 'msg/ack'
-require_relative 'msg/ack_methods'
-require_relative 'msg/metadata'
+require_relative "msg/ack"
+require_relative "msg/ack_methods"
+require_relative "msg/metadata"
 
 module NATS
   class JetStream
@@ -23,4 +25,9 @@ module NATS
     module Msg
     end
   end
-end
+
+  class Msg
+    # Enhance it with ack related methods from JetStream to ack msgs.
+    include JetStream::Msg::AckMethods
+  end
+end

data/lib/nats/io/jetstream/pull_subscription.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright 2021 The NATS Authors
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,7 +14,7 @@
 # limitations under the License.
 #
 
-require_relative 'errors'
+require_relative "errors"
 
 module NATS
   class JetStream
@@ -39,7 +41,7 @@ module NATS
     module PullSubscription
       # next_msg is not available for pull based subscriptions.
       # @raise [NATS::JetStream::Error]
-      def next_msg(params={})
+      def next_msg(params = {})
         raise ::NATS::JetStream::Error.new("nats: pull subscription cannot use next_msg")
       end
 
@@ -49,7 +51,7 @@ module NATS
       # @param params [Hash] Options to customize the fetch request.
       # @option params [Float] :timeout Duration of the fetch request before it expires.
       # @return [Array<NATS::Msg>]
-      def fetch(batch=1, params={})
+      def fetch(batch = 1, params = {})
         if batch < 1
           raise ::NATS::JetStream::Error.new("nats: invalid batch size")
         end
@@ -80,7 +82,7 @@ module NATS
               if JS.is_status_msg(msg)
                 case msg.header["Status"]
                 when JS::Status::NoMsgs
-                  msg = nil
+                  nil
                 when JS::Status::RequestTimeout
                   # Skip
                 else
@@ -193,27 +195,31 @@ module NATS
 
           # Check if have not received yet a single message.
           duration = MonotonicTime.since(start_time)
-          if msgs.empty? and duration > timeout
+
+          if msgs.empty? && (duration > timeout)
             raise NATS::Timeout.new("nats: fetch timeout")
           end
 
           needed = batch - msgs.count
-          while needed > 0 and MonotonicTime.since(start_time) < timeout
+          while (needed > 0) && (MonotonicTime.since(start_time) < timeout)
             duration = MonotonicTime.since(start_time)
 
             # Wait for the rest of the messages.
             synchronize do
-
               # Wait until there is a message delivered.
               if @pending_queue.empty?
                 deadline = timeout - duration
+                MonotonicTime.now
+
                 wait_for_msgs_cond.wait(deadline) if deadline > 0
 
                 duration = MonotonicTime.since(start_time)
-                if msgs.empty? && @pending_queue.empty? and duration > timeout
+                if msgs.empty? && @pending_queue.empty? && (duration > timeout)
                   raise NATS::Timeout.new("nats: fetch timeout")
                 end
-              else
+              end
+
+              unless @pending_queue.empty?
                 msg = @pending_queue.pop
                 @pending_size -= msg.data.size
 
@@ -244,6 +250,11 @@ module NATS
           end
         end
 
+        # Check if timed out waiting for messages.
+        if msgs.empty? && (MonotonicTime.since(start_time) > timeout)
+          raise NATS::Timeout.new("nats: fetch timeout")
+        end
+
         msgs
       end
 
@@ -251,7 +262,7 @@ module NATS
       # @param params [Hash] Options to customize API request.
       # @option params [Float] :timeout Time to wait for response.
       # @return [JetStream::API::ConsumerInfo] The latest ConsumerInfo of the consumer.
-      def consumer_info(params={})
+      def consumer_info(params = {})
         @jsi.js.consumer_info(@jsi.stream, @jsi.consumer, params)
       end
     end

data/lib/nats/io/jetstream/push_subscription.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright 2021 The NATS Authors
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -33,7 +35,7 @@ module NATS
       # @param params [Hash] Options to customize API request.
       # @option params [Float] :timeout Time to wait for response.
       # @return [JetStream::API::ConsumerInfo] The latest ConsumerInfo of the consumer.
-      def consumer_info(params={})
+      def consumer_info(params = {})
         @jsi.js.consumer_info(@jsi.stream, @jsi.consumer, params)
       end
     end