ruby_event_store 0.27.1 → 0.28.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 7a86c8269c00c7fc0586a26cc129573df691b34a
-  data.tar.gz: 49469f4a21d4679acd373e58beea78a8baa7ff51
+SHA256:
+  metadata.gz: 72a8ebb8ab54701aac0c46c74e2ca5dd58bd4b505c39e2d3323c5b0e67c1408a
+  data.tar.gz: 6ba8a87fb402111fe441dcfb366a59ae8b967e82e884ee9f88beab3e20d8d3ba
 SHA512:
-  metadata.gz: 69318af6cb2f0eddc85b0e33afc35643086c0d15b6c8a51fceaec0e5557d2712b866ee0832ad683574a0e0970444f9bb0bd93e0e660c3cd815dd4b545ce26516
-  data.tar.gz: 4fe460334ee294978c2a8a8f43d386484617cbd49b907d98fe4832f96ad513f695aac314146ae70eb3764d24727ef530c401c206eb8b7dc5b7d5e7acdcdf4177
+  metadata.gz: 16a7cfe13de7dbfb095198e4a9a93d7b3b26f6a085be0c85c3b28266a494781e6535e16687c23df900f39e83cdefdb62b87e803bd8ec0c735e6ac442e6e54eda
+  data.tar.gz: 428425082d57566878b5736ff838cf15eda1fa970a72758d111b067920227970d073eabf45ca833c197792fdc050bb17c471c975b5d8863d65d8fea48def833f

data/Gemfile

@@ -1,3 +1,4 @@
 source 'https://rubygems.org'
 gemspec
-gem 'pry'
+gem 'pry'
+gem 'protobuf_nested_struct'

data/Makefile

@@ -17,6 +17,12 @@ install: ## Install gem dependencies
 	@echo "Installing gem dependencies"
 	@bundle install
 
+remove-lock:
+	@echo "Removing resolved dependency versions"
+	-rm Gemfile.lock
+
+reinstall: remove-lock install ## Removing resolved dependency versions
+
 test: ## Run unit tests
 	@echo "Running unit tests"
 	@bundle exec rspec
@@ -28,6 +34,14 @@ mutate: test ## Run mutation tests
 		$(addprefix --ignore-subject ,$(IGNORE)) \
 		--use rspec "$(SUBJECT)"
 
+mutate-fast: ## Run mutation tests with --fail-fast
+	@echo "Running mutation tests"
+	@MUTATING=true bundle exec mutant --include lib \
+		$(addprefix --require ,$(REQUIRE)) \
+		$(addprefix --ignore-subject ,$(IGNORE)) \
+		--fail-fast \
+		--use rspec "$(SUBJECT)"
+
 build:
 	@echo "Building gem package"
 	@gem build -V $(GEM_NAME).gemspec
@@ -36,7 +50,7 @@ build:
 
 push:
 	@echo "Pushing package to RubyGems"
-	@gem push pkg/$(GEM_NAME)-$(GEM_VERSION).gem
+	@gem push -k dev_arkency pkg/$(GEM_NAME)-$(GEM_VERSION).gem
 
 clean:
 	@echo "Removing previously built package"

data/lib/ruby_event_store/client.rb

@@ -1,11 +1,13 @@
 module RubyEventStore
   class Client
     def initialize(repository:,
+                   mapper: Mappers::Default.new,
                    event_broker:  PubSub::Broker.new,
                    page_size: PAGE_SIZE,
                    metadata_proc: nil,
                    clock: ->{ Time.now.utc })
       @repository     = repository
+      @mapper         = mapper
       @event_broker   = event_broker
       @page_size      = page_size
       @metadata_proc  = metadata_proc
@@ -15,7 +17,7 @@ module RubyEventStore
     def publish_events(events, stream_name: GLOBAL_STREAM, expected_version: :any)
       append_to_stream(events, stream_name: stream_name, expected_version: expected_version)
       events.each do |ev|
-        @event_broker.notify_subscribers(ev)
+        event_broker.notify_subscribers(ev)
       end
       :ok
     end
@@ -27,62 +29,48 @@ module RubyEventStore
     def append_to_stream(events, stream_name: GLOBAL_STREAM, expected_version: :any)
       events = normalize_to_array(events)
       events.each{|event| enrich_event_metadata(event) }
-      @repository.append_to_stream(events, stream_name, expected_version)
+      repository.append_to_stream(serialized_events(events), Stream.new(stream_name), ExpectedVersion.new(expected_version))
       :ok
     end
 
     def link_to_stream(event_ids, stream_name:, expected_version: :any)
-      @repository.link_to_stream(event_ids, stream_name, expected_version)
+      repository.link_to_stream(event_ids, Stream.new(stream_name), ExpectedVersion.new(expected_version))
       self
     end
 
     def delete_stream(stream_name)
-      raise IncorrectStreamData if stream_name.nil? || stream_name.empty?
-      @repository.delete_stream(stream_name)
+      repository.delete_stream(Stream.new(stream_name))
       :ok
     end
 
-    def read_events_forward(stream_name, start: :head, count: @page_size)
-      raise IncorrectStreamData if stream_name.nil? || stream_name.empty?
-      page = Page.new(@repository, start, count)
-      @repository.read_events_forward(stream_name, page.start, page.count)
+    def read_events_forward(stream_name, start: :head, count: page_size)
+      deserialized_events(read.stream(stream_name).limit(count).from(start).each)
     end
 
-    def read_events_backward(stream_name, start: :head, count: @page_size)
-      raise IncorrectStreamData if stream_name.nil? || stream_name.empty?
-      page = Page.new(@repository, start, count)
-      @repository.read_events_backward(stream_name, page.start, page.count)
+    def read_events_backward(stream_name, start: :head, count: page_size)
+      deserialized_events(read.stream(stream_name).limit(count).from(start).backward.each)
     end
 
     def read_stream_events_forward(stream_name)
-      raise IncorrectStreamData if stream_name.nil? || stream_name.empty?
-      @repository.read_stream_events_forward(stream_name)
+      deserialized_events(read.stream(stream_name).each)
     end
 
     def read_stream_events_backward(stream_name)
-      raise IncorrectStreamData if stream_name.nil? || stream_name.empty?
-      @repository.read_stream_events_backward(stream_name)
+      deserialized_events(read.stream(stream_name).backward.each)
     end
 
-    def read_all_streams_forward(start: :head, count: @page_size)
-      page = Page.new(@repository, start, count)
-      @repository.read_all_streams_forward(page.start, page.count)
+    def read_all_streams_forward(start: :head, count: page_size)
+      deserialized_events(read.limit(count).from(start).each)
     end
 
-    def read_all_streams_backward(start: :head, count: @page_size)
-      page = Page.new(@repository, start, count)
-      @repository.read_all_streams_backward(page.start, page.count)
+    def read_all_streams_backward(start: :head, count: page_size)
+      deserialized_events(read.limit(count).from(start).backward.each)
     end
 
     def read_event(event_id)
-      @repository.read_event(event_id)
+      deserialize_event(repository.read_event(event_id))
     end
 
-    def get_all_streams
-      @repository.get_all_streams
-    end
-
-
     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:
@@ -97,7 +85,7 @@ module RubyEventStore
         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)
+        event_broker.add_subscriber(subscriber, to)
       else
         if proc
           warn(DEPRECATED_WITHIN)
@@ -124,10 +112,10 @@ module RubyEventStore
           within(&proc).subscribe_to_all_events(subscriber).call
           -> {}
         else
-          @event_broker.add_global_subscriber(subscriber)
+          event_broker.add_global_subscriber(subscriber)
         end
       else
-        @event_broker.add_global_subscriber(proc)
+        event_broker.add_global_subscriber(proc)
       end
     end
 
@@ -160,7 +148,7 @@ module RubyEventStore
       end
 
       private
-      
+
       def add_thread_subscribers
         @subscribers.map do |handler, types|
           @event_broker.add_thread_subscriber(handler, types)
@@ -180,39 +168,43 @@ module RubyEventStore
 
     def within(&block)
       raise ArgumentError if block.nil?
-      Within.new(block, @event_broker)
+      Within.new(block, event_broker)
     end
 
     private
 
-    def normalize_to_array(events)
-      return *events
+    def serialized_events(events)
+      events.map do |ev|
+        mapper.event_to_serialized_record(ev)
+      end
     end
 
-    def enrich_event_metadata(event)
-      metadata = {}
-      metadata[:timestamp] ||= @clock.()
-      metadata.merge!(@metadata_proc.call || {}) if @metadata_proc
-      metadata.each do |key, value|
-        @repository.add_metadata(event, key, value)
+    def deserialized_events(serialized_events)
+      serialized_events.map do |sev|
+        deserialize_event(sev)
       end
     end
 
-    class Page
-      def initialize(repository, start, count)
-        if start.instance_of?(Symbol)
-          raise InvalidPageStart unless [:head].include?(start)
-        else
-          start = start.to_s
-          raise InvalidPageStart if start.empty?
-          raise EventNotFound.new(start) unless repository.has_event?(start)
-        end
-        raise InvalidPageSize unless count > 0
-        @start = start
-        @count = count
+    def deserialize_event(sev)
+      mapper.serialized_record_to_event(sev)
+    end
+
+    def read
+      Specification.new(repository)
+    end
+
+    def normalize_to_array(events)
+      return *events
+    end
+
+    def enrich_event_metadata(event)
+      event.metadata[:timestamp] ||= clock.()
+      if metadata_proc
+        md = metadata_proc.call || {}
+        md.each{|k,v| event.metadata[k]=(v) }
       end
-      attr_reader :start, :count
     end
 
+    attr_reader :repository, :mapper, :event_broker, :clock, :metadata_proc, :page_size
   end
 end

data/lib/ruby_event_store/constants.rb

@@ -1,4 +1,4 @@
 module RubyEventStore
-  GLOBAL_STREAM = 'all'.freeze
+  GLOBAL_STREAM = Object.new
   PAGE_SIZE = 100.freeze
 end

data/lib/ruby_event_store/errors.rb

@@ -7,6 +7,7 @@ module RubyEventStore
   InvalidPageSize            = Class.new(ArgumentError)
   EventDuplicatedInStream    = Class.new(StandardError)
   NotSupported               = Class.new(StandardError)
+  ReservedInternalName       = Class.new(StandardError)
 
   class EventNotFound < StandardError
     attr_reader :event_id

data/lib/ruby_event_store/event.rb

@@ -4,16 +4,21 @@ module RubyEventStore
   class Event
     def initialize(event_id: SecureRandom.uuid, metadata: nil, data: nil)
       @event_id = event_id.to_s
-      @metadata = metadata.to_h
+      @metadata = Metadata.new(metadata.to_h)
       @data     = data.to_h
     end
     attr_reader :event_id, :metadata, :data
 
+    def type
+      self.class.name
+    end
+
     def to_h
       {
           event_id:   event_id,
-          metadata:   metadata,
-          data:       data
+          metadata:   metadata.to_h,
+          data:       data,
+          type:       type,
       }
     end
 

data/lib/ruby_event_store/expected_version.rb

@@ -0,0 +1,73 @@
+module RubyEventStore
+  class ExpectedVersion
+    POSITION_DEFAULT = -1.freeze
+    NOT_RESOLVED = Object.new.freeze
+
+    def self.any
+      new(:any)
+    end
+
+    def self.none
+      new(:none)
+    end
+
+    def self.auto
+      new(:auto)
+    end
+
+    attr_reader :version
+
+    def initialize(version)
+      @version = version
+      invalid_version! unless [Integer, :any, :none, :auto].any? {|i| i === version}
+    end
+
+    def any?
+      version.equal?(:any)
+    end
+
+    def auto?
+      version.equal?(:auto)
+    end
+
+    def none?
+      version.equal?(:none)
+    end
+
+    def resolve_for(stream, resolver = Proc.new {})
+      invalid_version! if stream.global? && !any?
+
+      case version
+      when Integer
+        version
+      when :none
+        POSITION_DEFAULT
+      when :auto
+        resolver[stream] || POSITION_DEFAULT
+      end
+    end
+
+    BIG_VALUE = 0b110111100100000010010010110011101011000101010101001100100110011
+    private_constant :BIG_VALUE
+
+    def hash
+      [
+        self.class,
+        version
+      ].hash ^ BIG_VALUE
+    end
+
+    def ==(other_expected_version)
+      other_expected_version.instance_of?(self.class) &&
+        other_expected_version.version.equal?(version)
+    end
+
+    alias_method :eql?, :==
+
+    private
+
+    def invalid_version!
+      raise InvalidExpectedVersion
+    end
+  end
+end

data/lib/ruby_event_store/in_memory_repository.rb

@@ -4,95 +4,66 @@ require 'thread'
 module RubyEventStore
   class InMemoryRepository
 
-    def initialize(mapper: Mappers::Default.new)
-      @all = Array.new
+    def initialize
       @streams = Hash.new
       @mutex = Mutex.new
-      @mapper = mapper
+      @global = Array.new
     end
 
-    def append_to_stream(events, stream_name, expected_version)
-      add_to_stream(events, expected_version, stream_name, true)
+    def append_to_stream(events, stream, expected_version)
+      add_to_stream(events, expected_version, stream, true)
     end
 
-    def link_to_stream(event_ids, stream_name, expected_version)
-      events = normalize_to_array(event_ids).map{|eid| read_event(eid) }
-      add_to_stream(events, expected_version, stream_name, nil)
+    def link_to_stream(event_ids, stream, expected_version)
+      events = normalize_to_array(event_ids).map {|eid| read_event(eid)}
+      add_to_stream(events, expected_version, stream, nil)
     end
 
-    def delete_stream(stream_name)
-      @streams.delete(stream_name)
+    def delete_stream(stream)
+      streams.delete(stream.name)
     end
 
     def has_event?(event_id)
-      @all.any?{ |item| item.event_id.eql?(event_id) }
+       global.any?{ |item| item.event_id.eql?(event_id) }
     end
 
-    def last_stream_event(stream_name)
-      read_stream_events_forward(stream_name).last
-    end
-
-    def read_events_forward(stream_name, start_event_id, count)
-      source = read_stream_events_forward(stream_name)
-      read_batch(source, start_event_id, count)
-    end
-
-    def read_events_backward(stream_name, start_event_id, count)
-      source = read_stream_events_backward(stream_name)
-      read_batch(source, start_event_id, count)
-    end
-
-    def read_stream_events_forward(stream_name)
-      @streams[stream_name] || Array.new
-    end
-
-    def read_stream_events_backward(stream_name)
-      read_stream_events_forward(stream_name).reverse
-    end
-
-    def read_all_streams_forward(start_event_id, count)
-      read_batch(@all, start_event_id, count)
-    end
-
-    def read_all_streams_backward(start_event_id, count)
-      read_batch(@all.reverse, start_event_id, count)
+    def last_stream_event(stream)
+      stream_of(stream.name).last
     end
 
     def read_event(event_id)
-      @all.find { |e| event_id.eql?(e.event_id) } or raise EventNotFound.new(event_id)
+      global.find {|e| event_id.eql?(e.event_id)} or raise EventNotFound.new(event_id)
     end
 
-    def get_all_streams
-      [Stream.new("all")] + @streams.keys.map { |name| Stream.new(name) }
-    end
-
-    def add_metadata(event, key, value)
-      @mapper.add_metadata(event, key, value)
+    def read(spec)
+      events = spec.global_stream? ? global : stream_of(spec.stream_name)
+      events = events.reverse if spec.backward?
+      events = read_batch(events, spec.start, spec.count) if spec.limit?
+      events.each
     end
 
     private
 
+    def stream_of(name)
+      streams.fetch(name, Array.new)
+    end
+
     def normalize_to_array(events)
       return *events
     end
 
-    def add_to_stream(events, expected_version, stream_name, include_global)
-      raise InvalidExpectedVersion if !expected_version.equal?(:any) && stream_name.eql?(GLOBAL_STREAM)
+    def add_to_stream(events, expected_version, stream, include_global)
       events = normalize_to_array(events)
-      expected_version = case expected_version
-        when :none
-          -1
-        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_name, include_global)
+      append_with_synchronize(events, expected_version, stream, include_global)
     end
 
-    def append_with_synchronize(events, expected_version, stream_name, include_global)
+    def last_stream_version(stream)
+      stream_of(stream.name).size - 1
+    end
+
+    def append_with_synchronize(events, expected_version, stream, include_global)
+      resolved_version = expected_version.resolve_for(stream, method(:last_stream_version))
+
       # expected_version :auto assumes external lock is used
       # which makes reading stream before writing safe.
       #
@@ -101,37 +72,38 @@ module RubyEventStore
       # conditions more likely. And we only use mutex.synchronize for writing
       # not for the whole read+write algorithm.
       Thread.pass
-      @mutex.synchronize do
-        if expected_version == :any
-          expected_version = read_stream_events_forward(stream_name).size - 1
-        end
-        append(events, expected_version, stream_name, include_global)
+      mutex.synchronize do
+        resolved_version = last_stream_version(stream) if expected_version.any?
+        append(events, resolved_version, stream, include_global)
       end
     end
 
-    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)
+    def append(events, resolved_version, stream, include_global)
+      stream_events = stream_of(stream.name)
+      raise WrongExpectedEventVersion unless last_stream_version(stream).equal?(resolved_version)
+
       events.each do |event|
-        raise EventDuplicatedInStream if stream.any?{|ev| ev.event_id.eql?(event.event_id) }
+        raise EventDuplicatedInStream if stream_events.any? {|ev| ev.event_id.eql?(event.event_id)}
         if include_global
-          raise EventDuplicatedInStream if @all.any?{|ev| ev.event_id.eql?(event.event_id) }
-          @all.push(event)
+          raise EventDuplicatedInStream if has_event?(event.event_id)
+          global.push(event)
         end
-        stream.push(event)
+        stream_events.push(event)
       end
-      @streams[stream_name] = stream
+      streams[stream.name] = stream_events
       self
     end
 
     def read_batch(source, start_event_id, count)
-      return source[0..count-1] if start_event_id.equal?(:head)
+      return source[0..count - 1] if start_event_id.equal?(:head)
       start_index = index_of(source, start_event_id)
-      source[start_index+1..start_index+count]
+      source[start_index + 1..start_index + count]
     end
 
     def index_of(source, event_id)
-      source.index{ |item| item.event_id.eql?(event_id) }
+      source.index {|item| item.event_id.eql?(event_id)}
     end
+
+    attr_reader :streams, :mutex, :global
   end
 end