event_sourcing 0.0.2

data/lib/event_sourcing/application/actor.rb

@@ -0,0 +1,40 @@
+require "concurrent/actor"
+require "event_sourcing/aggregate/manager"
+require "event_sourcing/command/bus"
+require "event_sourcing/event/bus"
+
+module EventSourcing
+  module Application
+    class Actor < Concurrent::Actor::RestartingContext
+      require "event_sourcing/application/actor/reference"
+
+      def self.to_str #TODO Remove this. It's needed for specs passing under jruby O_o
+        to_s 
+      end
+
+      def default_reference_class
+        Reference
+      end
+
+      def initialize(event_store)
+        @event_store = event_store
+        @event_bus   = EventSourcing::Event::Bus.spawn!(name: :event_bus, supervise: true, args: [@event_store])
+        @aggregate_manager = EventSourcing::Aggregate::Manager.spawn!(name: :aggregate_manager, supervise: true, args: [@event_bus])
+        @command_bus = EventSourcing::Command::Bus.spawn!(name: :command_bus, supervise: true, args: [@aggregate_manager])
+      end
+
+      def on_message(message)
+        case message
+        when :get_command_bus
+          @command_bus
+        when :get_event_bus
+          @event_bus
+        when :get_aggregate_manager
+          @aggregate_manager
+        end
+      end
+    end
+  end
+end
+
+Concurrent::Actor.i_know_it_is_experimental!

data/lib/event_sourcing/application/actor/reference.rb

@@ -0,0 +1,23 @@
+require "concurrent/actor"
+require "event_sourcing/application/actor"
+
+module EventSourcing
+  module Application
+    class Actor
+      class Reference < Concurrent::Actor::Reference
+        def execute_command(command)
+          command_bus.tell(command)
+        end
+
+        def terminate!
+          tell(:terminate!)
+        end
+
+        private
+        def command_bus
+          @command_bus ||= ask!(:get_command_bus)
+        end
+      end
+    end
+  end
+end

data/lib/event_sourcing/command.rb

@@ -0,0 +1,30 @@
+module EventSourcing
+  class Command
+    private_class_method :new
+
+    def self.define(*fields, &block)
+      raise "Commands require an execution block" unless block_given?
+
+      Class.new(self) do
+        public_class_method :new
+        attr_reader(*fields)
+
+        define_method :initialize do |properties = {}|
+          missing_keys = fields - properties.keys
+          
+          if missing_keys.any?
+            raise ArgumentError, "missing keyword: #{missing_keys.first}"
+          end
+
+          fields.each do |field|
+            instance_variable_set("@#{field}", properties[field])
+          end
+        end
+
+        define_method :execute do |*args|
+          instance_exec(*args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/event_sourcing/command/bus.rb

@@ -0,0 +1,16 @@
+require "concurrent/actor"
+
+module EventSourcing
+  class Command
+    class Bus < Concurrent::Actor::RestartingContext
+
+      def initialize(aggregate_manager)
+        @aggregate_manager = aggregate_manager
+      end
+
+      def on_message(command)
+        command.execute(@aggregate_manager)
+      end
+    end
+  end
+end

data/lib/event_sourcing/event.rb

@@ -0,0 +1,29 @@
+module EventSourcing
+  class Event
+
+    private_class_method :new
+
+    def self.define(*fields)
+      Class.new(self) do
+        attr_reader(*fields)
+        public_class_method :new
+
+        define_method :initialize do |properties = {}|
+          missing_keys = fields - properties.keys
+          
+          if missing_keys.any?
+            raise ArgumentError, "missing keyword: #{missing_keys.first}"
+          end
+
+          fields.each do |field|
+            instance_variable_set("@#{field}", properties[field])
+          end
+        end
+
+        def to_s
+          self.class.to_s
+        end
+      end
+    end
+  end
+end

data/lib/event_sourcing/event/bus.rb

@@ -0,0 +1,29 @@
+require "concurrent/actor"
+require "event_sourcing/event/publisher"
+
+module EventSourcing
+  class Event
+    class Bus < Concurrent::Actor::RestartingContext
+
+      require "event_sourcing/event/bus/reference"
+      
+      def initialize(event_store)
+        @store = event_store
+        @publisher = Publisher.spawn!(name: :event_publisher, supervise: true)
+      end
+
+      def on_message(message)
+        case message
+        when :get_event_publisher
+          @publisher
+        when :get_event_store
+          @store
+        end
+      end
+
+      def default_reference_class
+        Reference
+      end
+    end
+  end
+end

data/lib/event_sourcing/event/bus/reference.rb

@@ -0,0 +1,28 @@
+require "concurrent/actor"
+require "event_sourcing/event/bus"
+
+module EventSourcing
+  class Event
+    class Bus
+      class Reference < Concurrent::Actor::Reference
+
+        def publish(events)
+          publisher.publish(events)
+        end
+
+        def get_stream(id)
+          store.get_stream(id)
+        end
+
+        private
+        def publisher
+          @publisher ||= ask!(:get_event_publisher)
+        end
+
+        def store
+          @store ||= ask!(:get_event_store)
+        end
+      end
+    end
+  end
+end

data/lib/event_sourcing/event/publisher.rb

@@ -0,0 +1,47 @@
+require "concurrent/actor"
+
+module EventSourcing
+  class Event
+    class Publisher < Concurrent::Actor::RestartingContext
+
+      require "event_sourcing/event/publisher/reference"
+
+      @subscribers = {}
+
+      class << self
+        attr_reader :subscribers
+
+        def subscribe(klass, event)
+          @subscribers[event.to_s] ||= []
+          @subscribers[event.to_s] << klass
+        end
+      end
+
+      def initialize
+        @subscribed_actors = {}
+        self.class.subscribers.each do |event,subscribers|
+          @subscribed_actors[event] = subscribers.map { |s| actor_for(s) }
+        end
+      end
+
+      def on_message(event)
+        subscribers_for(event).each do |subscriber|
+          subscriber.tell(event) # TODO: Add support for some kind of ACK + recovery
+        end
+      end
+
+      def default_reference_class
+        Reference
+      end
+
+      private
+      def subscribers_for(event)
+        @subscribed_actors[event.to_s] || []
+      end
+
+      def actor_for(subscriber)
+        @actors ||= subscriber.spawn!(name: subscriber.to_s, supervise: true)
+      end
+    end
+  end
+end

data/lib/event_sourcing/event/publisher/reference.rb

@@ -0,0 +1,11 @@
+module EventSourcing
+  class Event
+    class Publisher
+      class Reference < Concurrent::Actor::Reference
+        def publish(event)
+          tell(event)
+        end
+      end
+    end
+  end
+end

data/lib/event_sourcing/event/store.rb

@@ -0,0 +1,8 @@
+module EventSourcing
+  class Event
+    module Store
+      class ConcurrencyError < RuntimeError
+      end
+    end
+  end
+end

data/lib/event_sourcing/event/store/memory.rb

@@ -0,0 +1,43 @@
+require "event_sourcing/event"
+require "event_sourcing/event/store"
+require "event_sourcing/event/stream"
+
+module EventSourcing
+  class Event
+    module Store
+      class Memory
+        def initialize
+          @events_with_stream_id = []
+        end
+
+        def events
+          @events_with_stream_id.map { |e| e[:event] }
+        end
+
+        def get_stream(id)
+          events = events_for(id)
+          EventSourcing::Event::Stream.new(id, events, events.count, self)
+        end
+
+        def append(stream_id, expected_version, events)
+          raise EventSourcing::Event::Store::ConcurrencyError if get_stream(stream_id).version != expected_version
+
+          Array(events).tap do |events|
+            events.each do |event|
+              @events_with_stream_id.push(stream_id: stream_id, event: event)
+            end
+          end
+          nil
+        end
+
+        alias_method :<<,   :append
+        alias_method :push, :append
+
+        protected
+        def events_for(stream_id)
+          @events_with_stream_id.select { |event| event[:stream_id] == stream_id }.map { |event| event[:event] }
+        end
+      end
+    end
+  end
+end

data/lib/event_sourcing/event/stream.rb

@@ -0,0 +1,23 @@
+module EventSourcing
+  class Event
+    class Stream
+      attr_reader :version
+      include Enumerable
+      
+      def initialize(id, events, version, store)
+        @id       = id
+        @events  = events
+        @version = version
+        @store   = store
+      end
+
+      def each(&block)
+        @events.each(&block)
+      end
+
+      def append(events)
+        @store.append(@id, @version, events)
+      end
+    end
+  end
+end

data/lib/event_sourcing/event/subscriber.rb

@@ -0,0 +1,16 @@
+require "event_sourcing/event/publisher"
+
+module EventSourcing
+  class Event
+    class Subscriber < Concurrent::Actor::RestartingContext #TODO: Should be a plain Context?
+      def self.subscribe_to(event, &block)
+        define_method "handle_#{event}", &block
+        Publisher.subscribe(self, event)
+      end
+
+      def on_message(event)
+        send("handle_#{event}", event)
+      end
+    end
+  end
+end

data/lib/event_sourcing/version.rb

@@ -0,0 +1,3 @@
+module EventSourcing
+  VERSION = "0.0.2"
+end

data/spec/concurrent_logging.rb

@@ -0,0 +1,6 @@
+require "concurrent"
+require "logger"
+
+Concurrent.configuration.logger = lambda do |level, progname, message = nil, &block|
+  Logger.new(File.dirname(__FILE__) + '/../log/test.log').add Logger::INFO, message, progname, &block
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require "unit_helper"
+
+RSpec.configure do |config|
+  config.mock_with :rspec do |mocks|
+    mocks.verify_doubled_constant_names = true
+    mocks.verify_partial_doubles = true
+  end
+end

data/spec/support/actor_helpers.rb

@@ -0,0 +1,11 @@
+module ActorHelpers
+  def actor_reference(ref_class)
+    ref_class.new(instance_double("Concurrent::Actor::Core", is_a?: true, path: "Path for #{ref_class} core", context_class: ref_class))
+  end
+
+  def event_double(name)
+    instance_double("EventSourcing::Event", to_s: name)
+  end
+end
+
+RSpec.configuration.include ActorHelpers

data/spec/support/shared_examples/a_store_implementation.rb

@@ -0,0 +1,70 @@
+require "event_sourcing/event"
+
+RSpec.shared_examples "a store implementation" do
+  let(:event) { double("Some event") }
+  let(:another_event) { double("Anothe event") }
+
+  it "is empty when created" do
+    expect(subject.events).to be_empty
+  end
+
+  context "append" do
+    it "returns nil, since it's a command" do
+      expect(subject.append("stream-id", 0, event)).to be_nil
+    end
+
+    it "does nothing if no events are passed to it" do
+      expect { subject.append("stream-id", 0, []) }.not_to change { subject.events.count }
+    end
+  end
+
+  context "when events have been appended" do
+    before do
+      subject.append("stream-id", 0, event)
+    end
+
+    it "they can be retrieved later" do
+      expect(subject.events).to eq([event])
+    end
+
+    it "they can be retrieved by stream" do
+      expect(subject.get_stream("stream-id").to_a).to eq([event])
+    end
+  end
+
+  context "when multiple events are appended" do
+    let(:further_event) { double("Further event")}
+
+    before do
+      subject.append("stream-id", 0, [event, another_event])
+      subject.append("stream-id", 2, [further_event])
+    end
+
+    it "they can be retrieved later" do
+      expect(subject.events).to eq([event, another_event, further_event])
+    end
+
+    it "they can be retrieved by stream" do
+      expect(subject.get_stream("stream-id").to_a).to eq([event, another_event, further_event])
+    end
+  end
+
+  it "locks optimistically per stream" do
+    expect {
+      subject.append("stream-id", 0, event)
+      subject.append("stream-id", 0, another_event)
+    }.to raise_error(EventSourcing::Event::Store::ConcurrencyError)
+  end
+
+  context "with multiple streams" do
+    before do
+      subject.append("stream-id", 0, event)
+      subject.append("another-stream-id", 0, [event, another_event])
+    end
+
+    it "allows retrieval of events by stream id" do
+      expect(subject.get_stream("stream-id").version).to eq(1)
+      expect(subject.get_stream("another-stream-id").version).to eq(2)
+    end
+  end
+end