ruby_event_store 2.19.1 → 2.19.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce9224b921ed7a88f7c7d6b35875ae497d0980b63b2088877d34a830678d812e
-  data.tar.gz: 26dfca582631ed9e9e91d1ff35857052bb52de9cbff9ebdf3f27022a67ebb24a
+  metadata.gz: a38be596490cc7feffdf26968a8175a2a1606ba567f448382b2aecfe2e78ebd9
+  data.tar.gz: c64882bef174236d979680f84ed1d16b37f8ef2ba2a48b50a49d55286cff523e
 SHA512:
-  metadata.gz: 55c6aa28f09507bee217fd58e979dab0e3962343fafb6b72ccf579c0fe1c4f4e828f6cff0aeb4ee89e94f4a6ffedf9069a14a267fe45c9cc021495d87f3cb10d
-  data.tar.gz: d60413a68772516d46b8c9ab7812dc6572d7da1b8b706d339a6a864290914048c3a78b0c6386ae5abe9bff947a0a11f6dae903e91a4d1226de06038741ca7cd9
+  metadata.gz: 07a6509f6ac818e525834d0bae05b297ef2802643fee60cc45024cf3ea2faf49744f26dfe31896be18274dfc83e4a6be62abef1cb6faa27c67b8de8664998d11
+  data.tar.gz: f4846eedf860127e23bcdc38c37b13028896b39836a3af75689943de59bbdf633d7b2dd0e30cade9728486710cc2395db99ec4adef98a60fcfbdb4c494724e3f

data/lib/ruby_event_store/client.rb

@@ -25,7 +25,7 @@ module RubyEventStore
       @event_type_resolver = event_type_resolver
 
       if (subscriptions || dispatcher)
-        warn <<~EOW
+        msg = <<~EOW
           Passing subscriptions and dispatcher to #{self.class} has been deprecated.
 
           Pass it using message_broker argument. For example:
@@ -37,11 +37,12 @@ module RubyEventStore
             )
           )
         EOW
-        warn <<~EOW if (message_broker)
+        msg += <<~EOW if message_broker
 
-            Because message_broker has been provided,
-            arguments passed by subscriptions or dispatcher will be ignored.
-          EOW
+          Because message_broker has been provided,
+          arguments passed by subscriptions or dispatcher will be ignored.
+        EOW
+        Deprecations.warn(:ruby_client_subscriptions_dispatcher, message: msg)
       end
     end
 
@@ -98,11 +99,9 @@ module RubyEventStore
     # @param expected_version (see #publish)
     # @return [self]
     def link(event_ids, stream_name:, expected_version: :any)
-      if event_ids.nil? || Array(event_ids).any?(&:nil?)
-        warn <<~EOW
+      warn <<~EOW if event_ids.nil? || Array(event_ids).any?(&:nil?)
           Passing `nil` to link is deprecated and will raise ArgumentError in RubyEventStore 3.0.
         EOW
-      end
       @repository.link_to_stream(Array(event_ids), Stream.new(stream_name), ExpectedVersion.new(expected_version))
       self
     end
@@ -385,11 +384,9 @@ module RubyEventStore
     end
 
     def enrich_events_metadata(events)
-      if events.nil? || Array(events).any?(&:nil?)
-        warn <<~EOW
+      warn <<~EOW if events.nil? || Array(events).any?(&:nil?)
           Passing `nil` to publish/append is deprecated and will raise ArgumentError in RubyEventStore 3.0.
         EOW
-      end
       events = Array(events)
       events.each { |event| enrich_event_metadata(event) }
     end

data/lib/ruby_event_store/deprecated.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  Deprecations.register(
+    :dispatcher_renamed,
+    "`RubyEventStore::Dispatcher` is deprecated and will be removed in the next major release.\n" \
+      "Use `RubyEventStore::SyncScheduler` instead.",
+  )
+  Deprecations.deprecate(Dispatcher, :initialize, key: :dispatcher_renamed)
+
+  Deprecations.register(
+    :immediate_async_dispatcher_renamed,
+    "`RubyEventStore::ImmediateAsyncDispatcher` is deprecated and will be removed in the next major release.\n" \
+      "Use `RubyEventStore::ImmediateDispatcher` instead.",
+  )
+  Deprecations.deprecate(ImmediateAsyncDispatcher, :initialize, key: :immediate_async_dispatcher_renamed)
+
+  Deprecations.register(
+    :class_subscriber,
+    "Passing a class as a subscriber is deprecated and will be removed in the next major release.\n" \
+      "Pass an instance or lambda instead, e.g. subscribe(MyHandler.new, to: [MyEvent]).",
+  )
+
+  Deprecations.register(
+    :null_mapper,
+    "`RubyEventStore::Mappers::NullMapper` is deprecated and will be removed in the next major release.\n" \
+      "Use `RubyEventStore::Mappers::Default.new` instead.",
+  )
+  Deprecations.deprecate(Mappers::NullMapper, :initialize, key: :null_mapper)
+
+  Deprecations.register(
+    :events_class_remapping_option,
+    "`events_class_remapping` option in `RubyEventStore::Mappers::Default` is deprecated and will be removed in the next major release.\n" \
+      "Use `RubyEventStore::Mappers::Transformation::Upcast` instead.",
+  )
+
+  Deprecations.register(
+    :event_class_remapper,
+    "`RubyEventStore::Mappers::Transformation::EventClassRemapper` is deprecated and will be removed in the next major release.\n" \
+      "Use `RubyEventStore::Mappers::Transformation::Upcast` instead.",
+  )
+  Deprecations.deprecate(Mappers::Transformation::EventClassRemapper, :initialize, key: :event_class_remapper)
+
+  Deprecations.register(
+    :any_version_with_specific_position,
+    "Mixing expected version :any and specific position (or :auto) is deprecated and will raise UnsupportedVersionAnyUsage in RubyEventStore 3.0.",
+  )
+
+  Deprecations.register(
+    :projection_new_constructor,
+    "RubyEventStore::Projection.new is deprecated and will be removed in the next major release.\n" \
+      "Use Projection.init(initial_state) instead.",
+  )
+
+  Deprecations.register(
+    :projection_multiple_scopes,
+    "Passing multiple scopes to RubyEventStore::Projection#call is deprecated and will be removed in the next major release.\n" \
+      "Use a single scope instead, e.g. call(event_store.read.stream(\"stream_name\")).",
+  )
+
+  Deprecations.register(
+    :projection_old_api,
+    "RubyEventStore::Projection from_stream/from_all_streams/init/when/run API is deprecated and will be removed in the next major release.\n" \
+      "Use Projection.init(initial_state).on(EventClass) { |state, event| new_state }.call(scope) instead.",
+  )
+  Deprecations.deprecate_class_method(Projection, :from_stream, key: :projection_old_api)
+  Deprecations.deprecate_class_method(Projection, :from_all_streams, key: :projection_old_api)
+  Deprecations.deprecate(Projection, :init, key: :projection_old_api)
+  Deprecations.deprecate(Projection, :when, key: :projection_old_api)
+  Deprecations.deprecate(Projection, :run, key: :projection_old_api)
+
+  Deprecations.register(
+    :instrumentation_renamed,
+    "Instrumentation event names *.rails_event_store are deprecated and will be removed in the next major release.\n" \
+      "Use *.ruby_event_store instead.",
+  )
+
+  Deprecations.register(
+    :instrumented_mapper_serialize_deprecated,
+    "Instrumentation event names serialize.mapper.ruby_event_store and deserialize.mapper.ruby_event_store are deprecated and will be removed in the next major release.\n" \
+      "Use event_to_record.mapper.ruby_event_store and record_to_event.mapper.ruby_event_store instead.\n" \
+      "The domain_event: payload key in serialize.mapper.ruby_event_store has been renamed to event: in event_to_record.mapper.ruby_event_store.",
+  )
+
+  Deprecations.register(
+    :specification_in_batches_of,
+    "RubyEventStore::Specification#in_batches_of is deprecated and will be removed in the next major release.\n\n" \
+      "Use #in_batches instead.",
+  )
+  Deprecations.deprecate(Specification, :in_batches_of, key: :specification_in_batches_of)
+
+  Deprecations.register(
+    :specification_of_types,
+    "RubyEventStore::Specification#of_types is deprecated and will be removed in the next major release.\n\n" \
+      "Use #of_type instead.",
+  )
+  Deprecations.deprecate(Specification, :of_types, key: :specification_of_types)
+end

data/lib/ruby_event_store/deprecations.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "set"
+
+module RubyEventStore
+  module Deprecations
+    @suppressions = Set.new
+    @warnings = {}
+    @emitted = Set.new
+
+    class << self
+      def register(key, message)
+        @warnings[key] = message
+      end
+
+      def suppress(key)
+        @suppressions << key
+      end
+
+      def warn(key, message: nil)
+        return if @suppressions.include?(key)
+        return if @emitted.include?(key)
+        @emitted << key
+        Kernel.warn(
+          "[DEPRECATION] #{message || @warnings.fetch(key) { raise KeyError, "Deprecation :#{key} not registered. Call Deprecations.register first." }}",
+        )
+      end
+
+      def deprecate(klass, method_name, key:)
+        warn_key = key
+        is_private = klass.private_method_defined?(method_name)
+        this = self
+        wrapper =
+          Module.new do
+            define_method(method_name) do |*args, **kwargs, &block|
+              this.warn(warn_key)
+              super(*args, **kwargs, &block)
+            end
+            private(method_name) if is_private
+          end
+        klass.prepend(wrapper)
+      end
+
+      def deprecate_class_method(klass, method_name, key:)
+        warn_key = key
+        this = self
+        wrapper =
+          Module.new do
+            define_method(method_name) do |*args, **kwargs, &block|
+              this.warn(warn_key)
+              super(*args, **kwargs, &block)
+            end
+          end
+        klass.singleton_class.prepend(wrapper)
+      end
+
+      def reset!
+        @suppressions = Set.new
+        @emitted = Set.new
+      end
+    end
+  end
+end

data/lib/ruby_event_store/dispatcher.rb

@@ -2,11 +2,5 @@
 
 module RubyEventStore
   class Dispatcher < SyncScheduler
-    def initialize
-      warn <<~EOW
-        DEPRECATION WARNING: `RubyEventStore::Dispatcher` is deprecated and will be removed in the next major release.
-        Use `RubyEventStore::SyncScheduler` instead.
-      EOW
-    end
   end
 end

data/lib/ruby_event_store/immediate_async_dispatcher.rb

@@ -2,12 +2,5 @@
 
 module RubyEventStore
   class ImmediateAsyncDispatcher < ImmediateDispatcher
-    def initialize(scheduler:)
-      warn <<~EOW
-        DEPRECATION WARNING: `RubyEventStore::ImmediateAsyncDispatcher` is deprecated and will be removed in the next major release.
-        Use `RubyEventStore::ImmediateDispatcher` instead.
-      EOW
-      super
-    end
   end
 end

data/lib/ruby_event_store/in_memory_repository.rb

@@ -237,15 +237,13 @@ module RubyEventStore
       stream_positions = streams.fetch(stream.name, Array.new).map(&:position)
       violation =
         (resolved_version.nil? && !stream_positions.compact.empty?) ||
-        (!resolved_version.nil? && stream_positions.include?(nil))
+          (!resolved_version.nil? && stream_positions.include?(nil))
 
       if violation
         if @ensure_supported_any_usage
           raise UnsupportedVersionAnyUsage
         else
-          warn <<~EOW
-            Mixing expected version :any and specific position (or :auto) is deprecated and will raise UnsupportedVersionAnyUsage in RubyEventStore 3.0.
-          EOW
+          Deprecations.warn(:any_version_with_specific_position)
         end
       end
     end

data/lib/ruby_event_store/instrumented_broker.rb

@@ -2,12 +2,6 @@
 
 module RubyEventStore
   class InstrumentedBroker
-    DEPRECATION_MESSAGE = <<~EOW
-      Instrumentation event names *.rails_event_store are deprecated and will be removed in the next major release.
-      Use *.ruby_event_store instead.
-    EOW
-    private_constant :DEPRECATION_MESSAGE
-
     def initialize(broker, instrumentation)
       @broker = broker
       @instrumentation = instrumentation
@@ -52,9 +46,11 @@ module RubyEventStore
         subscriber: subscriber,
         topics: topics,
       ) do
-        deprecated_instrument("add_thread_subscription.broker.rails_event_store", subscriber: subscriber, topics: topics) do
-          broker.add_thread_subscription(subscriber, topics)
-        end
+        deprecated_instrument(
+          "add_thread_subscription.broker.rails_event_store",
+          subscriber: subscriber,
+          topics: topics,
+        ) { broker.add_thread_subscription(subscriber, topics) }
       end
     end
 
@@ -95,7 +91,7 @@ module RubyEventStore
       old_listeners = instrumentation.notifier.all_listeners_for(name)
       new_listeners = instrumentation.notifier.all_listeners_for(canonical_name)
       if (old_listeners - new_listeners).any?
-        warn DEPRECATION_MESSAGE
+        Deprecations.warn(:instrumentation_renamed)
         instrumentation.instrument(name, payload, &block)
       else
         yield

data/lib/ruby_event_store/instrumented_dispatcher.rb

@@ -2,12 +2,6 @@
 
 module RubyEventStore
   class InstrumentedDispatcher
-    DEPRECATION_MESSAGE = <<~EOW
-      Instrumentation event names *.rails_event_store are deprecated and will be removed in the next major release.
-      Use *.ruby_event_store instead.
-    EOW
-    private_constant :DEPRECATION_MESSAGE
-
     def initialize(dispatcher, instrumentation)
       @dispatcher = dispatcher
       @instrumentation = instrumentation
@@ -42,7 +36,7 @@ module RubyEventStore
       old_listeners = instrumentation.notifier.all_listeners_for(name)
       new_listeners = instrumentation.notifier.all_listeners_for(canonical_name)
       if (old_listeners - new_listeners).any?
-        warn DEPRECATION_MESSAGE
+        Deprecations.warn(:instrumentation_renamed)
         instrumentation.instrument(name, payload, &block)
       else
         yield

data/lib/ruby_event_store/instrumented_repository.rb

@@ -2,22 +2,22 @@
 
 module RubyEventStore
   class InstrumentedRepository
-    DEPRECATION_MESSAGE = <<~EOW
-      Instrumentation event names *.rails_event_store are deprecated and will be removed in the next major release.
-      Use *.ruby_event_store instead.
-    EOW
-    private_constant :DEPRECATION_MESSAGE
-
     def initialize(repository, instrumentation)
       @repository = repository
       @instrumentation = instrumentation
     end
 
     def append_to_stream(records, stream, expected_version)
-      instrumentation.instrument("append_to_stream.repository.ruby_event_store", records: records, events: records, stream: stream) do
-        deprecated_instrument("append_to_stream.repository.rails_event_store", { records: records, events: records, stream: stream }) do
-          repository.append_to_stream(records, stream, expected_version)
-        end
+      instrumentation.instrument(
+        "append_to_stream.repository.ruby_event_store",
+        records: records,
+        events: records,
+        stream: stream,
+      ) do
+        deprecated_instrument(
+          "append_to_stream.repository.rails_event_store",
+          { records: records, events: records, stream: stream },
+        ) { repository.append_to_stream(records, stream, expected_version) }
       end
     end
 
@@ -55,9 +55,10 @@ module RubyEventStore
 
     def update_messages(records)
       instrumentation.instrument("update_messages.repository.ruby_event_store", records: records, messages: records) do
-        deprecated_instrument("update_messages.repository.rails_event_store", { records: records, messages: records }) do
-          repository.update_messages(records)
-        end
+        deprecated_instrument(
+          "update_messages.repository.rails_event_store",
+          { records: records, messages: records },
+        ) { repository.update_messages(records) }
       end
     end
 
@@ -90,7 +91,7 @@ module RubyEventStore
       old_listeners = instrumentation.notifier.all_listeners_for(name)
       new_listeners = instrumentation.notifier.all_listeners_for(canonical_name)
       if (old_listeners - new_listeners).any?
-        warn DEPRECATION_MESSAGE
+        Deprecations.warn(:instrumentation_renamed)
         instrumentation.instrument(name, payload, &block)
       else
         yield

data/lib/ruby_event_store/mappers/default.rb

@@ -5,10 +5,7 @@ module RubyEventStore
     class Default < PipelineMapper
       def initialize(events_class_remapping: {})
         if events_class_remapping.any?
-          warn <<~EOW
-            DEPRECATION WARNING: `events_class_remapping` option in `RubyEventStore::Mappers::Default` is deprecated and will be removed in the next major release.
-            Use `RubyEventStore::Mappers::Transformation::Upcast` instead.
-          EOW
+          Deprecations.warn(:events_class_remapping_option)
           super(
             Pipeline.new(
               Transformation::EventClassRemapper.new(events_class_remapping),

data/lib/ruby_event_store/mappers/instrumented_batch_mapper.rb

@@ -3,12 +3,6 @@
 module RubyEventStore
   module Mappers
     class InstrumentedBatchMapper
-      DEPRECATION_MESSAGE = <<~EOW
-        Instrumentation event names *.rails_event_store are deprecated and will be removed in the next major release.
-        Use *.ruby_event_store instead.
-      EOW
-      private_constant :DEPRECATION_MESSAGE
-
       def initialize(mapper, instrumentation)
         @mapper = mapper
         @instrumentation = instrumentation
@@ -39,7 +33,7 @@ module RubyEventStore
         old_listeners = instrumentation.notifier.all_listeners_for(name)
         new_listeners = instrumentation.notifier.all_listeners_for(canonical_name)
         if (old_listeners - new_listeners).any?
-          warn DEPRECATION_MESSAGE
+          Deprecations.warn(:instrumentation_renamed)
           instrumentation.instrument(name, payload, &block)
         else
           yield

data/lib/ruby_event_store/mappers/instrumented_mapper.rb

@@ -3,19 +3,6 @@
 module RubyEventStore
   module Mappers
     class InstrumentedMapper
-      DEPRECATION_MESSAGE = <<~EOW
-        Instrumentation event names *.rails_event_store are deprecated and will be removed in the next major release.
-        Use *.ruby_event_store instead.
-      EOW
-      private_constant :DEPRECATION_MESSAGE
-
-      RENAME_DEPRECATION_MESSAGE = <<~EOW
-        Instrumentation event names serialize.mapper.ruby_event_store and deserialize.mapper.ruby_event_store are deprecated and will be removed in the next major release.
-        Use event_to_record.mapper.ruby_event_store and record_to_event.mapper.ruby_event_store instead.
-        The domain_event: payload key in serialize.mapper.ruby_event_store has been renamed to event: in event_to_record.mapper.ruby_event_store.
-      EOW
-      private_constant :RENAME_DEPRECATION_MESSAGE
-
       def initialize(mapper, instrumentation)
         @mapper = mapper
         @instrumentation = instrumentation
@@ -23,9 +10,12 @@ module RubyEventStore
 
       def event_to_record(event)
         instrumentation.instrument("event_to_record.mapper.ruby_event_store", event: event) do
-          deprecated_instrument("serialize.mapper.ruby_event_store", { domain_event: event },
-                                canonical: "event_to_record.mapper.ruby_event_store",
-                                message: RENAME_DEPRECATION_MESSAGE) do
+          deprecated_instrument(
+            "serialize.mapper.ruby_event_store",
+            { domain_event: event },
+            canonical: "event_to_record.mapper.ruby_event_store",
+            key: :instrumented_mapper_serialize_deprecated,
+          ) do
             deprecated_instrument("serialize.mapper.rails_event_store", { domain_event: event }) do
               mapper.event_to_record(event)
             end
@@ -35,9 +25,12 @@ module RubyEventStore
 
       def record_to_event(record)
         instrumentation.instrument("record_to_event.mapper.ruby_event_store", record: record) do
-          deprecated_instrument("deserialize.mapper.ruby_event_store", { record: record },
-                                canonical: "record_to_event.mapper.ruby_event_store",
-                                message: RENAME_DEPRECATION_MESSAGE) do
+          deprecated_instrument(
+            "deserialize.mapper.ruby_event_store",
+            { record: record },
+            canonical: "record_to_event.mapper.ruby_event_store",
+            key: :instrumented_mapper_serialize_deprecated,
+          ) do
             deprecated_instrument("deserialize.mapper.rails_event_store", { record: record }) do
               mapper.record_to_event(record)
             end
@@ -49,12 +42,12 @@ module RubyEventStore
 
       attr_reader :instrumentation, :mapper
 
-      def deprecated_instrument(name, payload, canonical: nil, message: DEPRECATION_MESSAGE, &block)
+      def deprecated_instrument(name, payload, canonical: nil, key: :instrumentation_renamed, &block)
         canonical_name = canonical || name.sub("rails_event_store", "ruby_event_store")
         old_listeners = instrumentation.notifier.all_listeners_for(name)
         new_listeners = instrumentation.notifier.all_listeners_for(canonical_name)
         if (old_listeners - new_listeners).any?
-          warn message
+          Deprecations.warn(key)
           instrumentation.instrument(name, payload, &block)
         else
           yield

data/lib/ruby_event_store/mappers/null_mapper.rb

@@ -4,10 +4,6 @@ module RubyEventStore
   module Mappers
     class NullMapper < PipelineMapper
       def initialize
-        warn <<~EOW
-          DEPRECATION WARNING: `RubyEventStore::Mappers::NullMapper` is deprecated and will be removed in the next major release.
-          Use `RubyEventStore::Mappers::Default.new` instead.
-        EOW
         super(Pipeline.new)
       end
     end

data/lib/ruby_event_store/mappers/transformation/event_class_remapper.rb

@@ -5,10 +5,6 @@ module RubyEventStore
     module Transformation
       class EventClassRemapper
         def initialize(class_map)
-          warn <<~EOW
-            DEPRECATION WARNING: `RubyEventStore::Mappers::Transformation::EventClassRemapper` is deprecated and will be removed in the next major release.
-            Use `RubyEventStore::Mappers::Transformation::Upcast` instead.
-          EOW
           @class_map = class_map
         end
 

data/lib/ruby_event_store/projection.rb

@@ -3,22 +3,10 @@
 module RubyEventStore
   class Projection
     ANONYMOUS_CLASS = "#<Class:".freeze
-    DEPRECATION_MESSAGE = <<~EOW
-      RubyEventStore::Projection from_stream/from_all_streams/init/when/run API is deprecated and will be removed in the next major release.
-      Use Projection.init(initial_state).on(EventClass) { |state, event| new_state }.call(scope) instead.
-    EOW
-    MULTI_SCOPE_DEPRECATION_MESSAGE = <<~EOW
-      Passing multiple scopes to RubyEventStore::Projection#call is deprecated and will be removed in the next major release.
-      Use a single scope instead, e.g. call(event_store.read.stream("stream_name")).
-    EOW
-    NEW_CONSTRUCTOR_DEPRECATION_MESSAGE = <<~EOW
-      RubyEventStore::Projection.new is deprecated and will be removed in the next major release.
-      Use Projection.init(initial_state) instead.
-    EOW
-    private_constant :ANONYMOUS_CLASS, :DEPRECATION_MESSAGE, :MULTI_SCOPE_DEPRECATION_MESSAGE, :NEW_CONSTRUCTOR_DEPRECATION_MESSAGE
+    private_constant :ANONYMOUS_CLASS
 
     def initialize(initial_state = nil, _internal: false)
-      warn NEW_CONSTRUCTOR_DEPRECATION_MESSAGE unless _internal
+      Deprecations.warn(:projection_new_constructor) unless _internal
       @handlers = {}
       @init = -> { initial_state }
       @streams = []
@@ -43,15 +31,12 @@ module RubyEventStore
     def call(*scopes)
       return initial_state if handled_events.empty?
 
-      warn MULTI_SCOPE_DEPRECATION_MESSAGE if scopes.size > 1
+      Deprecations.warn(:projection_multiple_scopes) if scopes.size > 1
 
-      scopes.reduce(initial_state) do |state, scope|
-        scope.of_type(handled_events).reduce(state, &method(:transition))
-      end
+      scopes.reduce(initial_state) { |state, scope| scope.of_type(handled_events).reduce(state, &method(:transition)) }
     end
 
     def self.from_stream(stream_or_streams)
-      warn DEPRECATION_MESSAGE
       streams = Array(stream_or_streams)
       raise(ArgumentError, "At least one stream must be given") if streams.empty?
       projection = new(_internal: true)
@@ -60,36 +45,36 @@ module RubyEventStore
     end
 
     def self.from_all_streams
-      warn DEPRECATION_MESSAGE
       new(_internal: true)
     end
 
     def init(handler)
-      warn DEPRECATION_MESSAGE
       @init = handler
       self
     end
 
     def when(events, handler)
-      warn DEPRECATION_MESSAGE
       Array(events).each do |event_klass|
         name = event_klass.to_s
-        @handlers[name] = ->(state, event) { handler.call(state, event); state }
+        @handlers[name] = ->(state, event) do
+          handler.call(state, event)
+          state
+        end
       end
       self
     end
 
     def run(event_store, start: nil, count: PAGE_SIZE)
-      warn DEPRECATION_MESSAGE
-
       if @streams.any?
         raise ArgumentError, "Start must be an array with event ids" unless valid_start_for_streams?(start)
         scopes =
-          @streams.zip(start || []).map do |stream, start_event_id|
-            scope = event_store.read.stream(stream).in_batches(count)
-            scope = scope.from(start_event_id) if start_event_id
-            scope
-          end
+          @streams
+            .zip(start || [])
+            .map do |stream, start_event_id|
+              scope = event_store.read.stream(stream).in_batches(count)
+              scope = scope.from(start_event_id) if start_event_id
+              scope
+            end
       else
         raise ArgumentError, "Start must be valid event id" unless valid_start_for_all_streams?(start)
         scope = event_store.read.in_batches(count)

data/lib/ruby_event_store/specification.rb

@@ -246,11 +246,6 @@ module RubyEventStore
     end
 
     def in_batches_of(batch_size = DEFAULT_BATCH_SIZE)
-      warn <<~EOW
-        RubyEventStore::Specification#in_batches_of is deprecated and will be removed in the next major release.
-
-        Use #in_batches instead.
-      EOW
       in_batches(batch_size)
     end
 
@@ -298,11 +293,6 @@ module RubyEventStore
     end
 
     def of_types(*types)
-      warn <<~EOW
-        RubyEventStore::Specification#of_types is deprecated and will be removed in the next major release.
-
-        Use #of_type instead.
-      EOW
       of_type(*types)
     end
 

data/lib/ruby_event_store/sync_scheduler.rb

@@ -2,14 +2,9 @@
 
 module RubyEventStore
   class SyncScheduler
-    DEPRECATION_MESSAGE = <<~EOW
-      DEPRECATION WARNING: Passing a class as a subscriber is deprecated and will be removed in the next major release.
-      Pass an instance or lambda instead, e.g. subscribe(MyHandler.new, to: [MyEvent]).
-    EOW
-
     def call(subscriber, event, _)
       if Class === subscriber
-        warn DEPRECATION_MESSAGE
+        Deprecations.warn(:class_subscriber)
         subscriber = subscriber.new
       end
       subscriber.call(event)
@@ -17,7 +12,7 @@ module RubyEventStore
 
     def verify(subscriber)
       if Class === subscriber
-        warn DEPRECATION_MESSAGE
+        Deprecations.warn(:class_subscriber)
         begin
           subscriber.new.respond_to?(:call)
         rescue ArgumentError

data/lib/ruby_event_store/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyEventStore
-  VERSION = "2.19.1"
+  VERSION = "2.19.2"
 end

data/lib/ruby_event_store.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "ruby_event_store/deprecations"
 require_relative "ruby_event_store/sync_scheduler"
 require_relative "ruby_event_store/dispatcher"
 require_relative "ruby_event_store/subscriptions"
@@ -53,3 +54,4 @@ require_relative "ruby_event_store/instrumented_dispatcher"
 require_relative "ruby_event_store/instrumented_subscriptions"
 require_relative "ruby_event_store/instrumented_broker"
 require_relative "ruby_event_store/event_type_resolver"
+require_relative "ruby_event_store/deprecated"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_event_store
 version: !ruby/object:Gem::Version
-  version: 2.19.1
+  version: 2.19.2
 platform: ruby
 authors:
 - Arkency
@@ -47,6 +47,8 @@ files:
 - lib/ruby_event_store/composed_dispatcher.rb
 - lib/ruby_event_store/constants.rb
 - lib/ruby_event_store/correlated_commands.rb
+- lib/ruby_event_store/deprecated.rb
+- lib/ruby_event_store/deprecations.rb
 - lib/ruby_event_store/dispatcher.rb
 - lib/ruby_event_store/errors.rb
 - lib/ruby_event_store/event.rb
@@ -123,7 +125,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Implementation of an event store in Ruby
 test_files: []