rcqrs 0.1.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in rcqrs.gemspec
+gemspec

data/README.md

@@ -0,0 +1,4 @@
+rcqrs
+=====
+
+cqrs in ruby - see http://martinfowler.com/bliki/CQRS.html for details on cqrs

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/rcqrs.rb

@@ -0,0 +1,30 @@
+require "rcqrs/version"
+
+require "uuid"
+require "active_model"
+
+require "rcqrs/repository"
+require "rcqrs/base_event"
+require "rcqrs/aggregate_root_base"
+require "rcqrs/event_collection"
+require "rcqrs/command_source"
+require "rcqrs/base_command_handler"
+require "rcqrs/convention_command_handler"
+require "rcqrs/base_command"
+require "rcqrs/convention_command"
+require "rcqrs/command_not_valid_exception"
+require "rcqrs/denormalizer"
+require "rcqrs/event_bus"
+require "rcqrs/not_an_event_exception"
+require "rcqrs/event_handler"
+require "rcqrs/domain_exception"
+require "rcqrs/event_type_registry"
+require "rcqrs/event_configuration_base"
+require "rcqrs/configuration"
+require "rcqrs/published_event"
+
+require "rcqrs/command_executor"
+
+module Rcqrs
+  # Your code goes here...
+end

data/lib/rcqrs/aggregate_root_base.rb

@@ -0,0 +1,70 @@
+module Rcqrs
+
+  class AggregateRootBase
+    
+    def self.handle(eventtype, &handlercode)
+      define_method "handle" + eventtype.to_s, &handlercode
+    end
+    
+    def initialize id
+      @id = id
+    end
+    
+    def pending_events
+      EventCollection.new @id, events
+    end
+    
+    def load_from events
+      events.each {|event| handle event}
+    end
+        
+    protected
+    
+    def fire event
+      unless event.is_a? BaseEvent then
+        raise NotAnEventException, "Given event has to inherit from BaseEvent"
+      end
+      events << event
+      handle event   
+    end  
+    
+    private
+    
+    def handle event
+      get_handler_method(event).call(event)
+    end
+    
+    def get_handler_method event
+      methodchecker = Proc.new  do |methodSymbol|
+        methodname = methodSymbol.to_s
+        if is_eventhandlermethod methodname, event.class
+          return self.method(methodname)
+        end
+      end
+      self.private_methods.each &methodchecker
+      self.methods.each &methodchecker
+      return self.method(:unknown_handler)
+    end
+    
+    def unknown_handler event
+      
+    end
+    
+    def is_eventhandlermethod(methodname, eventtype)
+      methodname.start_with?("handle") && has_event_type_postfix(methodname,eventtype)
+    end
+    
+    def has_event_type_postfix(methodname, eventtype)
+      methodname[6,methodname.size] == eventtype.name.split("::").last
+    end
+    
+    def events
+      if (@events == nil)
+        @events = Array.new
+      end
+      return @events
+    end
+    
+  end
+
+end

data/lib/rcqrs/base_command.rb

@@ -0,0 +1,22 @@
+module Rcqrs
+
+  class BaseCommand
+    include ActiveModel::Validations
+        
+    def initialize(attributes = {})
+      attributes.each do |name, value|
+        instance_variable_set("@" + name.to_s, value)
+      end
+    end
+    
+    def errormessages
+      errormessages = Array.new
+      errors.each do |attribute, message|
+        errormessages << message
+      end
+      errormessages
+    end  
+  
+  end
+
+end

data/lib/rcqrs/base_command_handler.rb

@@ -0,0 +1,27 @@
+module Rcqrs
+
+  class BaseCommandHandler
+    
+    def initialize repository
+      @repository = repository
+    end
+    
+    def executeCommand command
+      if command.respond_to?(:invalid?) && command.invalid?
+        if command.respond_to? :errormessages
+          raise CommandNotValidException.new(command.errormessages)
+        else
+          raise CommandNotValidException.new []
+        end
+      end
+      execute command
+    end
+    
+    protected
+    def repository
+      @repository
+    end
+  
+  end
+
+end

data/lib/rcqrs/base_event.rb

@@ -0,0 +1,57 @@
+module Rcqrs
+
+  class BaseEvent
+        
+    attr_reader :data, :published_at
+
+    def initialize data = {}
+      data.each do |k,v|
+        raise "Property not defined" unless self.class.has_property(k)
+        instance_variable_set("@#{k}",v)
+      end
+      @data = data
+    end
+
+    def self.property(property_name)
+      raise "data and published_at are not allowed property names" if (["data","published_at"].include? property_name.to_s)
+      @properties = Array.new unless @properties
+      @properties << property_name.to_s
+      attr_reader property_name
+    end
+
+    def self.has_property(property)
+      @properties.include?(property.to_s)
+    end
+    
+    def self.restore_from(data, published_at)
+      self.load_from(data, published_at)
+    end
+    
+    def self.load_from data, published_at
+      event = self.new(data)
+      event.instance_variable_set("@published_at",published_at)
+      event
+    end
+    
+    def store_publish_time
+      raise "Event has allready a publish date" if(@published_at != nil)
+      @published_at = Time.now
+    end
+    
+    def [](index)
+      if @data.has_key?(index)
+        return @data[index]
+      elsif @data.has_key?(index.to_s)
+        return @data[index.to_s]
+      elsif @data.has_key?(index.to_sym)
+        return @data[index.to_sym]
+      end
+    end
+    
+    def == other
+      @data == other.data
+    end
+    
+  end
+
+end

data/lib/rcqrs/command_executor.rb

@@ -0,0 +1,16 @@
+module Rcqrs
+  
+  class CommandExecutor
+    extend Rcqrs::CommandSource
+    
+    def self.eventbus
+      if @eventbus == nil 
+        @eventbus = Rcqrs::Eventbus.new(Configuration.eventstore)
+        EventConfigurationBase.register_all_at(@eventbus)
+      end
+      @eventbus
+    end
+    
+  end
+
+end

data/lib/rcqrs/command_not_valid_exception.rb

@@ -0,0 +1,13 @@
+module Rcqrs
+
+  class CommandNotValidException < Exception
+     
+    attr_accessor :errors
+     
+    def initialize errors
+      @errors = errors
+    end
+  
+  end
+
+end

data/lib/rcqrs/command_source.rb

@@ -0,0 +1,72 @@
+module Rcqrs
+
+  module CommandSource
+    
+    def execute(command, *params)
+      if command.is_a? Symbol
+        commandhandler = get_commandhandler_from_symbol(command)
+        commandhandler.executeCommand(*params)
+      else
+        commandhandler = get_commandhandler_from_command(command)
+        commandhandler.executeCommand(command)
+      end
+      eventbus.commit
+    end
+    
+    def get_commandhandler_from_symbol(command_symbol)
+      commandhandlerclass = get_handler_class_from_command_name command_symbol.to_s
+      commandhandlerclass.new(Repository.new(eventbus))    
+    end
+    
+    def get_commandhandler_from_command command
+      commandhandlerclass = get_commandhandler_class(command)
+      commandhandlerclass.new(Repository.new(eventbus))
+    end
+    
+    def get_commandhandler_class command
+      handler_name = get_handler_class_name(command)
+      handlerclass = eval(handler_name)
+      checkIfInheritsFromBaseHandler handlerclass
+      return handlerclass
+    rescue NameError => e
+        raise CommandHandlerNotFoundError, "Could not find Commandhandler #{handler_name}, root cause: #{e.to_s}"   
+    end
+    
+    def get_handler_class_name command
+      if(command.is_a? ConventionCommand)
+        return ConventionCommandHandler.name
+      else
+        return get_handler_class_from_command_name(command.class.name)
+      end
+    end
+    
+    def get_handler_class_from_command_name command_name
+      handler_name = String.new
+      command_name.to_s.split("_").each do |command_name_part|
+        handler_name << capitalize_only_first(command_name_part)
+      end
+      handler_name << "Handler"
+      return handler_name
+    end
+    
+    def capitalize_only_first phrase
+      phrase[0].upcase + phrase[1..-1]
+    end
+  
+    def checkIfInheritsFromBaseHandler handlerclass
+      unless handlerclass < BaseCommandHandler
+        raise CommandHandlerDoesNotInheritFromBaseError, "#{handlerclass.name} does not inherit from BaseCommandHandler"
+      end
+    end
+  
+  end
+  
+  
+  
+  class Rcqrs::CommandHandlerNotFoundError < Exception
+  end
+  
+  class Rcqrs::CommandHandlerDoesNotInheritFromBaseError < Exception
+  end
+
+end

data/lib/rcqrs/configuration.rb

@@ -0,0 +1,15 @@
+module Rcqrs
+  class Configuration
+    
+    class << self
+    
+      attr_accessor :eventstore, :readmodel_database
+
+      def configure
+        yield self
+      end
+      
+    end
+        
+  end
+end

data/lib/rcqrs/convention_command.rb

@@ -0,0 +1,32 @@
+module Rcqrs
+  
+  class ConventionCommand < Rcqrs::BaseCommand
+    
+    attr_reader :data, :aggregate_id
+    
+    def self.aggregate_id_attribute name
+      define_method(:aggregate_id) do
+        instance_variable_get("@" + name.to_s)
+      end
+    end
+    
+    def self.aggregate aggregate
+      define_method(:aggregate) do
+        return aggregate
+      end
+    end
+      
+    def initialize(attributes = {})
+      super
+      attributes.shift
+      @data = attributes
+    end
+        
+    def == other
+      other.class == self.class && other.aggregate_id == self.aggregate_id && other.data == self.data
+    end
+  
+  
+  end
+
+end

data/lib/rcqrs/convention_command_handler.rb

@@ -0,0 +1,33 @@
+module Rcqrs
+
+  class ConventionCommandHandler < Rcqrs::BaseCommandHandler
+    
+    def execute command
+      account = repository.load(command.aggregate,command.aggregate_id)
+      methodname = get_method_name_from_command command
+      if(command.data.empty?)
+        account.send(methodname)      
+      else
+        account.send(methodname, command.data)
+      end
+      repository.save(account)
+    end
+    
+    def get_method_name_from_command command
+      words = command_name(command).split(%r{[A-Z]})
+      first_letters = command_name(command).scan(%r{[A-Z]})
+      result = String.new
+      words.shift
+      0.upto(words.size-2) do |i|
+        result << first_letters[i].downcase + words[i] + "_"  
+      end
+      result[0..-2]
+    end
+    
+    def command_name command
+      command.class.name.split("::").last
+    end
+    
+  end
+
+end

data/lib/rcqrs/denormalizer.rb

@@ -0,0 +1,79 @@
+module Rcqrs
+
+  module Denormalizer
+    
+    
+    attr_accessor :model      
+    
+    def map to_map
+      if to_map.is_a? Hash
+        return HashMapper.new to_map
+      end
+      return AttributeMapper.new to_map
+    end
+        
+    def method_missing(name, *args,&block)
+      if(Configuration.readmodel_database.respond_to?(name))
+        if(@model)  
+          Configuration.readmodel_database.send(name,model,*args,&block)
+        else
+          Configuration.readmodel_database.send(name,*args,&block)
+        end  
+      else
+        super
+      end    
+    end
+    
+    class AttributeMapper
+      
+      def initialize attribute_specification
+        @attribute_specification = attribute_specification      
+      end
+      
+      def from source
+        @source = source
+        self
+      end
+      
+      def to target
+        @attribute_specification.each do |attribute_name|
+            if(target.is_a? Hash)
+              target[attribute_name] = @source.send(attribute_name)
+            else
+              target.send(attribute_name.to_s + "=",@source.send(attribute_name))
+            end  
+        end
+      end
+           
+    end
+    
+    class HashMapper
+      
+        def initialize hash_to_map
+          @hash_to_map = hash_to_map
+        end
+        
+        def only keys
+          @hash_to_map = @hash_to_map.select {|key,value| keys.count{|k| k.to_s == key.to_s} > 0}
+          self
+        end
+        
+        def to target
+          @hash_to_map.each do |key,value|
+            if(target.is_a? Hash)
+              if(target.has_key? key.to_sym)
+                target[key.to_sym] = value
+              else
+                target[key] = value
+              end  
+            else
+              target.send(key.to_s + "=", value)            
+            end  
+          end
+        end
+        
+    end
+    
+  end
+
+end