ruby_event_store 2.19.2 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a38be596490cc7feffdf26968a8175a2a1606ba567f448382b2aecfe2e78ebd9
-  data.tar.gz: c64882bef174236d979680f84ed1d16b37f8ef2ba2a48b50a49d55286cff523e
+  metadata.gz: 05b8bd1227176e2a6d41cd4429f90f79a47ce98c13b03e81ba24cf6b61f0a118
+  data.tar.gz: 5100c038a126708538e6a9eecac435dacb9b58d2c0feacb9689daaab2217439c
 SHA512:
-  metadata.gz: 07a6509f6ac818e525834d0bae05b297ef2802643fee60cc45024cf3ea2faf49744f26dfe31896be18274dfc83e4a6be62abef1cb6faa27c67b8de8664998d11
-  data.tar.gz: f4846eedf860127e23bcdc38c37b13028896b39836a3af75689943de59bbdf633d7b2dd0e30cade9728486710cc2395db99ec4adef98a60fcfbdb4c494724e3f
+  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

@@ -99,9 +99,7 @@ module RubyEventStore
     # @param expected_version (see #publish)
     # @return [self]
     def link(event_ids, stream_name:, expected_version: :any)
-      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
+      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
@@ -384,9 +382,7 @@ module RubyEventStore
     end
 
     def enrich_events_metadata(events)
-      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
+      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/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)
@@ -239,13 +238,7 @@ module RubyEventStore
         (resolved_version.nil? && !stream_positions.compact.empty?) ||
           (!resolved_version.nil? && stream_positions.include?(nil))
 
-      if violation
-        if @ensure_supported_any_usage
-          raise UnsupportedVersionAnyUsage
-        else
-          Deprecations.warn(:any_version_with_specific_position)
-        end
-      end
+      raise UnsupportedVersionAnyUsage if violation
     end
 
     attr_reader :streams, :mutex, :storage, :serializer

data/lib/ruby_event_store/instrumented_broker.rb

@@ -9,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
 
@@ -45,28 +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,
-        ) { broker.add_thread_subscription(subscriber, topics) }
-      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
 
@@ -85,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?
-        Deprecations.warn(:instrumentation_renamed)
-        instrumentation.instrument(name, payload, &block)
-      else
-        yield
-      end
-    end
   end
 end

data/lib/ruby_event_store/instrumented_dispatcher.rb

@@ -9,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
 
@@ -30,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?
-        Deprecations.warn(:instrumentation_renamed)
-        instrumentation.instrument(name, payload, &block)
-      else
-        yield
-      end
-    end
   end
 end

data/lib/ruby_event_store/instrumented_repository.rb

@@ -11,62 +11,43 @@ module RubyEventStore
       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
+      ) { 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 },
-        ) { repository.update_messages(records) }
+      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
 
@@ -85,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?
-        Deprecations.warn(:instrumentation_renamed)
-        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,18 +3,8 @@
 module RubyEventStore
   module Mappers
     class Default < PipelineMapper
-      def initialize(events_class_remapping: {})
-        if events_class_remapping.any?
-          Deprecations.warn(:events_class_remapping_option)
-          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

@@ -10,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?
-          Deprecations.warn(:instrumentation_renamed)
-          instrumentation.instrument(name, payload, &block)
-        else
-          yield
-        end
-      end
     end
   end
 end

data/lib/ruby_event_store/mappers/instrumented_mapper.rb

@@ -10,49 +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",
-            key: :instrumented_mapper_serialize_deprecated,
-          ) 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",
-            key: :instrumented_mapper_serialize_deprecated,
-          ) 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, 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?
-          Deprecations.warn(key)
-          instrumentation.instrument(name, payload, &block)
-        else
-          yield
-        end
-      end
     end
   end
 end

data/lib/ruby_event_store/projection.rb

@@ -5,15 +5,15 @@ module RubyEventStore
     ANONYMOUS_CLASS = "#<Class:".freeze
     private_constant :ANONYMOUS_CLASS
 
-    def initialize(initial_state = nil, _internal: false)
-      Deprecations.warn(:projection_new_constructor) 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)
@@ -28,61 +28,10 @@ module RubyEventStore
       self
     end
 
-    def call(*scopes)
+    def call(scope)
       return initial_state if handled_events.empty?
 
-      Deprecations.warn(:projection_multiple_scopes) if scopes.size > 1
-
-      scopes.reduce(initial_state) { |state, scope| scope.of_type(handled_events).reduce(state, &method(:transition)) }
-    end
-
-    def self.from_stream(stream_or_streams)
-      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
-      new(_internal: true)
-    end
-
-    def init(handler)
-      @init = handler
-      self
-    end
-
-    def when(events, handler)
-      Array(events).each do |event_klass|
-        name = event_klass.to_s
-        @handlers[name] = ->(state, event) do
-          handler.call(state, event)
-          state
-        end
-      end
-      self
-    end
-
-    def run(event_store, start: nil, count: PAGE_SIZE)
-      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
@@ -98,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,10 +245,6 @@ module RubyEventStore
       )
     end
 
-    def in_batches_of(batch_size = DEFAULT_BATCH_SIZE)
-      in_batches(batch_size)
-    end
-
     # Specifies that only first event should be read.
     # {https://railseventstore.org/docs/core-concepts/read Find out more}.
     #
@@ -292,10 +288,6 @@ module RubyEventStore
       Specification.new(reader, result.dup { |r| r.with_types = types.flatten })
     end
 
-    def of_types(*types)
-      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

@@ -3,24 +3,11 @@
 module RubyEventStore
   class SyncScheduler
     def call(subscriber, event, _)
-      if Class === subscriber
-        Deprecations.warn(:class_subscriber)
-        subscriber = subscriber.new
-      end
       subscriber.call(event)
     end
 
     def verify(subscriber)
-      if Class === subscriber
-        Deprecations.warn(:class_subscriber)
-        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.2"
+  VERSION = "3.0.0"
 end

data/lib/ruby_event_store.rb

@@ -2,7 +2,6 @@
 
 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"
@@ -25,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"
@@ -38,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"
@@ -54,4 +49,3 @@ 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.2
+  version: 3.0.0
 platform: ruby
 authors:
 - Arkency
@@ -47,14 +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/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
 - 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
@@ -70,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
@@ -125,7 +119,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 3.7.1
 specification_version: 4
 summary: Implementation of an event store in Ruby
 test_files: []

data/lib/ruby_event_store/deprecated.rb

@@ -1,98 +0,0 @@
-# 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/dispatcher.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-module RubyEventStore
-  class Dispatcher < SyncScheduler
-  end
-end

data/lib/ruby_event_store/immediate_async_dispatcher.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-module RubyEventStore
-  class ImmediateAsyncDispatcher < ImmediateDispatcher
-  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,11 +0,0 @@
-# frozen_string_literal: true
-
-module RubyEventStore
-  module Mappers
-    class NullMapper < PipelineMapper
-      def initialize
-        super(Pipeline.new)
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module RubyEventStore
-  module Mappers
-    module Transformation
-      class EventClassRemapper
-        def initialize(class_map)
-          @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