gallifrey 0.1.0.beta1

data/History.rdoc

@@ -0,0 +1,3 @@
+=== 0.1.0 / yyyy-mm-dd
+
+* Initial version

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Simon Harris
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,20 @@
+= Gallifrey - Description
+
+  GitHub:     http://github.com/harukizaemon/gallifrey
+  Gemcutter:  http://gemcutter/gems/gallifrey
+  email:      haruki.zaemon@gmail.com
+  IRC:        ##haruki_zaemon on freenode
+
+== Introduction
+
+== Installation
+
+Gallifrey is distributed as a gem via gemcutter (http://gemcutter.org/gems/gallifrey) or as source via GitHub (http://github.com/harukizaemon/gallifrey).
+
+Installation via the gem is easy:
+
+  > gem install gallifrey
+
+Once installed, all that remains is to make the classes available in your code:
+
+  require 'gallifrey'

data/Rakefile

@@ -0,0 +1,5 @@
+Dir[File.expand_path("tasks/**/*.rb")].each do |task_file|
+  require task_file
+end
+
+task :default => [ :spec ]

data/lib/gallifrey/aggregate.rb

@@ -0,0 +1,62 @@
+require 'gallifrey/guid'
+require 'gallifrey/event_application'
+
+module Gallifrey
+
+  class Aggregate
+
+    include EventApplication
+
+    attr_reader :id, :version, :unsaved_events
+
+    def initialize(id = GUID.create)
+      @id = id
+      @version = 0
+      @unsaved_events = []
+    end
+
+    def type
+      self.class.name.gsub(/.*::/, "")
+    end
+
+    def load_from_history(events)
+      events.each { |event| apply_event(event) }
+    end
+
+    def record_event(type, details = {})
+      @unsaved_events.push(Event.new(self.type, id, @version + 1, type, details))
+      apply_event(@unsaved_events.last)
+    end
+
+    def apply_event(event)
+      raise(ArgumentError, "Event out of sequence") unless event.aggregate_version > @version
+      @version = event.aggregate_version
+      super
+    end
+
+    def modified?
+      !@unsaved_events.empty?
+    end
+
+    def mark_as_saved
+      @unsaved_events = []
+    end
+
+    # def load_from_snapshot(snapshot)
+    #   @version = snapshot.version
+    #   load_from_memento(snapshot.memento)
+    # end
+    #
+    # def snapshot
+    #   Snapshot.new(@version, memento)
+    # end
+
+    protected
+
+    def next_entity_id
+      @version + 1
+    end
+
+  end
+
+end

data/lib/gallifrey/aggregate_not_found.rb

@@ -0,0 +1,6 @@
+module Gallifrey
+
+  class AggregateNotFound < StandardError
+  end
+
+end

data/lib/gallifrey/cipher/base64.rb

@@ -0,0 +1,26 @@
+require 'base64'
+require 'gallifrey/cipher/null'
+
+module Gallifrey
+
+  module Cipher
+
+    class Base64
+
+      def initialize(cipher = Null)
+        @cipher = cipher
+      end
+
+      def encrypt(data)
+        ::Base64.encode64(@cipher.encrypt(data))
+      end
+
+      def decrypt(data)
+        @cipher.decrypt(::Base64.decode64(data))
+      end
+
+    end
+
+  end
+
+end

data/lib/gallifrey/cipher/null.rb

@@ -0,0 +1,19 @@
+module Gallifrey
+
+  module Cipher
+
+    module Null
+
+      def self.encrypt(data)
+        data
+      end
+
+      def self.decrypt(data)
+        data
+      end
+
+    end
+
+  end
+
+end

data/lib/gallifrey/cipher/sha256.rb

@@ -0,0 +1,36 @@
+require 'openssl'
+require 'digest/sha2'
+
+module Gallifrey
+
+  module Cipher
+
+    class SHA256
+
+      def initialize(key, cipher_name = "AES-256-CBC")
+        @key = Digest::SHA256.digest(key)
+        @cipher = OpenSSL::Cipher::Cipher.new(cipher_name)
+      end
+
+      def encrypt(data)
+        cipher(:encrypt, data)
+      end
+
+      def decrypt(data)
+        cipher(:decrypt, data)
+      end
+
+      private
+
+      def cipher(mode, data)
+        @cipher.reset
+        @cipher.send(mode)
+        @cipher.key = @key
+        @cipher.update(data) << @cipher.final
+      end
+
+    end
+
+  end
+
+end

data/lib/gallifrey/conflict.rb

@@ -0,0 +1,6 @@
+module Gallifrey
+
+  class Conflict < StandardError
+  end
+
+end

data/lib/gallifrey/entity.rb

@@ -0,0 +1,22 @@
+require 'gallifrey/event_application'
+
+module Gallifrey
+
+  class Entity
+
+    include EventApplication
+
+    attr_reader :id
+
+    def initialize(aggregate, id)
+      @aggregate = aggregate
+      @id = id
+    end
+
+    def record_event(type, data = {})
+      @aggregate.record_event(type, data.merge(:id => id))
+    end
+
+  end
+
+end

data/lib/gallifrey/entity_not_found.rb

@@ -0,0 +1,6 @@
+module Gallifrey
+
+  class EntityNotFound < StandardError
+  end
+
+end

data/lib/gallifrey/event.rb

@@ -0,0 +1,42 @@
+module Gallifrey
+
+  class Event
+
+    attr_reader :aggregate_type, :aggregate_id, :aggregate_version, :type, :details
+    attr_accessor :created_at, :created_by
+
+    def initialize(aggregate_type, aggregate_id, aggregate_version, type, details = {}, created_at = nil, created_by = nil)
+      @aggregate_type = aggregate_type
+      @aggregate_id = aggregate_id
+      @aggregate_version = aggregate_version
+      @type = type
+      @details = details
+      @created_at = created_at
+      @created_by = created_by
+    end
+
+    def [](key)
+      raise(ArgumentError, "No such key #{key.inspect}") unless @details.has_key?(key)
+      @details[key]
+    end
+
+    def audit(created_at, created_by)
+      @created_at = created_at
+      @created_by = created_by
+    end
+
+    def eql?(other)
+      self.class.equal?(other.class) &&
+        aggregate_type == other.aggregate_type &&
+        aggregate_id == other.aggregate_id &&
+        aggregate_version == other.aggregate_version &&
+        type == other.type &&
+        details == other.details &&
+        created_at == other.created_at &&
+        created_by == other.created_by
+    end
+    alias_method :==, :eql?
+
+  end
+
+end

data/lib/gallifrey/event_application.rb

@@ -0,0 +1,22 @@
+module Gallifrey
+
+  module EventApplication
+
+    def apply_event(event)
+      method_name = "apply_#{event.type}"
+      if respond_to?(method_name)
+        send(method_name, event)
+      else
+        unapplied_event(event)
+      end
+    end
+
+    protected
+
+    def unapplied_event(event)
+      raise(ArgumentError, "Unapplied event: #{event.type}")
+    end
+
+  end
+
+end

data/lib/gallifrey/event_processing.rb

@@ -0,0 +1,36 @@
+require 'set'
+
+module Gallifrey
+
+  module EventProcessing
+
+    def process_event(event)
+      event_type = :"#{underscore(event.aggregate_type).downcase}_#{event.type}"
+      event_processors[event_type].each do |block|
+        block.call(event)
+      end
+    end
+
+    protected
+
+    def process(*event_types, &block)
+      event_types.each do |event_type|
+        event_processors[event_type].add(block)
+      end
+    end
+
+    private
+
+    def event_processors
+      @event_processors ||= Hash.new { |event_processors, event_type| event_processors[event_type] = Set.new }
+    end
+
+    def underscore(aggregate_type)
+      aggregate_type
+        .gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+        .gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+    end
+
+  end
+
+end

data/lib/gallifrey/event_store/auditing.rb

@@ -0,0 +1,26 @@
+module Gallifrey
+
+  module EventStore
+
+    class Auditing
+
+      def initialize(event_store, created_by)
+        @event_store = event_store
+        @created_by = created_by
+      end
+
+      def load_events(aggregate_type, aggregate_id, since_version = 0)
+        @event_store.load_events(aggregate_type, aggregate_id, since_version)
+      end
+
+      def save_events(aggregate_type, aggregate_id, events)
+        timestamp = Time.now
+        events.each { |event| event.audit(timestamp, @created_by) }
+        @event_store.save_events(aggregate_type, aggregate_id, events)
+      end
+
+    end
+
+  end
+
+end

data/lib/gallifrey/event_store/null.rb

@@ -0,0 +1,20 @@
+require 'gallifrey/aggregate_not_found'
+
+module Gallifrey
+
+  module EventStore
+
+    module Null
+
+      def self.load_events(aggregate_type, aggregate_id, since_version = 0)
+        raise(AggregateNotFound)
+      end
+
+      def self.save_events(aggregate_type, aggregate_id, events)
+      end
+
+    end
+
+  end
+
+end

data/lib/gallifrey/event_store/publishing.rb

@@ -0,0 +1,25 @@
+module Gallifrey
+
+  module EventStore
+
+    class Publishing
+
+      def initialize(event_store, view)
+        @event_store = event_store
+        @view = view
+      end
+
+      def load_events(aggregate_type, aggregate_id, since_version = 0)
+        @event_store.load_events(aggregate_type, aggregate_id, since_version)
+      end
+
+      def save_events(aggregate_type, aggregate_id, events)
+        @event_store.save_events(aggregate_type, aggregate_id, events)
+        @view.process_events(events)
+      end
+
+    end
+
+  end
+
+end

data/lib/gallifrey/event_store/sequel.rb

@@ -0,0 +1,94 @@
+require 'sequel'
+require 'json'
+require 'gallifrey/event'
+require 'gallifrey/aggregate_not_found'
+require 'gallifrey/cipher/null'
+
+module Gallifrey
+
+  module EventStore
+
+    class Sequel
+
+      def self.migrate(database)
+        database.create_table(:aggregates) do
+          uuid        :id,          :null => false
+          text        :type,        :null => false
+          integer     :version,     :null => false
+          timestamp   :updated_at,  :null => false
+          primary_key [:id]
+        end
+
+        database.create_table(:events) do
+          primary_key :sequence,          :null => false
+          uuid        :aggregate_id,      :null => false
+          integer     :aggregate_version, :null => false
+          text        :type,              :null => false
+          text        :details,           :null => false
+          timestamp   :created_at,        :null => true
+          uuid        :created_by,        :null => true
+          foreign_key [:aggregate_id], :aggregates, :on_delete => :cascade
+          index [:aggregate_id, :aggregate_version], :unique => true
+        end
+      end
+
+      def initialize(database, cipher = Cipher::Null)
+        @aggregates_table = database[:aggregates]
+        @events_table = database[:events]
+        @cipher = cipher
+      end
+
+      def load_events(aggregate_type, aggregate_id, since_version = 0)
+        raise(AggregateNotFound) if @aggregates_table.filter(:id => aggregate_id, :type => aggregate_type).empty?
+
+        @events_table
+          .select(:aggregate_version, :type, :details, :created_at, :created_by)
+          .filter(:aggregate_id => aggregate_id)
+          .filter{aggregate_version > since_version}
+          .order(:aggregate_version)
+          .map do |record|
+            Event.new(
+              aggregate_type,
+              aggregate_id,
+              record[:aggregate_version],
+              record[:type].to_sym,
+              JSON.parse(@cipher.decrypt(record[:details]), :symbolize_names => true),
+              record[:created_at],
+              record[:created_by]
+            )
+          end
+      end
+
+      def save_events(aggregate_type, aggregate_id, events)
+        values = { :version => events.last.aggregate_version, :updated_at => events.last.created_at }
+
+        update_count = @aggregates_table
+          .filter(:id => aggregate_id, :type => aggregate_type, :version => events.first.aggregate_version - 1)
+          .update(values)
+
+        if update_count == 0
+          if aggregate_record = @aggregates_table.first(:id => aggregate_id)
+            raise(TypeError) unless aggregate_record[:type] == aggregate_type
+            raise(Conflict)
+          end
+
+          @aggregates_table.insert(values.merge(:id => aggregate_id, :type => aggregate_type))
+        end
+
+        events.each do |event|
+          @events_table.insert(
+            :aggregate_id => event.aggregate_id,
+            :aggregate_version => event.aggregate_version,
+            :type => event.type.to_s,
+            :details => @cipher.encrypt(JSON.generate(event.details)),
+            :created_at => event.created_at,
+            :created_by => event.created_by
+          )
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/gallifrey/guid.rb

@@ -0,0 +1,25 @@
+require 'uuidtools'
+
+module Gallifrey
+
+  module GUID
+
+    class << self
+
+      def create
+        UUIDTools::UUID.random_create.to_s
+      end
+
+      def parse(guid_string)
+        UUIDTools::UUID.parse(guid_string).to_s
+      end
+
+      def valid?(guid_string)
+        !!parse(guid_string) rescue false
+      end
+
+    end
+
+  end
+
+end

data/lib/gallifrey/repository/default.rb

@@ -0,0 +1,12 @@
+module Repository
+
+  module Default
+
+    def self.new(created_by)
+      event_store = EventStore::Default.new(created_by)
+      Gallifrey::Repository.new(event_store)
+    end
+
+  end
+
+end

data/lib/gallifrey/repository.rb

@@ -0,0 +1,50 @@
+require 'gallifrey/aggregate_not_found'
+require 'gallifrey/aggregate'
+require 'gallifrey/event_store/null'
+
+module Gallifrey
+
+  class Repository
+
+    def initialize(event_store = EventStore::Null)
+      @event_store = event_store
+      @aggregates = {}
+    end
+
+    def add(aggregate)
+      raise(TypeError) unless aggregate.is_a?(Aggregate)
+      @aggregates[aggregate.id] ||= aggregate
+    end
+
+    def get(aggregate_class, aggregate_id)
+      load_from_cache(aggregate_class, aggregate_id) or load_from_event_store(aggregate_class, aggregate_id)
+    end
+
+    def commit
+      @aggregates.each_value do |aggregate|
+        next unless aggregate.modified?
+        @event_store.save_events(aggregate.type, aggregate.id, aggregate.unsaved_events)
+        aggregate.mark_as_saved
+      end
+      @aggregates = {}
+    end
+
+    private
+
+    def load_from_cache(aggregate_class, aggregate_id)
+      if aggregate = @aggregates[aggregate_id]
+        raise(AggregateNotFound) unless aggregate.is_a?(aggregate_class)
+      end
+      aggregate
+    end
+
+    def load_from_event_store(aggregate_class, aggregate_id)
+      @aggregates[aggregate_id] = aggregate_class.new(aggregate_id).tap do |aggregate|
+        # aggregate.load_from_snapshot(@event_store.load_snapshot(aggregate.type, aggregate.id))
+        aggregate.load_from_history(@event_store.load_events(aggregate.type, aggregate.id, aggregate.version))
+      end
+    end
+
+  end
+
+end

data/lib/gallifrey/version.rb

@@ -0,0 +1,5 @@
+module Gallifrey
+
+  VERSION = "0.1.0.beta1".freeze
+
+end

data/lib/gallifrey/view/composite.rb

@@ -0,0 +1,23 @@
+module Gallifrey
+
+  module View
+
+    class Composite
+
+      def initialize(*views)
+        @views = views
+      end
+
+      def process_event(event)
+        @views.each { |view| view.process_event(event) }
+      end
+
+      def delete
+        @views.each(&:delete)
+      end
+
+    end
+
+  end
+
+end

data/lib/gallifrey/view/null.rb

@@ -0,0 +1,17 @@
+module Gallifrey
+
+  module View
+
+    module Null
+
+      def self.process_event(event)
+      end
+
+      def self.delete
+      end
+
+    end
+
+  end
+
+end