ruby_event_store 0.29.0 → 0.30.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dce5f67de62e85755060ade796d9f07674197175c867ea6028dca2b9fd730791
-  data.tar.gz: 95fb9ef4100c3fd2179cb0c5ff7e77e9c31801c68cc5872eb020433e448d1668
+  metadata.gz: 4df1be4d7e983bb77d1c069496cdca690f72d593a0c0d83f9d3d7519d63ed115
+  data.tar.gz: 0d156019cb436a9fb262b680e3e46d007d7c64ec46f1186bae82c5e4344b03c8
 SHA512:
-  metadata.gz: eee87e104fc965fe7c4e7768ba97424d072d816c107d7ed70a8317c86e6b848f532808626851cd3acd9e7ef5f7f3a4fcfa224baa47b631b97b6be6968e82c92c
-  data.tar.gz: 4aa91e0bf722675f60dff89fcf1b42ab47faf82e95ab4087017f3538b2ea919c814aa63692d467eab69f12ece43efd516bd73ae5c7a3da51af6bfad2f5bbbc60
+  metadata.gz: 490e25c72237a78d241df447ad97d55f2d245d40ea4d3b7665b5c699e5273d3b8257f06d2a0a3a1d8d3bc0940158819f433d72b47460620a5c4ed756fad5d646
+  data.tar.gz: 4355818327a762070c48a8121728c9914b74881187f028c8dc8c440d46c9b51556621b5fb697cdbbd97fc93c3eaff03cafa69fefa6d84f6655023cb053336ae4

data/Makefile

@@ -8,9 +8,14 @@ IGNORE      = RubyEventStore.const_missing \
               RubyEventStore::Client::Within\#normalize_to_array \
               RubyEventStore::Client::Within\#add_thread_subscribers \
               RubyEventStore::Client::Within\#add_thread_global_subscribers \
-              RubyEventStore::SerializedRecord \
-              RubyEventStore::Projection\#read_events_from_stream \
-              RubyEventStore::Projection\#read_events_from_all_streams
+              RubyEventStore::Client\#read_all_streams_forward \
+              RubyEventStore::Client\#read_all_streams_backward \
+              RubyEventStore::Client\#read_stream_events_forward \
+              RubyEventStore::Client\#read_stream_events_backward \
+              RubyEventStore::Client\#read_events_forward \
+              RubyEventStore::Client\#read_events_backward \
+              RubyEventStore::DeprecatedReadAPIRunner* \
+              RubyEventStore::DeprecatedReadAPIRewriter*
 SUBJECT     ?= RubyEventStore*
 
 install: ## Install gem dependencies

data/exe/res-deprecated-read-api-migrator

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'ruby_event_store/deprecated_read_api_rewriter'
+  require 'ruby_event_store/deprecated_read_api_runner'
+rescue LoadError
+  warn <<-EOS
+
+You need following gems in Gemfile in order to use this script:
+
+  gem 'parser'
+  gem 'unparser'
+  gem 'astrolabe'
+
+EOS
+  exit(2)
+end
+
+RubyEventStore::DeprecatedReadAPIRunner.go(ARGV)

data/lib/ruby_event_store.rb

@@ -15,4 +15,5 @@ require 'ruby_event_store/serialized_record'
 require 'ruby_event_store/mappers/default'
 require 'ruby_event_store/mappers/protobuf'
 require 'ruby_event_store/mappers/null_mapper'
+require 'ruby_event_store/batch_enumerator'
 require 'ruby_event_store/version'

data/lib/ruby_event_store/batch_enumerator.rb

@@ -0,0 +1,25 @@
+module RubyEventStore
+  class BatchEnumerator
+    def initialize(batch_size, total_limit, reader)
+      @batch_size  = batch_size
+      @total_limit = total_limit
+      @reader      = reader
+    end
+
+    def each
+      return to_enum unless block_given?
+      (0...total_limit).step(batch_size) do |batch_offset|
+        batch_offset = Integer(batch_offset)
+        batch_limit  = [batch_size, total_limit - batch_offset].min
+        result       = reader.call(batch_offset, batch_limit)
+
+        break if result.empty?
+        yield result
+      end
+    end
+
+    private
+
+    attr_accessor :batch_size, :total_limit, :reader
+  end
+end

data/lib/ruby_event_store/client.rb

@@ -45,79 +45,88 @@ module RubyEventStore
     end
 
     def read_events_forward(stream_name, start: :head, count: page_size)
-      deserialized_events(read.stream(stream_name).limit(count).from(start).each)
+      warn <<~EOW
+        RubyEventStore::Client#read_events_forward has been deprecated.
+
+        Use following fluent API to receive exact results:
+        client.read.stream(stream_name).limit(count).from(start).each.to_a
+      EOW
+      read.stream(stream_name).limit(count).from(start).each.to_a
     end
 
     def read_events_backward(stream_name, start: :head, count: page_size)
-      deserialized_events(read.stream(stream_name).limit(count).from(start).backward.each)
+      warn <<~EOW
+        RubyEventStore::Client#read_events_backward has been deprecated.
+
+        Use following fluent API to receive exact results:
+        client.read.stream(stream_name).limit(count).from(start).backward.each.to_a
+      EOW
+      read.stream(stream_name).limit(count).from(start).backward.each.to_a
     end
 
     def read_stream_events_forward(stream_name)
-      deserialized_events(read.stream(stream_name).each)
+      warn <<~EOW
+        RubyEventStore::Client#read_stream_events_forward has been deprecated.
+
+        Use following fluent API to receive exact results:
+        client.read.stream(stream_name).each.to_a
+      EOW
+      read.stream(stream_name).each.to_a
     end
 
     def read_stream_events_backward(stream_name)
-      deserialized_events(read.stream(stream_name).backward.each)
+      warn <<~EOW
+        RubyEventStore::Client#read_stream_events_backward has been deprecated.
+
+        Use following fluent API to receive exact results:
+        client.read.stream(stream_name).backward.each.to_a
+      EOW
+      read.stream(stream_name).backward.each.to_a
     end
 
     def read_all_streams_forward(start: :head, count: page_size)
-      deserialized_events(read.limit(count).from(start).each)
+      warn <<~EOW
+        RubyEventStore::Client#read_all_streams_forward has been deprecated.
+
+        Use following fluent API to receive exact results:
+        client.read.limit(count).from(start).each.to_a
+      EOW
+      read.limit(count).from(start).each.to_a
     end
 
     def read_all_streams_backward(start: :head, count: page_size)
-      deserialized_events(read.limit(count).from(start).backward.each)
+      warn <<~EOW
+        RubyEventStore::Client#read_all_streams_backward has been deprecated.
+
+        Use following fluent API to receive exact results:
+        client.read.limit(count).from(start).backward.each.to_a
+      EOW
+      read.limit(count).from(start).backward.each.to_a
     end
 
     def read_event(event_id)
       deserialize_event(repository.read_event(event_id))
     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:
-    #  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
+    def read
+      Specification.new(repository, mapper)
     end
 
-    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)
+    # subscribe(subscriber, to:)
+    # subscribe(to:, &subscriber)
+    def subscribe(subscriber = nil, to:, &proc)
+      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
+      subscriber ||= proc
+      event_broker.add_subscriber(subscriber, to)
+    end
+
+    # 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
+      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
+      event_broker.add_global_subscriber(subscriber || proc)
     end
 
     class Within
@@ -188,20 +197,10 @@ module RubyEventStore
       end
     end
 
-    def deserialized_events(serialized_events)
-      serialized_events.map do |sev|
-        deserialize_event(sev)
-      end
-    end
-
     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

data/lib/ruby_event_store/deprecated_read_api_rewriter.rb

@@ -0,0 +1,67 @@
+require 'parser/current'
+require 'unparser'
+require 'ruby_event_store'
+
+
+module RubyEventStore
+  class DeprecatedReadAPIRewriter < ::Parser::Rewriter
+    def on_send(node)
+      node.each_descendant(:send) { |desc_node| on_send(desc_node) }
+
+      _, method_name, *args = node.children
+      replace_range = node.location.selector
+      replace_range = replace_range.join(node.location.end) if node.location.end
+
+      case method_name
+      when :read_all_streams_backward, :read_events_backward
+        rewrite_api("read.backward", replace_range, **parse_args(args))
+      when :read_stream_events_backward
+        rewrite_api("read.backward", replace_range, count: nil, **parse_args(args))
+      when :read_all_streams_forward, :read_events_forward
+        rewrite_api("read", replace_range, **parse_args(args))
+      when :read_stream_events_forward
+        rewrite_api("read", replace_range, count: nil, **parse_args(args))
+      end
+    end
+
+    def rewrite_api(query, range, start: nil, count: PAGE_SIZE, stream: nil)
+      query << ".stream(#{stream})" if stream
+      query << ".from(#{start})" if start
+      query << ".limit(#{count})" if count
+
+      replace(range, "#{query}.each.to_a")
+    end
+
+    def parse_args(args)
+      return {} if args.empty?
+
+      case args.size
+      when 1
+        case args[0].type
+        when :hash
+          stream_name, kwargs = nil, args[0]
+        else
+          stream_name, kwargs = parse_value(args[0]), AST::Node.new(:hash)
+        end
+      else
+        stream_name, kwargs = parse_value(args[0]), args[1]
+      end
+
+      kwargs
+        .children
+        .reduce({stream: stream_name}) do |memo, pair|
+        keyword, value = pair.children
+        memo[parse_keyword(keyword)] = parse_value(value)
+        memo
+      end
+    end
+
+    def parse_value(node)
+      Unparser.unparse(node)
+    end
+
+    def parse_keyword(node)
+      node.children[0].to_sym
+    end
+  end
+end

data/lib/ruby_event_store/deprecated_read_api_runner.rb

@@ -0,0 +1,64 @@
+require 'parser/runner'
+require 'tempfile'
+require 'astrolabe/builder'
+
+
+module RubyEventStore
+  class DeprecatedReadAPIRunner < Parser::Runner
+    attr_reader :rewriter, :parser_class, :modify
+
+    def initialize
+      super
+      @rewriter = DeprecatedReadAPIRewriter.new
+    end
+
+    def runner_name
+      "res-deprecated-read-api-migrator"
+    end
+
+    def setup_option_parsing(opts)
+      super(opts)
+
+      opts.on '-m', '--modify' do
+        @modify = true
+      end
+    end
+
+    def process(buffer)
+      parser = parser_class.new(Astrolabe::Builder.new)
+      new_source = rewriter.rewrite(buffer, parser.parse(buffer))
+      new_buffer = Parser::Source::Buffer.new(buffer.name + '|after res-deprecated-read-api-migrator')
+      new_buffer.source = new_source
+
+      if !modify
+        old = Tempfile.new('old')
+        old.write(buffer.source + "\n")
+        old.flush
+
+        new = Tempfile.new('new')
+        new.write(new_source + "\n")
+        new.flush
+
+        IO.popen("diff -u #{old.path} #{new.path}") do |io|
+          $stderr.write(
+            io.read
+              .sub(/^---.*/, "--- #{buffer.name}")
+              .sub(/^\+\+\+.*/, "+++ #{new_buffer.name}")
+          )
+        end
+        exit(1)
+      end
+
+      if File.exist?(buffer.name)
+        File.open(buffer.name, 'w') do |file|
+          file.write(new_source)
+        end
+      else
+        if input_size > 1
+          puts "Rewritten content of #{buffer.name}:"
+        end
+        puts new_source
+      end
+    end
+  end
+end

data/lib/ruby_event_store/event.rb

@@ -9,6 +9,10 @@ module RubyEventStore
     end
     attr_reader :event_id, :metadata, :data
 
+    def message_id
+      event_id
+    end
+
     def type
       self.class.name
     end
@@ -43,6 +47,27 @@ module RubyEventStore
       ].hash ^ BIG_VALUE
     end
 
+    def correlation_id
+      metadata[:correlation_id]
+    end
+
+    def correlation_id=(val)
+      metadata[:correlation_id] = val
+    end
+
+    def causation_id
+      metadata[:causation_id]
+    end
+
+    def causation_id=(val)
+      metadata[:causation_id]= val
+    end
+
+    def correlate_with(other_message)
+      self.correlation_id = other_message.correlation_id || other_message.message_id
+      self.causation_id   = other_message.message_id
+    end
+
     alias_method :eql?, :==
   end
 end

data/lib/ruby_event_store/in_memory_repository.rb

@@ -38,8 +38,14 @@ module RubyEventStore
     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
+      events = events.drop(index_of(events, spec.start) + 1) unless spec.head?
+      events = events[0...spec.count] if spec.limit?
+      if spec.batched?
+        batch_reader = ->(offset, limit) { events.drop(offset).take(limit) }
+        BatchEnumerator.new(spec.batch_size, events.size, batch_reader).each
+      else
+        events.each
+      end
     end
 
     private
@@ -94,12 +100,6 @@ module RubyEventStore
       self
     end
 
-    def read_batch(source, start_event_id, count)
-      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]
-    end
-
     def index_of(source, event_id)
       source.index {|item| item.event_id.eql?(event_id)}
     end