pg_eventstore 1.13.1 → 1.13.3

data/lib/pg_eventstore/subscriptions/queries/subscriptions_set_queries.rb

@@ -46,9 +46,10 @@ module PgEventstore
     def set_names
       builder = SQLBuilder.new.select('name').from('subscriptions_set').group('name').order('name ASC')
 
-      connection.with do |conn|
+      raw_set = connection.with do |conn|
         conn.exec_params(*builder.to_exec_params)
-      end.map { |attrs| attrs['name'] }
+      end
+      raw_set.map { |attrs| attrs['name'] }
     end
 
     # The same as #find_all, but returns first result
@@ -61,15 +62,15 @@ module PgEventstore
     # @return [Hash]
     # @raise [PgEventstore::RecordNotFound]
     def find!(id)
-      find_by(id: id) || raise(RecordNotFound.new("subscriptions_set", id))
+      find_by(id: id) || raise(RecordNotFound.new('subscriptions_set', id))
     end
 
     # @param attrs [Hash]
     # @return [Hash]
     def create(attrs)
       sql = <<~SQL
-        INSERT INTO subscriptions_set (#{attrs.keys.join(', ')}) 
-          VALUES (#{Utils.positional_vars(attrs.values)}) 
+        INSERT INTO subscriptions_set (#{attrs.keys.join(', ')})
+          VALUES (#{Utils.positional_vars(attrs.values)})
           RETURNING *
       SQL
       pg_result = connection.with do |conn|
@@ -92,7 +93,7 @@ module PgEventstore
       pg_result = connection.with do |conn|
         conn.exec_params(sql, [*attrs.values, id])
       end
-      raise(RecordNotFound.new("subscriptions_set", id)) if pg_result.ntuples.zero?
+      raise(RecordNotFound.new('subscriptions_set', id)) if pg_result.ntuples == 0
 
       deserialize(pg_result.to_a.first)
     end

data/lib/pg_eventstore/subscriptions/runner_recovery_strategies/restore_connection.rb

@@ -17,9 +17,10 @@ module PgEventstore
       end
 
       def recovers?(error)
-        EXCEPTIONS_TO_HANDLE.any? {error.is_a?(_1) }
+        EXCEPTIONS_TO_HANDLE.any? { error.is_a?(_1) }
       end
 
+      # rubocop:disable Lint/SuppressedException
       def recover(_error)
         loop do
           sleep TIME_BETWEEN_RETRIES
@@ -32,6 +33,7 @@ module PgEventstore
         rescue *EXCEPTIONS_TO_HANDLE
         end
       end
+      # rubocop:enable Lint/SuppressedException
 
       private
 

data/lib/pg_eventstore/subscriptions/runner_recovery_strategies/restore_subscription_runner.rb

@@ -21,6 +21,7 @@ module PgEventstore
 
       def recover(error)
         return false if @restart_terminator&.call(@subscription.dup)
+
         if @subscription.restart_count >= @subscription.max_restarts_number
           @failed_subscription_notifier&.call(@subscription.dup, Utils.unwrap_exception(error))
           return false

data/lib/pg_eventstore/subscriptions/runner_state.rb

@@ -7,7 +7,7 @@ module PgEventstore
     include Extensions::CallbacksExtension
 
     # @return [Hash<Symbol => String>]
-    STATES = %i(initial running halting stopped dead).to_h { [_1, _1.to_s.freeze] }.freeze
+    STATES = %i[initial running halting stopped dead].to_h { [_1, _1.to_s.freeze] }.freeze
 
     def initialize
       initial!
@@ -36,11 +36,13 @@ module PgEventstore
 
     # @param state [String]
     # @return [String]
+    # rubocop:disable Naming/AccessorMethodName
     def set_state(state)
       old_state = @state
       @state = state
       callbacks.run_callbacks(:change_state, @state) unless old_state == @state
       @state
     end
+    # rubocop:enable Naming/AccessorMethodName
   end
 end

data/lib/pg_eventstore/subscriptions/subscription.rb

@@ -26,10 +26,11 @@ module PgEventstore
     #     the list of available options
     attribute(:options)
     # @!attribute current_position
-    #   @return [Integer, nil] current Subscription's position. It is updated automatically each time an event is processed
+    #   @return [Integer, nil] current Subscription's position. It is updated automatically each time an event is
+    #     processed
     attribute(:current_position)
     # @!attribute state
-    #   @return [String, nil] current Subscription's state. It is updated automatically during Subscription's life cycle.
+    #   @return [String, nil] current Subscription's state. It is updated automatically during Subscription's life cycle
     #     See {RunnerState::STATES} for possible values.
     attribute(:state)
     # @!attribute average_event_processing_time
@@ -141,20 +142,20 @@ module PgEventstore
       id.hash
     end
 
-    # @param another [Object]
+    # @param other [Object]
     # @return [Boolean]
-    def eql?(another)
-      return false unless another.is_a?(Subscription)
+    def eql?(other)
+      return false unless other.is_a?(Subscription)
 
-      hash == another.hash
+      hash == other.hash
     end
 
-    # @param another [Object]
+    # @param other [Object]
     # @return [Boolean]
-    def ==(another)
-      return false unless another.is_a?(Subscription)
+    def ==(other)
+      return false unless other.is_a?(Subscription)
 
-      id == another.id
+      id == other.id
     end
 
     private

data/lib/pg_eventstore/subscriptions/subscription_handler_performance.rb

@@ -34,7 +34,7 @@ module PgEventstore
     # The average time required to process an event.
     # @return [Float]
     def average_event_processing_time
-      synchronize { @timings.size.zero? ? 0.0 : @timings.sum / @timings.size }
+      synchronize { @timings.empty? ? 0.0 : @timings.sum / @timings.size }
     end
   end
 end

data/lib/pg_eventstore/subscriptions/subscription_runner.rb

@@ -58,7 +58,7 @@ module PgEventstore
 
     # @return [Integer]
     def estimate_events_number
-      return INITIAL_EVENTS_PER_CHUNK if @stats.average_event_processing_time.zero?
+      return INITIAL_EVENTS_PER_CHUNK if @stats.average_event_processing_time == 0
 
       events_per_chunk = (@subscription.chunk_query_interval / @stats.average_event_processing_time).round
       events_to_fetch = [events_per_chunk, MAX_EVENTS_PER_CHUNK].min - @events_processor.events_left_in_chunk

data/lib/pg_eventstore/subscriptions/subscriptions_manager.rb

@@ -6,6 +6,7 @@ require_relative 'basic_runner'
 require_relative 'runner_recovery_strategy'
 require_relative 'runner_recovery_strategies'
 require_relative 'subscription'
+require_relative 'synchronized_array'
 require_relative 'events_processor'
 require_relative 'subscription_handler_performance'
 require_relative 'subscription_runner'
@@ -54,7 +55,7 @@ module PgEventstore
         {
           name: set_name,
           max_restarts_number: max_retries || config.subscriptions_set_max_retries,
-          time_between_restarts: retries_interval || config.subscriptions_set_retries_interval
+          time_between_restarts: retries_interval || config.subscriptions_set_retries_interval,
         }
       )
       @subscriptions_lifecycle = SubscriptionsLifecycle.new(
@@ -108,7 +109,7 @@ module PgEventstore
           graceful_shutdown_timeout: graceful_shutdown_timeout,
           recovery_strategies: recovery_strategies(subscription, restart_terminator, failed_subscription_notifier)
         ),
-        subscription: subscription,
+        subscription: subscription
       )
 
       @subscriptions_lifecycle.runners.push(runner)
@@ -149,12 +150,10 @@ module PgEventstore
     private
 
     # @return [Object] the result of the passed block
-    def run_cli_callbacks
+    def run_cli_callbacks(&blk)
       return yield unless defined?(::PgEventstore::CLI)
 
-      PgEventstore::CLI.callbacks.run_callbacks(:start_manager, self) do
-        yield
-      end
+      PgEventstore::CLI.callbacks.run_callbacks(:start_manager, self, &blk)
     end
 
     # @param middlewares [Array<Symbol>, nil]
@@ -183,7 +182,7 @@ module PgEventstore
         RunnerRecoveryStrategies::RestoreSubscriptionRunner.new(
           subscription: subscription,
           restart_terminator: restart_terminator,
-          failed_subscription_notifier: failed_subscription_notifier,
+          failed_subscription_notifier: failed_subscription_notifier
         ),
       ]
     end

data/lib/pg_eventstore/subscriptions/subscriptions_set.rb

@@ -92,20 +92,20 @@ module PgEventstore
       id.hash
     end
 
-    # @param another [Object]
+    # @param other [Object]
     # @return [Boolean]
-    def eql?(another)
-      return false unless another.is_a?(SubscriptionsSet)
+    def eql?(other)
+      return false unless other.is_a?(SubscriptionsSet)
 
-      hash == another.hash
+      hash == other.hash
     end
 
-    # @param another [Object]
+    # @param other [Object]
     # @return [Boolean]
-    def ==(another)
-      return false unless another.is_a?(SubscriptionsSet)
+    def ==(other)
+      return false unless other.is_a?(SubscriptionsSet)
 
-      id == another.id
+      id == other.id
     end
 
     private

data/lib/pg_eventstore/subscriptions/subscriptions_set_lifecycle.rb

@@ -27,9 +27,11 @@ module PgEventstore
     end
 
     # @return [PgEventstore::SubscriptionsSet]
+    # rubocop:disable Naming/MemoizedInstanceVariableName
     def persisted_subscriptions_set
       @subscriptions_set ||= SubscriptionsSet.using_connection(@config_name).create(@subscriptions_set_attrs)
     end
+    # rubocop:enable Naming/MemoizedInstanceVariableName
 
     # @return [void]
     def reset_subscriptions_set

data/lib/pg_eventstore/subscriptions/synchronized_array.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'monitor'
+
+module PgEventstore
+  # @!visibility private
+  class SynchronizedArray < Array
+    include MonitorMixin
+
+    alias old_shift shift
+    alias old_unshift unshift
+    alias old_push push
+    alias old_clear clear
+    alias old_size size
+    alias old_empty? empty?
+
+    def shift(...)
+      synchronize { old_shift(...) }
+    end
+
+    def unshift(...)
+      synchronize { old_unshift(...) }
+    end
+
+    def push(...)
+      synchronize { old_push(...) }
+    end
+
+    def clear(...)
+      synchronize { old_clear(...) }
+    end
+
+    def size(...)
+      synchronize { old_size(...) }
+    end
+
+    def empty?(...)
+      synchronize { old_empty?(...) }
+    end
+  end
+end

data/lib/pg_eventstore/tasks/setup.rake

@@ -14,13 +14,13 @@ helpers = Class.new do
     end
 
     def db_name
-      @db_name ||= URI.parse(ENV.fetch('PG_EVENTSTORE_URI')).path&.delete("/")
+      @db_name ||= URI.parse(ENV.fetch('PG_EVENTSTORE_URI')).path&.delete('/')
     end
   end
 end
 
 namespace :pg_eventstore do
-  desc "Creates events table, indexes, etc."
+  desc 'Creates events table, indexes, etc.'
   task :create do
     PgEventstore.configure do |config|
       config.pg_uri = helpers.postgres_uri
@@ -28,7 +28,8 @@ namespace :pg_eventstore do
 
     PgEventstore.connection.with do |conn|
       exists =
-        conn.exec_params("SELECT 1 as exists FROM pg_database where datname = $1", [helpers.db_name]).first&.dig('exists')
+        conn.exec_params('SELECT 1 as exists FROM pg_database where datname = $1', [helpers.db_name]).
+        first&.dig('exists')
       if exists
         puts "#{helpers.db_name} already exists. Skipping."
       else
@@ -42,7 +43,7 @@ namespace :pg_eventstore do
       config.pg_uri = ENV['PG_EVENTSTORE_URI']
     end
 
-    migration_files_root = "#{Gem::Specification.find_by_name("pg_eventstore").gem_dir}/db/migrations"
+    migration_files_root = "#{Gem::Specification.find_by_name('pg_eventstore').gem_dir}/db/migrations"
 
     PgEventstore.connection.with do |conn|
       conn.exec('CREATE TABLE IF NOT EXISTS migrations (number int NOT NULL)')
@@ -50,7 +51,7 @@ namespace :pg_eventstore do
         conn.exec('SELECT number FROM migrations ORDER BY number DESC LIMIT 1').to_a.dig(0, 'number') || -1
 
       Dir.chdir migration_files_root do
-        Dir["*.{sql,rb}"].sort_by { |f_name| f_name.split('_').first.to_i }.each do |f_name|
+        Dir['*.{sql,rb}'].sort_by { |f_name| f_name.split('_').first.to_i }.each do |f_name|
           number = File.basename(f_name).split('_')[0].to_i
           next if latest_migration >= number
 
@@ -65,7 +66,7 @@ namespace :pg_eventstore do
     end
   end
 
-  desc "Drops events table and related pg_eventstore objects."
+  desc 'Drops events table and related pg_eventstore objects.'
   task :drop do
     PgEventstore.configure do |config|
       config.pg_uri = helpers.postgres_uri

data/lib/pg_eventstore/utils.rb

@@ -50,7 +50,7 @@ module PgEventstore
         {
           class: original_error.class,
           message: original_error.message,
-          backtrace: original_error.backtrace
+          backtrace: original_error.backtrace,
         }.tap do |attrs|
           attrs.merge!(error.extra) if error.is_a?(WrappedException)
         end
@@ -61,7 +61,7 @@ module PgEventstore
       def underscore_str(str)
         str = str.dup
         str[0] = str[0].downcase
-        str.gsub!(/[A-Z]/) { |letter| '_' + letter.downcase }
+        str.gsub!(/[A-Z]/) { |letter| "_#{letter.downcase}" }
         str
       end
 
@@ -83,7 +83,7 @@ module PgEventstore
       # @param content [String]
       # @return [void]
       def write_to_file(file_path, content)
-        file = File.open(file_path, "w")
+        file = File.open(file_path, 'w')
         file.write(content)
       ensure
         file&.close
@@ -91,20 +91,24 @@ module PgEventstore
 
       # @param file_path [String]
       # @return [void]
+      # rubocop:disable Lint/SuppressedException
       def remove_file(file_path)
         File.delete(file_path)
       rescue Errno::ENOENT
       end
+      # rubocop:enable Lint/SuppressedException
 
       # @param file_path [String]
       # @return [String, nil]
+      # rubocop:disable Lint/SuppressedException
       def read_pid(file_path)
-        file = File.open(file_path, "r")
+        file = File.open(file_path, 'r')
         file.readline.strip
       rescue Errno::ENOENT
       ensure
         file&.close
       end
+      # rubocop:enable Lint/SuppressedException
 
       # @param exception [StandardError]
       # @param extra [Hash] additional exception info

data/lib/pg_eventstore/version.rb

@@ -2,5 +2,5 @@
 
 module PgEventstore
   # @return [String]
-  VERSION = "1.13.1"
+  VERSION = '1.13.3'
 end

data/lib/pg_eventstore/web/application.rb

@@ -13,26 +13,33 @@ module PgEventstore
       COOKIES_CONFIG_KEY = 'current_config'
       # @return [String]
       COOKIES_FLASH_MESSAGE_KEY = 'flash_message'
+      # @return [Array<Symbol>]
+      LOGGING_ENVS = %i[development test].freeze
+      private_constant :LOGGING_ENVS
 
       # Defines a replacement for empty string value in a stream attributes filter or in an event type filter. This
       # replacement is needed to differentiate a user selection vs default placeholder value.
       # @return [String]
-      EMPTY_STRING_SIGN = "\x00".freeze
+      EMPTY_STRING_SIGN = "\x00"
 
-      set :static_cache_control, [:private, max_age: 86400]
+      set :static_cache_control, [:private, { max_age: 86_400 }]
       set :environment, -> { (ENV['RACK_ENV'] || ENV['RAILS_ENV'] || ENV['APP_ENV'])&.to_sym || :development }
-      set :logging, -> { environment == :development || environment == :test }
+      set :logging, -> { LOGGING_ENVS.include?(environment) }
       set :erb, layout: :'layouts/application'
       set :host_authorization, { allow_if: ->(_env) { true } }
 
       helpers(Paginator::Helpers, Subscriptions::Helpers) do
         # @return [Array<Hash>, nil]
+        # rubocop:disable Style/HashConversion
         def streams_filter
           streams = QueryBuilders::EventsFiltering.extract_streams_filter(params)
-          streams&.select { _1 in { context: String, stream_name: String, stream_id: String } }&.map do
-            Hash[_1.reject { |_, value| value == '' }].transform_keys(&:to_sym)
-          end&.reject { _1.empty? }
+          streams = streams.select { _1 in { context: String, stream_name: String, stream_id: String } }
+          streams = streams.map do |stream_attrs|
+            Hash[stream_attrs.reject { |_, value| value == '' }].transform_keys(&:to_sym)
+          end
+          streams.reject(&:empty?)
         end
+        # rubocop:enable Style/HashConversion
 
         # @return [String, nil]
         def system_stream
@@ -44,7 +51,7 @@ module PgEventstore
         def events_filter
           event_filters = { filter: { event_types: params.dig(:filter, :events) } }
           events = QueryBuilders::EventsFiltering.extract_event_types_filter(event_filters)
-          events&.reject { _1 == '' }
+          events.reject { _1 == '' }
         end
 
         # @return [Symbol]
@@ -81,7 +88,7 @@ module PgEventstore
           end
           halt 200, {
             results: results,
-            pagination: { more: !collection.next_page_starting_id.nil?, starting_id: collection.next_page_starting_id }
+            pagination: { more: !collection.next_page_starting_id.nil?, starting_id: collection.next_page_starting_id },
           }.to_json
         end
 
@@ -144,7 +151,7 @@ module PgEventstore
           order: Paginator::EventsCollection::SQL_DIRECTIONS[params[:order]],
           options: {
             filter: { event_types: events_filter, streams: streams_filter },
-            resolve_link_tos: resolve_link_tos?
+            resolve_link_tos: resolve_link_tos?,
           },
           system_stream: system_stream
         )
@@ -154,7 +161,7 @@ module PgEventstore
           halt 200, {
             events: erb(:'home/partials/events', { layout: false }, { events: @collection.collection }),
             total_count: total_count(@collection.total_count),
-            pagination: erb(:'home/partials/pagination_links', { layout: false }, { collection: @collection })
+            pagination: erb(:'home/partials/pagination_links', { layout: false }, { collection: @collection }),
           }.to_json
         else
           erb :'home/dashboard'
@@ -223,7 +230,7 @@ module PgEventstore
           options: {
             query: params[:term],
             context: unescape_empty_string(params[:context]),
-            stream_name: unescape_empty_string(params[:stream_name])
+            stream_name: unescape_empty_string(params[:stream_name]),
           }
         )
         paginated_json_response(collection)
@@ -297,7 +304,7 @@ module PgEventstore
             PgEventstore.maintenance(current_config).delete_event(event, force: force)
             self.flash_message = {
               message: "An event at global position #{event.global_position} has been deleted successfully.",
-              kind: 'success'
+              kind: 'success',
             }
           rescue TooManyRecordsToLockError => e
             text = <<~TEXT
@@ -319,10 +326,10 @@ module PgEventstore
           stream_id: params[:stream_id]&.to_s,
         }
 
-        err_message = ->(attrs) {
+        err_message = lambda { |attrs|
           self.flash_message = {
             message: "Could not delete #{attrs}. It is not valid stream for deletion.",
-            kind: 'error'
+            kind: 'error',
           }
         }
 
@@ -334,7 +341,7 @@ module PgEventstore
             PgEventstore.maintenance(current_config).delete_stream(stream)
             self.flash_message = {
               message: "Stream #{stream.to_hash} has been successfully deleted.",
-              kind: 'success'
+              kind: 'success',
             }
           end
         else

data/lib/pg_eventstore/web/paginator/event_types_collection.rb

@@ -9,14 +9,13 @@ module PgEventstore
 
         # @return [Array<Hash<String => String>>]
         def collection
-          @_collection ||=
+          @collection ||=
             begin
-              sql_builder =
-                SQLBuilder.new.select('event_type').from('partitions').
-                  where('context is not null and stream_name is not null').
-                  group('event_type').order("event_type #{order}").limit(per_page)
+              sql_builder = SQLBuilder.new.select('event_type').from('partitions')
+              sql_builder.where('context is not null and stream_name is not null')
               sql_builder.where("event_type #{direction_operator} ?", starting_id) if starting_id
               sql_builder.where('event_type ilike ?', "%#{options[:query]}%")
+              sql_builder.group('event_type').order("event_type #{order}").limit(per_page)
               connection.with do |conn|
                 conn.exec_params(*sql_builder.to_exec_params)
               end.to_a
@@ -28,12 +27,11 @@ module PgEventstore
           return unless collection.size == per_page
 
           starting_id = collection.first['event_type']
-          sql_builder =
-            SQLBuilder.new.select('event_type').from('partitions').
-              where('context is not null and stream_name is not null').
-              where("event_type #{direction_operator} ?", starting_id).
-              where('event_type ilike ?', "%#{options[:query]}%").
-              group('event_type').order("event_type #{order}").limit(1).offset(per_page)
+          sql_builder = SQLBuilder.new.select('event_type').from('partitions')
+          sql_builder.where('context is not null and stream_name is not null')
+          sql_builder.where("event_type #{direction_operator} ?", starting_id)
+          sql_builder.where('event_type ilike ?', "%#{options[:query]}%")
+          sql_builder.group('event_type').order("event_type #{order}").limit(1).offset(per_page)
 
           connection.with do |conn|
             conn.exec_params(*sql_builder.to_exec_params)

data/lib/pg_eventstore/web/paginator/events_collection.rb

@@ -7,7 +7,7 @@ module PgEventstore
         # @return [Hash<String => Symbol>] SQL directions, string-to-symbol mapping
         SQL_DIRECTIONS = {
           'asc' => :asc,
-          'desc' => :desc
+          'desc' => :desc,
         }.tap do |directions|
           directions.default = :desc
         end.freeze
@@ -32,7 +32,7 @@ module PgEventstore
 
         # @return [Array<PgEventstore::Event>]
         def collection
-          @_collection ||= PgEventstore.client(config_name).read(
+          @collection ||= PgEventstore.client(config_name).read(
             @stream,
             options: options.merge(from_position: starting_id, max_count: per_page, direction: order)
           )
@@ -59,18 +59,17 @@ module PgEventstore
           ).to_sql_builder.unselect.select('global_position').offset(1)
           sql, params = sql_builder.to_exec_params
           sql = "SELECT * FROM (#{sql}) events ORDER BY global_position #{order} LIMIT 1"
-          connection.with  do |conn|
+          connection.with do |conn|
             conn.exec_params(sql, params)
           end.to_a.dig(0, 'global_position')
         end
 
         # @return [Integer]
         def total_count
-          @_total_count ||=
+          @total_count ||=
             begin
-              sql_builder =
-                QueryBuilders::EventsFiltering.events_filtering(@stream, options).
-                  to_sql_builder.remove_limit.remove_group.remove_order
+              sql_builder = QueryBuilders::EventsFiltering.events_filtering(@stream, options).to_sql_builder
+              sql_builder.remove_limit.remove_group.remove_order
               count = estimate_count(sql_builder)
               return count if count > MAX_NUMBER_TO_COUNT