ruby_event_store 2.19.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce9224b921ed7a88f7c7d6b35875ae497d0980b63b2088877d34a830678d812e
-  data.tar.gz: 26dfca582631ed9e9e91d1ff35857052bb52de9cbff9ebdf3f27022a67ebb24a
+  metadata.gz: 05b8bd1227176e2a6d41cd4429f90f79a47ce98c13b03e81ba24cf6b61f0a118
+  data.tar.gz: 5100c038a126708538e6a9eecac435dacb9b58d2c0feacb9689daaab2217439c
 SHA512:
-  metadata.gz: 55c6aa28f09507bee217fd58e979dab0e3962343fafb6b72ccf579c0fe1c4f4e828f6cff0aeb4ee89e94f4a6ffedf9069a14a267fe45c9cc021495d87f3cb10d
-  data.tar.gz: d60413a68772516d46b8c9ab7812dc6572d7da1b8b706d339a6a864290914048c3a78b0c6386ae5abe9bff947a0a11f6dae903e91a4d1226de06038741ca7cd9
+  metadata.gz: 176ada1f03146d76a5a58ae8f7803fe029dd0fb265fa94b15da5412e7c98689b8be388ef977f77cdb56b54be3f4b420b6ffc291547f56b74136a9456f2c7341a
+  data.tar.gz: fd9befc69d34e4ca120520c4e0724b2dc031adfe2f9f35dc4a9f52e2d8977f61424988b85fd5c00983d228701bf5a10d628f7aa50be6c96f75507f5a63252760

data/lib/ruby_event_store/broker.rb

@@ -2,7 +2,7 @@
 
 module RubyEventStore
   class Broker
-    def initialize(subscriptions: Subscriptions.new, dispatcher: Dispatcher.new)
+    def initialize(subscriptions: Subscriptions.new, dispatcher: SyncScheduler.new)
       @subscriptions = subscriptions
       @dispatcher = dispatcher
     end

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,7 @@ 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
-          Passing `nil` to link is deprecated and will raise ArgumentError in RubyEventStore 3.0.
-        EOW
-      end
+      raise ArgumentError, "event_ids must not be nil" if event_ids.nil? || Array(event_ids).any?(&:nil?)
       @repository.link_to_stream(Array(event_ids), Stream.new(stream_name), ExpectedVersion.new(expected_version))
       self
     end
@@ -385,11 +382,7 @@ module RubyEventStore
     end
 
     def enrich_events_metadata(events)
-      if events.nil? || Array(events).any?(&:nil?)
-        warn <<~EOW
-          Passing `nil` to publish/append is deprecated and will raise ArgumentError in RubyEventStore 3.0.
-        EOW
-      end
+      raise ArgumentError, "events must not be nil" if events.nil? || Array(events).any?(&:nil?)
       events = Array(events)
       events.each { |event| enrich_event_metadata(event) }
     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/in_memory_repository.rb

@@ -22,12 +22,11 @@ module RubyEventStore
       attr_reader :event_id, :position
     end
 
-    def initialize(serializer: NULL, ensure_supported_any_usage: false)
+    def initialize(serializer: NULL)
       @serializer = serializer
       @streams = Hash.new { |h, k| h[k] = Array.new }
       @mutex = Mutex.new
       @storage = Hash.new
-      @ensure_supported_any_usage = ensure_supported_any_usage
     end
 
     def append_to_stream(records, stream, expected_version)
@@ -237,17 +236,9 @@ 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))
-
-      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
-        end
-      end
+          (!resolved_version.nil? && stream_positions.include?(nil))
+
+      raise UnsupportedVersionAnyUsage if violation
     end
 
     attr_reader :streams, :mutex, :storage, :serializer

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
@@ -15,34 +9,28 @@ module RubyEventStore
 
     def call(topic, event, record)
       instrumentation.instrument("call.broker.ruby_event_store", topic: topic, event: event, record: record) do
-        deprecated_instrument("call.broker.rails_event_store", topic: topic, event: event, record: record) do
-          if broker.public_method(:call).arity == 3
-            broker.call(topic, event, record)
-          else
-            warn <<~EOW
-              Message broker shall support topics.
-              Topic WILL BE IGNORED in the current broker.
-              Modify the broker implementation to pass topic as an argument to broker.call method.
-            EOW
-            broker.call(event, record)
-          end
+        if broker.public_method(:call).arity == 3
+          broker.call(topic, event, record)
+        else
+          warn <<~EOW
+            Message broker shall support topics.
+            Topic WILL BE IGNORED in the current broker.
+            Modify the broker implementation to pass topic as an argument to broker.call method.
+          EOW
+          broker.call(event, record)
         end
       end
     end
 
     def add_subscription(subscriber, topics)
       instrumentation.instrument("add_subscription.broker.ruby_event_store", subscriber: subscriber, topics: topics) do
-        deprecated_instrument("add_subscription.broker.rails_event_store", subscriber: subscriber, topics: topics) do
-          broker.add_subscription(subscriber, topics)
-        end
+        broker.add_subscription(subscriber, topics)
       end
     end
 
     def add_global_subscription(subscriber)
       instrumentation.instrument("add_global_subscription.broker.ruby_event_store", subscriber: subscriber) do
-        deprecated_instrument("add_global_subscription.broker.rails_event_store", subscriber: subscriber) do
-          broker.add_global_subscription(subscriber)
-        end
+        broker.add_global_subscription(subscriber)
       end
     end
 
@@ -51,26 +39,18 @@ module RubyEventStore
         "add_thread_subscription.broker.ruby_event_store",
         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
-      end
+      ) { broker.add_thread_subscription(subscriber, topics) }
     end
 
     def add_thread_global_subscription(subscriber)
       instrumentation.instrument("add_thread_global_subscription.broker.ruby_event_store", subscriber: subscriber) do
-        deprecated_instrument("add_thread_global_subscription.broker.rails_event_store", subscriber: subscriber) do
-          broker.add_thread_global_subscription(subscriber)
-        end
+        broker.add_thread_global_subscription(subscriber)
       end
     end
 
     def all_subscriptions_for(topic)
       instrumentation.instrument("all_subscriptions_for.broker.ruby_event_store", topic: topic) do
-        deprecated_instrument("all_subscriptions_for.broker.rails_event_store", topic: topic) do
-          broker.all_subscriptions_for(topic)
-        end
+        broker.all_subscriptions_for(topic)
       end
     end
 
@@ -89,17 +69,5 @@ module RubyEventStore
     private
 
     attr_reader :instrumentation, :broker
-
-    def deprecated_instrument(name, payload, &block)
-      canonical_name = 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 DEPRECATION_MESSAGE
-        instrumentation.instrument(name, payload, &block)
-      else
-        yield
-      end
-    end
   end
 end

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
@@ -15,9 +9,7 @@ module RubyEventStore
 
     def call(subscriber, event, record)
       instrumentation.instrument("call.dispatcher.ruby_event_store", event: event, subscriber: subscriber) do
-        deprecated_instrument("call.dispatcher.rails_event_store", event: event, subscriber: subscriber) do
-          dispatcher.call(subscriber, event, record)
-        end
+        dispatcher.call(subscriber, event, record)
       end
     end
 
@@ -36,17 +28,5 @@ module RubyEventStore
     private
 
     attr_reader :instrumentation, :dispatcher
-
-    def deprecated_instrument(name, payload, &block)
-      canonical_name = 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 DEPRECATION_MESSAGE
-        instrumentation.instrument(name, payload, &block)
-      else
-        yield
-      end
-    end
   end
 end

data/lib/ruby_event_store/instrumented_repository.rb

@@ -2,70 +2,52 @@
 
 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
-      end
+      instrumentation.instrument(
+        "append_to_stream.repository.ruby_event_store",
+        records: records,
+        stream: stream,
+      ) { repository.append_to_stream(records, stream, expected_version) }
     end
 
     def link_to_stream(event_ids, stream, expected_version)
       instrumentation.instrument("link_to_stream.repository.ruby_event_store", event_ids: event_ids, stream: stream) do
-        deprecated_instrument("link_to_stream.repository.rails_event_store", event_ids: event_ids, stream: stream) do
-          repository.link_to_stream(event_ids, stream, expected_version)
-        end
+        repository.link_to_stream(event_ids, stream, expected_version)
       end
     end
 
     def delete_stream(stream)
       instrumentation.instrument("delete_stream.repository.ruby_event_store", stream: stream) do
-        deprecated_instrument("delete_stream.repository.rails_event_store", stream: stream) do
-          repository.delete_stream(stream)
-        end
+        repository.delete_stream(stream)
       end
     end
 
     def read(specification)
       instrumentation.instrument("read.repository.ruby_event_store", specification: specification) do
-        deprecated_instrument("read.repository.rails_event_store", specification: specification) do
-          repository.read(specification)
-        end
+        repository.read(specification)
       end
     end
 
     def count(specification)
       instrumentation.instrument("count.repository.ruby_event_store", specification: specification) do
-        deprecated_instrument("count.repository.rails_event_store", specification: specification) do
-          repository.count(specification)
-        end
+        repository.count(specification)
       end
     end
 
     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
+      instrumentation.instrument("update_messages.repository.ruby_event_store", records: records) do
+        repository.update_messages(records)
       end
     end
 
     def streams_of(event_id)
       instrumentation.instrument("streams_of.repository.ruby_event_store", event_id: event_id) do
-        deprecated_instrument("streams_of.repository.rails_event_store", event_id: event_id) do
-          repository.streams_of(event_id)
-        end
+        repository.streams_of(event_id)
       end
     end
 
@@ -84,17 +66,5 @@ module RubyEventStore
     private
 
     attr_reader :repository, :instrumentation
-
-    def deprecated_instrument(name, payload, &block)
-      canonical_name = 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 DEPRECATION_MESSAGE
-        instrumentation.instrument(name, payload, &block)
-      else
-        yield
-      end
-    end
   end
 end

data/lib/ruby_event_store/instrumented_subscriptions.rb

@@ -42,9 +42,9 @@ module RubyEventStore
     private
 
     def instrument(args)
-      instrumentation.instrument("add.subscriptions.rails_event_store", args) do
+      instrumentation.instrument("add.subscriptions.ruby_event_store", args) do
         unsubscribe = yield
-        -> { instrumentation.instrument("remove.subscriptions.rails_event_store", args) { unsubscribe.call } }
+        -> { instrumentation.instrument("remove.subscriptions.ruby_event_store", args) { unsubscribe.call } }
       end
     end
 

data/lib/ruby_event_store/mappers/default.rb

@@ -3,21 +3,8 @@
 module RubyEventStore
   module Mappers
     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
-          super(
-            Pipeline.new(
-              Transformation::EventClassRemapper.new(events_class_remapping),
-              Transformation::SymbolizeMetadataKeys.new,
-            ),
-          )
-        else
-          super(Pipeline.new(Transformation::SymbolizeMetadataKeys.new))
-        end
+      def initialize
+        super(Pipeline.new(Transformation::SymbolizeMetadataKeys.new))
       end
     end
   end

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
@@ -16,35 +10,19 @@ module RubyEventStore
 
       def events_to_records(events)
         instrumentation.instrument("events_to_records.mapper.ruby_event_store", domain_events: events) do
-          deprecated_instrument("events_to_records.mapper.rails_event_store", domain_events: events) do
-            mapper.events_to_records(events)
-          end
+          mapper.events_to_records(events)
         end
       end
 
       def records_to_events(records)
         instrumentation.instrument("records_to_events.mapper.ruby_event_store", records: records) do
-          deprecated_instrument("records_to_events.mapper.rails_event_store", records: records) do
-            mapper.records_to_events(records)
-          end
+          mapper.records_to_events(records)
         end
       end
 
       private
 
       attr_reader :instrumentation, :mapper
-
-      def deprecated_instrument(name, payload, &block)
-        canonical_name = 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 DEPRECATION_MESSAGE
-          instrumentation.instrument(name, payload, &block)
-        else
-          yield
-        end
-      end
     end
   end
 end

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,43 +10,19 @@ 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.rails_event_store", { domain_event: event }) do
-              mapper.event_to_record(event)
-            end
-          end
+          mapper.event_to_record(event)
         end
       end
 
       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.rails_event_store", { record: record }) do
-              mapper.record_to_event(record)
-            end
-          end
+          mapper.record_to_event(record)
         end
       end
 
       private
 
       attr_reader :instrumentation, :mapper
-
-      def deprecated_instrument(name, payload, canonical: nil, message: DEPRECATION_MESSAGE, &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
-          instrumentation.instrument(name, payload, &block)
-        else
-          yield
-        end
-      end
     end
   end
 end

data/lib/ruby_event_store/projection.rb

@@ -3,29 +3,17 @@
 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
-      @handlers = {}
-      @init = -> { initial_state }
-      @streams = []
-    end
+    private_class_method :new
 
     def self.init(initial_state = nil)
-      new(initial_state, _internal: true)
+      new(initial_state)
+    end
+
+    def initialize(initial_state)
+      @handlers = {}
+      @init = -> { initial_state }
     end
 
     def on(*event_klasses, &block)
@@ -40,64 +28,10 @@ module RubyEventStore
       self
     end
 
-    def call(*scopes)
+    def call(scope)
       return initial_state if handled_events.empty?
 
-      warn MULTI_SCOPE_DEPRECATION_MESSAGE if scopes.size > 1
-
-      scopes.reduce(initial_state) do |state, scope|
-        scope.of_type(handled_events).reduce(state, &method(:transition))
-      end
-    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)
-      projection.instance_variable_set(:@streams, streams)
-      projection
-    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 }
-      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
-      else
-        raise ArgumentError, "Start must be valid event id" unless valid_start_for_all_streams?(start)
-        scope = event_store.read.in_batches(count)
-        scope = scope.from(start) if start
-        scopes = [scope]
-      end
-
-      call(*scopes)
+      scope.of_type(handled_events).reduce(initial_state, &method(:transition))
     end
 
     private
@@ -113,15 +47,5 @@ module RubyEventStore
     def transition(state, event)
       @handlers.fetch(event.event_type).call(state, event)
     end
-
-    def valid_start_for_streams?(start)
-      return true unless start
-      start.instance_of?(Array) && start.size == @streams.size
-    end
-
-    def valid_start_for_all_streams?(start)
-      return true unless start
-      start.instance_of?(String)
-    end
   end
 end

data/lib/ruby_event_store/spec/broker_lint.rb

@@ -5,7 +5,7 @@ RSpec.shared_examples "broker" do |broker_klass|
   let(:record) { instance_double(::RubyEventStore::Record) }
   let(:handler) { HandlerClass.new }
   let(:subscriptions) { ::RubyEventStore::Subscriptions.new }
-  let(:dispatcher) { ::RubyEventStore::Dispatcher.new }
+  let(:dispatcher) { ::RubyEventStore::SyncScheduler.new }
   let(:broker) { broker_klass.new(subscriptions: subscriptions, dispatcher: dispatcher) }
 
   specify "no dispatch when no subscriptions" do
@@ -56,7 +56,7 @@ RSpec.shared_examples "broker" do |broker_klass|
     allow(dispatcher).to receive(:verify).and_return(false)
     expect { broker.add_subscription(HandlerClass, []) }.to raise_error(
       RubyEventStore::InvalidHandler,
-      /Handler HandlerClass is invalid for dispatcher .*Dispatcher/,
+      /Handler HandlerClass is invalid for dispatcher .*SyncScheduler/,
     )
     expect { broker.add_global_subscription(HandlerClass) }.to raise_error(
       RubyEventStore::InvalidHandler,

data/lib/ruby_event_store/specification.rb

@@ -245,15 +245,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
-
     # Specifies that only first event should be read.
     # {https://railseventstore.org/docs/core-concepts/read Find out more}.
     #
@@ -297,15 +288,6 @@ module RubyEventStore
       Specification.new(reader, result.dup { |r| r.with_types = types.flatten })
     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
-
     # Limits the query to certain events by given even ids.
     # {https://railseventstore.org/docs/core-concepts/read Find out more}.
     #

data/lib/ruby_event_store/sync_scheduler.rb

@@ -2,30 +2,12 @@
 
 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
-        subscriber = subscriber.new
-      end
       subscriber.call(event)
     end
 
     def verify(subscriber)
-      if Class === subscriber
-        warn DEPRECATION_MESSAGE
-        begin
-          subscriber.new.respond_to?(:call)
-        rescue ArgumentError
-          false
-        end
-      else
-        subscriber.respond_to?(:call)
-      end
+      subscriber.respond_to?(:call)
     end
   end
 end

data/lib/ruby_event_store/version.rb

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

data/lib/ruby_event_store.rb

@@ -1,7 +1,7 @@
 # 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"
 require_relative "ruby_event_store/broker"
 require_relative "ruby_event_store/in_memory_repository"
@@ -24,7 +24,6 @@ require_relative "ruby_event_store/mappers/encryption_key"
 require_relative "ruby_event_store/mappers/in_memory_encryption_key_repository"
 require_relative "ruby_event_store/mappers/transformation/domain_event"
 require_relative "ruby_event_store/mappers/transformation/encryption"
-require_relative "ruby_event_store/mappers/transformation/event_class_remapper"
 require_relative "ruby_event_store/mappers/transformation/upcast"
 require_relative "ruby_event_store/mappers/transformation/stringify_metadata_keys"
 require_relative "ruby_event_store/mappers/transformation/symbolize_metadata_keys"
@@ -37,14 +36,11 @@ require_relative "ruby_event_store/mappers/forgotten_data"
 require_relative "ruby_event_store/mappers/encryption_mapper"
 require_relative "ruby_event_store/mappers/instrumented_mapper"
 require_relative "ruby_event_store/mappers/instrumented_batch_mapper"
-require_relative "ruby_event_store/mappers/json_mapper"
-require_relative "ruby_event_store/mappers/null_mapper"
 require_relative "ruby_event_store/serializers/yaml"
 require_relative "ruby_event_store/batch_enumerator"
 require_relative "ruby_event_store/correlated_commands"
 require_relative "ruby_event_store/link_by_metadata"
 require_relative "ruby_event_store/immediate_dispatcher"
-require_relative "ruby_event_store/immediate_async_dispatcher"
 require_relative "ruby_event_store/composed_dispatcher"
 require_relative "ruby_event_store/composed_broker"
 require_relative "ruby_event_store/version"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_event_store
 version: !ruby/object:Gem::Version
-  version: 2.19.1
+  version: 3.0.0
 platform: ruby
 authors:
 - Arkency
@@ -47,12 +47,11 @@ 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/dispatcher.rb
+- lib/ruby_event_store/deprecations.rb
 - lib/ruby_event_store/errors.rb
 - lib/ruby_event_store/event.rb
 - lib/ruby_event_store/event_type_resolver.rb
 - lib/ruby_event_store/expected_version.rb
-- lib/ruby_event_store/immediate_async_dispatcher.rb
 - lib/ruby_event_store/immediate_dispatcher.rb
 - lib/ruby_event_store/in_memory_repository.rb
 - lib/ruby_event_store/instrumented_broker.rb
@@ -68,13 +67,10 @@ files:
 - lib/ruby_event_store/mappers/in_memory_encryption_key_repository.rb
 - lib/ruby_event_store/mappers/instrumented_batch_mapper.rb
 - lib/ruby_event_store/mappers/instrumented_mapper.rb
-- lib/ruby_event_store/mappers/json_mapper.rb
-- lib/ruby_event_store/mappers/null_mapper.rb
 - lib/ruby_event_store/mappers/pipeline.rb
 - lib/ruby_event_store/mappers/pipeline_mapper.rb
 - lib/ruby_event_store/mappers/transformation/domain_event.rb
 - lib/ruby_event_store/mappers/transformation/encryption.rb
-- lib/ruby_event_store/mappers/transformation/event_class_remapper.rb
 - lib/ruby_event_store/mappers/transformation/preserve_types.rb
 - lib/ruby_event_store/mappers/transformation/stringify_metadata_keys.rb
 - lib/ruby_event_store/mappers/transformation/symbolize_metadata_keys.rb
@@ -123,7 +119,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 3.7.1
 specification_version: 4
 summary: Implementation of an event store in Ruby
 test_files: []

data/lib/ruby_event_store/dispatcher.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-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

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-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/mappers/json_mapper.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module RubyEventStore
-  module Mappers
-    class JSONMapper < Default
-      def initialize(events_class_remapping: {})
-        warn <<~EOW
-          Please replace RubyEventStore::Mappers::JSONMapper with RubyEventStore::Mappers::Default
-
-          They're now identical and the former will be removed in next major release.
-        EOW
-        super
-      end
-    end
-  end
-end

data/lib/ruby_event_store/mappers/null_mapper.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-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
-  end
-end

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

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module RubyEventStore
-  module Mappers
-    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
-
-        def dump(record)
-          record
-        end
-
-        def load(record)
-          Record.new(
-            event_id: record.event_id,
-            event_type: class_map[record.event_type] || record.event_type,
-            data: record.data,
-            metadata: record.metadata,
-            timestamp: record.timestamp,
-            valid_at: record.valid_at,
-          )
-        end
-
-        private
-
-        attr_reader :class_map
-      end
-    end
-  end
-end