ruby_event_store 0.25.2 → 0.26.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 17c8a7baa18f2bc50009615e332df2928e5dbdf834e496031b526687fc97cbc2
-  data.tar.gz: 671448bb3373d5d81b34eeaa10d7afc95f7ac1c0f73368a0378b303630c7bfb1
+SHA1:
+  metadata.gz: a57244de5351622091fa442885288c1775dc5ad0
+  data.tar.gz: 2280e2361f7c8466484caa459822c28e213d1b4d
 SHA512:
-  metadata.gz: ed795c85091f01f0c1d13f368cedaf25d14be63ae086dd7d8a074d15c038ccc9a52631dc0d1227e81c87ca7b47af849989dc14884b9b3adac9454164405c4881
-  data.tar.gz: 745277d650f8255bcf076443813b4425ea74003323526bee10f11c8639850d4b4369b72e656bd29036cffc087ce6c7c02fa44b906e4657b7c3f7fce45108d888
+  metadata.gz: d64e4f0c8d49aa4161df43acddd7e16ff16ea9c7e193826a3817224035b27f9953ec943da86126b8cb94f9e41ac3fd5d4ab29d8058038d19be3a0c4fd8e94523
+  data.tar.gz: e3cc5306c6ae098ed5d3544000a1a1aa87ae672a9c9a66510e64141ad813ae8b28123b8b24cf69125e0393c446a17aca7c077a5c4098849405e02607379d7c33

data/Makefile

@@ -5,6 +5,7 @@ IGNORE      = RubyEventStore.const_missing \
               RubyEventStore::InMemoryRepository\#append_with_synchronize \
               RubyEventStore::InMemoryRepository\#normalize_to_array \
               RubyEventStore::Client\#normalize_to_array \
+              RubyEventStore::Client::Within\#normalize_to_array \
               RubyEventStore::SerializedRecord \
               RubyEventStore::Projection\#read_events_from_stream \
               RubyEventStore::Projection\#read_events_from_all_streams
@@ -20,7 +21,7 @@ test: ## Run unit tests
 
 mutate: test ## Run mutation tests
 	@echo "Running mutation tests"
-	@bundle exec mutant --include lib \
+	@MUTATING=true bundle exec mutant --include lib \
 		$(addprefix --require ,$(REQUIRE)) \
 		$(addprefix --ignore-subject ,$(IGNORE)) \
 		--use rspec "$(SUBJECT)"

data/lib/ruby_event_store/client.rb

@@ -82,18 +82,99 @@ module RubyEventStore
       @repository.get_all_streams
     end
 
-    def subscribe(subscriber, event_types, &proc)
-      @event_broker.add_subscriber(subscriber, event_types).tap do |unsub|
-        handle_subscribe(unsub, &proc)
+
+    DEPRECATED_WITHIN = "subscribe(subscriber, event_types, &task) has been deprecated. Use within(&task).subscribe(subscriber, to: event_types).call instead"
+    DEPRECATED_TO = "subscribe(subscriber, event_types) has been deprecated. Use subscribe(subscriber, to: event_types) instead"
+    # OLD:
+    #  subscribe(subscriber, event_types, &within)
+    #  subscribe(subscriber, event_types)
+    # NEW:
+    #  subscribe(subscriber, to:)
+    #  subscribe(to:, &subscriber)
+    def subscribe(subscriber = nil, event_types = nil, to: nil, &proc)
+      if to
+        raise ArgumentError, "subscriber must be first argument or block, cannot be both" if subscriber && proc
+        raise SubscriberNotExist, "subscriber must be first argument or block" unless subscriber || proc
+        raise ArgumentError, "list of event types must be second argument or named argument to: , it cannot be both" if event_types
+        subscriber ||= proc
+        @event_broker.add_subscriber(subscriber, to)
+      else
+        if proc
+          warn(DEPRECATED_WITHIN)
+          within(&proc).subscribe(subscriber, to: event_types).call
+          -> {}
+        else
+          warn(DEPRECATED_TO)
+          subscribe(subscriber, to: event_types)
+        end
       end
     end
 
-    def subscribe_to_all_events(subscriber, &proc)
-      @event_broker.add_global_subscriber(subscriber).tap do |unsub|
-        handle_subscribe(unsub, &proc)
+    DEPRECATED_ALL_WITHIN = "subscribe_to_all_events(subscriber, &task) has been deprecated. Use within(&task).subscribe_to_all_events(subscriber).call instead."
+    # OLD:
+    #  subscribe_to_all_events(subscriber, &within)
+    #  subscribe_to_all_events(subscriber)
+    # NEW:
+    #  subscribe_to_all_events(subscriber)
+    #  subscribe_to_all_events(&subscriber)
+    def subscribe_to_all_events(subscriber = nil, &proc)
+      if subscriber
+        if proc
+          warn(DEPRECATED_ALL_WITHIN)
+          within(&proc).subscribe_to_all_events(subscriber).call
+          -> {}
+        else
+          @event_broker.add_global_subscriber(subscriber)
+        end
+      else
+        @event_broker.add_global_subscriber(proc)
       end
     end
 
+    class Within
+      def initialize(block, event_broker)
+        @block = block
+        @event_broker = event_broker
+        @global_subscribers = []
+        @subscribers = Hash.new {[]}
+      end
+
+      def subscribe_to_all_events(*handlers, &handler2)
+        handlers << handler2 if handler2
+        @global_subscribers += handlers
+        self
+      end
+
+      def subscribe(handler=nil, to:, &handler2)
+        raise ArgumentError if handler && handler2
+        @subscribers[handler || handler2] += normalize_to_array(to)
+        self
+      end
+
+      def call
+        unsubs = @global_subscribers.map do |s|
+          @event_broker.add_thread_global_subscriber(s)
+        end
+        unsubs += @subscribers.map do |handler, types|
+          @event_broker.add_thread_subscriber(handler, types)
+        end
+        @block.call
+      ensure
+        unsubs.each(&:call)
+      end
+
+      private
+
+      def normalize_to_array(objs)
+        return *objs
+      end
+    end
+
+    def within(&block)
+      raise ArgumentError if block.nil?
+      Within.new(block, @event_broker)
+    end
+
     private
 
     def normalize_to_array(events)
@@ -108,14 +189,6 @@ module RubyEventStore
       # event.class.new(event_id: event.event_id, metadata: metadata, data: event.data)
     end
 
-    def handle_subscribe(unsub, &proc)
-      begin
-        proc.call
-      ensure
-        unsub.()
-      end if proc
-    end
-
     class Page
       def initialize(repository, start, count)
         if start.instance_of?(Symbol)

data/lib/ruby_event_store/in_memory_repository.rb

@@ -73,21 +73,20 @@ module RubyEventStore
     def add_to_stream(events, expected_version, stream_name, include_global)
       raise InvalidExpectedVersion if !expected_version.equal?(:any) && stream_name.eql?(GLOBAL_STREAM)
       events = normalize_to_array(events)
-      stream = read_stream_events_forward(stream_name)
       expected_version = case expected_version
         when :none
           -1
-        when :auto, :any
-          stream.size - 1
-        when Integer
+        when :auto
+          read_stream_events_forward(stream_name).size - 1
+        when Integer, :any
           expected_version
         else
          raise InvalidExpectedVersion
       end
-      append_with_synchronize(events, expected_version, stream, stream_name, include_global)
+      append_with_synchronize(events, expected_version, stream_name, include_global)
     end
 
-    def append_with_synchronize(events, expected_version, stream, stream_name, include_global)
+    def append_with_synchronize(events, expected_version, stream_name, include_global)
       # expected_version :auto assumes external lock is used
       # which makes reading stream before writing safe.
       #
@@ -97,11 +96,15 @@ module RubyEventStore
       # not for the whole read+write algorithm.
       Thread.pass
       @mutex.synchronize do
-        append(events, expected_version, stream, stream_name, include_global)
+        if expected_version == :any
+          expected_version = read_stream_events_forward(stream_name).size - 1
+        end
+        append(events, expected_version, stream_name, include_global)
       end
     end
 
-    def append(events, expected_version, stream, stream_name, include_global)
+    def append(events, expected_version, stream_name, include_global)
+      stream = read_stream_events_forward(stream_name)
       raise WrongExpectedEventVersion unless (stream.size - 1).equal?(expected_version)
       events.each do |event|
         raise EventDuplicatedInStream if stream.any?{|ev| ev.event_id.eql?(event.event_id) }

data/lib/ruby_event_store/pub_sub/broker.rb

@@ -1,3 +1,5 @@
+require 'concurrent'
+
 module RubyEventStore
   module PubSub
     class Broker
@@ -6,6 +8,12 @@ module RubyEventStore
       def initialize(dispatcher: DEFAULT_DISPATCHER)
         @subscribers = Hash.new {|hsh, key| hsh[key] = [] }
         @global_subscribers = []
+
+        @thread_global_subscribers = Concurrent::ThreadLocalVar.new([])
+        @thread_subscribers = Concurrent::ThreadLocalVar.new do
+          Hash.new {|hsh, key| hsh[key] = [] }
+        end
+
         @dispatcher = dispatcher
       end
 
@@ -21,6 +29,19 @@ module RubyEventStore
         ->() { @global_subscribers.delete(subscriber) }
       end
 
+      def add_thread_global_subscriber(subscriber)
+        verify_subscriber(subscriber)
+        @thread_global_subscribers.value += [subscriber]
+
+        ->() { @thread_global_subscribers.value -= [subscriber] }
+      end
+
+      def add_thread_subscriber(subscriber, event_types)
+        verify_subscriber(subscriber)
+        event_types.each{ |type| @thread_subscribers.value[type.name] << subscriber }
+        ->() {event_types.each{ |type| @thread_subscribers.value.fetch(type.name).delete(subscriber) } }
+      end
+
       def notify_subscribers(event)
         all_subscribers_for(event.class).each do |subscriber|
           @dispatcher.call(subscriber, event)
@@ -40,7 +61,10 @@ module RubyEventStore
       end
 
       def all_subscribers_for(event_type)
-        @subscribers[event_type.name] + @global_subscribers
+        @subscribers[event_type.name] +
+        @global_subscribers +
+        @thread_global_subscribers.value +
+        @thread_subscribers.value[event_type.name]
       end
     end
   end

data/lib/ruby_event_store/spec/event_broker_lint.rb

@@ -35,10 +35,12 @@ RSpec.shared_examples :event_broker do |broker_class|
 
   it 'raise error when no subscriber' do
     expect { broker.add_subscriber(nil, [])}.to raise_error(RubyEventStore::SubscriberNotExist)
+    expect { broker.add_thread_subscriber(nil, [])}.to raise_error(RubyEventStore::SubscriberNotExist)
     expect { broker.add_global_subscriber(nil)}.to raise_error(RubyEventStore::SubscriberNotExist)
+    expect { broker.add_thread_global_subscriber(nil)}.to raise_error(RubyEventStore::SubscriberNotExist)
   end
 
-  it 'notify subscribed handlers' do
+  it 'notifies subscribed handlers' do
     handler         = TestHandler.new
     another_handler = TestHandler.new
     global_handler  = TestHandler.new
@@ -60,6 +62,28 @@ RSpec.shared_examples :event_broker do |broker_class|
     expect(global_handler.events).to eq([event1,event2,event3])
   end
 
+  it 'notifies subscribed thread handlers' do
+    handler         = TestHandler.new
+    another_handler = TestHandler.new
+    global_handler  = TestHandler.new
+
+    broker.add_thread_subscriber(handler, [Test1DomainEvent, Test3DomainEvent])
+    broker.add_thread_subscriber(another_handler, [Test2DomainEvent])
+    broker.add_thread_global_subscriber(global_handler)
+
+    event1 = Test1DomainEvent.new
+    event2 = Test2DomainEvent.new
+    event3 = Test3DomainEvent.new
+
+    [event1, event2, event3].each do |ev|
+      broker.notify_subscribers(ev)
+    end
+
+    expect(handler.events).to eq([event1,event3])
+    expect(another_handler.events).to eq([event2])
+    expect(global_handler.events).to eq([event1,event2,event3])
+  end
+
   it 'raises error when no valid method on handler' do
     subscriber = InvalidTestHandler.new
     expect do
@@ -74,13 +98,27 @@ RSpec.shared_examples :event_broker do |broker_class|
     end.to raise_error(RubyEventStore::InvalidHandler)
   end
 
+  it 'raises error when no valid method on thread handler' do
+    subscriber = InvalidTestHandler.new
+    expect do
+      broker.add_thread_subscriber(subscriber, [Test1DomainEvent])
+    end.to raise_error(RubyEventStore::InvalidHandler)
+  end
+
+  it 'raises error when no valid method on global thread handler' do
+    subscriber = InvalidTestHandler.new
+    expect do
+      broker.add_thread_global_subscriber(subscriber)
+    end.to raise_error(RubyEventStore::InvalidHandler)
+  end
+
   it 'returns lambda as an output of global subscribe methods' do
     handler   = TestHandler.new
     result = broker.add_global_subscriber(handler)
     expect(result).to respond_to(:call)
   end
 
-  it 'return lambda as an output of subscribe methods' do
+  it 'returns lambda as an output of subscribe methods' do
     handler   = TestHandler.new
     result    = broker.add_subscriber(handler, [Test1DomainEvent, Test2DomainEvent])
     expect(result).to respond_to(:call)
@@ -112,6 +150,32 @@ RSpec.shared_examples :event_broker do |broker_class|
     expect(handler.events).to eq([event1])
   end
 
+  it 'revokes thread global subscription' do
+    handler   = TestHandler.new
+    event1    = Test1DomainEvent.new
+    event2    = Test2DomainEvent.new
+
+    revoke    = broker.add_thread_global_subscriber(handler)
+    broker.notify_subscribers(event1)
+    expect(handler.events).to eq([event1])
+    revoke.()
+    broker.notify_subscribers(event2)
+    expect(handler.events).to eq([event1])
+  end
+
+  it 'revokes thread subscription' do
+    handler   = TestHandler.new
+    event1    = Test1DomainEvent.new
+    event2    = Test2DomainEvent.new
+
+    revoke    = broker.add_thread_subscriber(handler, [Test1DomainEvent, Test2DomainEvent])
+    broker.notify_subscribers(event1)
+    expect(handler.events).to eq([event1])
+    revoke.()
+    broker.notify_subscribers(event2)
+    expect(handler.events).to eq([event1])
+  end
+
   it 'allows to provide a custom dispatcher' do
     dispatcher  = TestDispatcher.new
     handler     = TestHandler.new
@@ -123,6 +187,7 @@ RSpec.shared_examples :event_broker do |broker_class|
   end
 
   private
+
   class HandlerClass
     @@received = nil
     def self.received

data/lib/ruby_event_store/version.rb

@@ -1,3 +1,3 @@
 module RubyEventStore
-  VERSION = "0.25.2"
+  VERSION = "0.26.0"
 end

data/ruby_event_store.gemspec

@@ -21,6 +21,7 @@ Gem::Specification.new do |spec|
 
 
   spec.add_dependency 'activesupport'
+  spec.add_dependency 'concurrent-ruby', '~> 1.0'
   spec.add_development_dependency 'bundler', '~> 1.15'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'rspec', '~> 3.6'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_event_store
 version: !ruby/object:Gem::Version
-  version: 0.25.2
+  version: 0.26.0
 platform: ruby
 authors:
 - Arkency
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-02-10 00:00:00.000000000 Z
+date: 2018-03-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -129,7 +143,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.3
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: Event Store in Ruby