rcqrs 0.1.0

data/lib/rcqrs/domain_exception.rb

@@ -0,0 +1,11 @@
+module Rcqrs
+
+  class DomainException < Exception
+    
+    def initialize reason
+      @reason = reason
+    end
+    
+  end
+
+end

data/lib/rcqrs/event_bus.rb

@@ -0,0 +1,59 @@
+module Rcqrs
+
+  class Eventbus
+    
+    def initialize eventstore
+      @eventstore = eventstore
+      @eventhandlers = Hash.new
+      @published_events = Array.new
+    end
+    
+    def load_events aggregate_id
+      @eventstore.load_events(aggregate_id)
+    end
+    
+    def register eventtype, eventhandler
+      @eventhandlers[eventtype] = Array.new unless @eventhandlers.has_key? eventtype
+      unless @eventhandlers[eventtype].include? eventhandler
+        @eventhandlers[eventtype] << eventhandler      
+      end
+    end
+    
+    def publish id, event
+      unless event.is_a? BaseEvent then
+        raise NotAnEventException, "Given event has to inherit from BaseEvent"
+      end
+      @published_events << PublishedEvent.new(id,event)
+    end
+    
+    def commit
+      store_published_time_for_events
+      save_events
+      publish_events
+      flush
+    end
+    
+    private
+    
+    def store_published_time_for_events
+      @published_events.each{|published_event| published_event.event.store_publish_time}
+    end
+    
+    def save_events
+      @eventstore.store(@published_events)
+    end
+    
+    def publish_events
+      @published_events.each do |event_tuple|
+        if @eventhandlers[event_tuple.event.class] != nil
+          @eventhandlers[event_tuple.event.class].each {|handler| handler.handle event_tuple.aggregate_id, event_tuple.event }
+        end      
+      end
+    end
+    
+    def flush
+      @published_events = Array.new
+    end
+  end
+
+end

data/lib/rcqrs/event_collection.rb

@@ -0,0 +1,18 @@
+module Rcqrs
+
+  class EventCollection
+    
+    def initialize aggregateroot_id, events    
+      @events = events
+      @aggregateroot_id = aggregateroot_id   
+    end
+    
+    def commit_to eventstore
+      @events.each do |event|
+        eventstore.publish @aggregateroot_id, event
+      end
+    end
+    
+  end
+
+end

data/lib/rcqrs/event_configuration_base.rb

@@ -0,0 +1,43 @@
+module Rcqrs
+
+  class EventConfigurationBase
+    
+      @configs = Array.new
+    
+    def self.register_handler(handler)
+      handler.handled_events.each do |event_name|      
+        handle(event_name).with(handler)
+      end
+    end
+    
+    def self.register_all_at(eventbus)
+      if(@configs != nil)
+        @configs.each do |config| 
+          eventbus.register config.eventtype, config.eventhandler
+        end
+      end
+    end
+    
+    def self.handle(eventtype)
+      @configs = Array.new if (@configs == nil)
+      config = EventConfig.new(eval(eventtype.to_s))
+      @configs << config
+      config
+    end    
+    
+  end
+  
+  class EventConfig
+    
+    attr_reader :eventtype, :eventhandler
+    
+    def initialize eventtype
+      @eventtype = eventtype
+    end
+    
+    def with eventhandler
+      @eventhandler = eventhandler
+    end
+  end
+
+end

data/lib/rcqrs/event_handler.rb

@@ -0,0 +1,55 @@
+module Rcqrs
+  
+  module EventHandler
+    
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    
+    module ClassMethods
+      
+      def handled_events
+        methods.select {|m| m.to_s.match(/^handle_/)}.map{|m| convert_to_event_name(m[6..-1])}
+      end
+      
+      def convert_to_event_name method
+        full_event_name(method)
+      end
+      
+      def handle aggregate_id, event
+       methodname = handler_method_name(event)
+       send(methodname, aggregate_id,event)
+      end
+                  
+      def handler_method_name(event)
+        "handle" + event.class.name.split("::").last.gsub(/[A-Z]/){|s| "_" + s.downcase}
+      end
+            
+      def namespace namespace
+        @namespace = namespace.to_s + "::"
+      end
+      
+      def handler(event, &handlercode)
+        create_handler_method(event,handlercode)
+        EventConfigurationBase.handle(full_event_name(event)).with(self)
+      end
+      
+      def full_event_name event_name
+        (@namespace || "") + symbol_to_event_name(event_name)
+      end
+      
+      def symbol_to_event_name event
+        name = event.to_s.gsub(/_[a-z]/){|s| s[1].upcase}
+        name[0] = name[0].upcase
+        name
+      end
+
+      def create_handler_method(event,handlercode)
+        itself = (class << self; self; end)             
+        itself.instance_eval do
+          define_method "handle_"+event.to_s.gsub(/[A-Z]/){|s| "_" + s.downcase}, &handlercode
+        end
+      end      
+    end
+  end 
+end

data/lib/rcqrs/event_type_registry.rb

@@ -0,0 +1,16 @@
+module Rcqrs
+
+class EventTypeRegistry
+  
+  @events = Hash.new
+  
+  def self.register name, type
+    @events[name] = type
+  end
+  
+  def self.get_type_for name
+    @events[name]
+  end
+end
+
+end

data/lib/rcqrs/not_an_event_exception.rb

@@ -0,0 +1,7 @@
+module Rcqrs
+
+  class NotAnEventException < Exception
+    
+  end
+
+end

data/lib/rcqrs/published_event.rb

@@ -0,0 +1,15 @@
+module Rcqrs
+  
+  class PublishedEvent
+    attr_accessor :aggregate_id, :event
+    
+    def initialize aggregate_id, event
+      @aggregate_id, @event = aggregate_id, event   
+    end
+    
+    def ==(other)
+      @aggregate_id == other.aggregate_id && @event == other.event
+    end
+  end
+  
+end

data/lib/rcqrs/repository.rb

@@ -0,0 +1,27 @@
+module Rcqrs
+  class Repository
+
+    def initialize event_store
+      @event_store = event_store
+    end
+    
+    def load(aggregate_class, aggregate_id)
+      aggregate = aggregate_class.new aggregate_id
+      events = @event_store.load_events(aggregate_id)
+      aggregate.load_from(events)
+      aggregate
+    end
+    
+    def save aggregate_root
+      aggregate_root.pending_events.commit_to @event_store
+    end
+    
+    def fire aggregate_id, event
+      unless (event.is_a? BaseEvent) then
+        raise NotAnEventException, "Given event has to inherit from BaseEvent"
+      end
+      @event_store.publish(aggregate_id,event)
+    end
+  
+  end
+end

data/lib/rcqrs/unknown_event_exception.rb

@@ -0,0 +1,3 @@
+class UnknownEventException < Exception
+  
+end

data/lib/rcqrs/version.rb

@@ -0,0 +1,3 @@
+module Rcqrs
+  VERSION = "0.1.0"
+end

data/rcqrs.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "rcqrs/version"
+
+Gem::Specification.new do |s|
+  s.name        = "rcqrs"
+  s.version     = Rcqrs::VERSION
+  s.authors     = ["Tim de Putter"]
+  s.email       = ["tim.de.putter83@googlemail.com"]
+  s.summary     = %q{Framework to provide cqrs + eventsourcing functionality in ruby.}
+  s.description = %q{Framework to provide cqrs + eventsourcing functionality in ruby.}
+
+  s.rubyforge_project = "rcqrs"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_runtime_dependency "rest-client"
+
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "rspec-spies"
+  s.add_development_dependency "activemodel"
+  s.add_runtime_dependency "uuid"
+  
+  
+end

data/spec/aggregate_root_base_spec.rb

@@ -0,0 +1,69 @@
+require "spec_helper"
+
+describe Rcqrs::AggregateRootBase do 
+
+  before do
+    @idgenerator = UUID.new
+    @id = @idgenerator.generate
+    @testAggregate = TestAggregateModule::TestAggregate.new @id
+    @mockEventStore = mockup
+    @events = [TestEventModule::TestEvent.new, TestEventModule::TestEvent.new]
+  end
+
+  it "should handle Events" do
+    @testAggregate.doSomething
+    @testAggregate.handledEvents.size.should == 1
+  end
+  
+  it "should events when there is no eventhandler method" do
+    class UnknownEvent < Rcqrs::BaseEvent; end
+    @testAggregate.load_from [TestEventModule::TestEvent.new,UnknownEvent.new]
+  end
+  
+  it "should collect Events in a EventCollection" do
+    @testAggregate.doSomething
+    @testAggregate.pending_events.should be_an_instance_of(Rcqrs::EventCollection)
+  end
+
+  it "should have recorded one event to be committed" do
+    @testAggregate.doSomething
+    @testAggregate.pending_events.commit_to @mockEventStore        
+    @mockEventStore.message(:publish).with(any, any(TestEventModule::TestEvent)).should_be_received
+  end
+  
+  it "should send its uuid to eventstore to be able to assoziate the events with the aggregate" do
+    @testAggregate.doSomething
+    @testAggregate.pending_events.commit_to @mockEventStore
+    @mockEventStore.message(:publish).with(@id, any()).should_be_received   
+  end
+  
+  it "should be able to load from existing events in the eventstore" do
+    @testAggregate.load_from @events
+    @testAggregate.handledEvents[0] == @events[0]
+    @testAggregate.handledEvents[1] == @events[1]
+  end  
+  
+  it "should only pass the new events to the eventstore, not the ones loaded previously" do
+    @testAggregate.load_from @events
+    @testAggregate.doSomething
+    @testAggregate.pending_events.commit_to @mockEventStore
+    @mockEventStore.message(:publish).with(@id,any(TestEventModule::TestEvent)).should_be_received
+  end
+  
+  it "events not inherited from BaseEvent are not allowed to be fired" do
+    expect {@testAggregate.doSomethingStupid}.to raise_error(Rcqrs::NotAnEventException)
+  end
+  
+  it "should allow to define eventhandlers via a class macro" do
+    @testAggregate.handleAnotherTestEvent TestEventModule::AnotherTestEvent.new
+    @testAggregate.handledEvents[0].class.should == TestEventModule::AnotherTestEvent
+  end
+  
+  it "should handle events with eventhandlers defined by class macros" do
+    @testAggregate.do_something_else
+    @testAggregate.handledEvents[0].class.should == TestEventModule::AnotherTestEvent    
+  end
+
+end
+
+

data/spec/base_commandhandler_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+describe Rcqrs::BaseCommandHandler do
+  
+  it "should call execute on inherited class when executeCommand is called" do
+    commandHandler = TestCommandHandler.new nil
+    commandHandler.executeCommand TestCommand.new("param")
+    commandHandler.execute_called?.should == true
+  end
+  
+  it "should validate the given command if it provides validation" do
+    commandHandler = TestCommandHandler.new nil
+    testCommand = TestCommand.new("param")
+    def testCommand.invalid?; true; end
+    expect {commandHandler.executeCommand testCommand}.to raise_error Rcqrs::CommandNotValidException
+  end
+  
+  it "the validation does not fail the command is executed" do
+    commandHandler = TestCommandHandler.new nil
+    testCommand = TestCommand.new("param")
+    def testCommand.invalid?; false; end
+    commandHandler.executeCommand testCommand
+    commandHandler.execute_called?.should == true 
+  end
+  
+  it "should put all validationerrors in the Exception if the validation fails" do
+    begin
+      commandHandler = TestCommandHandler.new nil
+      testCommand = TestCommand.new("param")
+      def testCommand.invalid?; true; end
+      def testCommand.errormessages; ["Error1", "Error2"]; end
+      commandHandler.executeCommand testCommand
+    rescue Rcqrs::CommandNotValidException => exception
+      exception.errors.should == ["Error1", "Error2"]
+    end
+  end
+  
+end

data/spec/base_event_spec.rb

@@ -0,0 +1,26 @@
+describe Rcqrs::BaseEvent do
+
+  class TestEvent < Rcqrs::BaseEvent
+    property :name
+  end
+
+  subject{TestEvent}
+
+  it "should allow to define properties on an event which can be initalized in the constructor" do
+    TestEvent.new(name: "Timbo").name.should == "Timbo"
+  end
+
+  it "should allow to use strings as keys" do
+    TestEvent.new("name" => "Timbo").name.should == "Timbo"
+  end
+
+  it "should reject properties not defined" do
+    lambda {TestEvent.new(age: 23)}.should raise_error
+    lambda {TestEvent.new("age" =>  23)}.should raise_error
+  end
+
+  it "should not allow to define allready used methods as properties" do
+    lambda {class TestEvent; property :data ;end}.should raise_error
+  end
+end
+