eventus 0.2.0

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+*.swp
+vendor/bundle

data/Gemfile

@@ -0,0 +1,11 @@
+source "http://rubygems.org"
+
+gemspec
+
+group :development do
+  gem 'rspec'
+  gem 'guard-rspec'
+  gem 'libnotify' if RUBY_PLATFORM =~ /linux/i
+  gem 'uuid'
+  gem 'kyotocabinet-ruby'
+end

data/Guardfile

@@ -0,0 +1,6 @@
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+end

data/README.md

@@ -0,0 +1,36 @@
+eventus
+===
+
+A Ruby Event Store
+
+License
+---
+
+Copyright (c) 2012, Jason Staten, PeerIntel
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+- Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+- Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+- Neither the name of PeerIntel nor the names of its contributors may be used
+  to endorse or promote products derived from this software without specific
+  prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/Rakefile

@@ -0,0 +1,4 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new

data/eventus.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "eventus/version"
+
+Gem::Specification.new do |s|
+  s.name        = "eventus"
+  s.version     = Eventus::VERSION
+  s.authors     = ["Jason Staten"]
+  s.email       = ["jstaten07@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Event Store}
+  s.description = %q{An Event Store}
+
+  s.rubyforge_project = "eventus"
+
+  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"]
+end

data/lib/eventus/aggregate_root.rb

@@ -0,0 +1,48 @@
+module Eventus
+  module AggregateRoot
+    module ClassMethods
+      def find(id)
+        instance = self.new
+        stream = Eventus::Stream.new(id, persistence)
+        instance.populate(stream)
+        instance
+      end
+
+      def apply(event_name, &block)
+        raise "A block is required" unless block_given?
+        define_method("apply_#{event_name}", &block)
+      end
+
+      def persistence
+        @persistence ||= Eventus.persistence
+      end
+    end
+
+    module InstanceMethods
+      def populate(stream)
+        @stream = stream
+        stream.committed_events.each do |event|
+          apply_change event[:name], event[:body], false
+        end
+      end
+
+      def save
+        @stream.commit
+      end
+
+      protected
+
+      def apply_change(name, body=nil, is_new=true)
+        method_name = "apply_#{name}"
+        self.send method_name, body if self.respond_to?(method_name)
+
+        @stream.add({:name => name, :body => body}) if is_new
+      end
+    end
+
+    def self.included(base)
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods
+    end
+  end
+end

data/lib/eventus/errors.rb

@@ -0,0 +1,3 @@
+module Eventus
+  class ConcurrencyError < ::StandardError; end
+end

data/lib/eventus/persistence/in_memory.rb

@@ -0,0 +1,42 @@
+module Eventus
+  module Persistence
+    class InMemory
+
+      def initialize(options = {})
+        @store = {}
+        @serializer = options.fetch(:serializer) { Eventus::Serializers::Marshal }
+        @mutex = Mutex.new
+      end
+
+      def commit(id, start, events)
+        @mutex.synchronize do
+          pending = {}
+          events.each_with_index do |event, index|
+            key = build_key(id, start + index)
+            raise Eventus::ConcurrencyError if @store.include? key
+            value = @serializer.serialize(event)
+            pending[key] = value
+          end
+          @store.merge! pending
+        end
+      end
+
+      def load(id, min=nil)
+        @mutex.synchronize do
+          keys = @store.keys.select { |k| k.start_with? id }.sort
+
+          if min
+            min_key = build_key(id, min)
+            keys = keys.drop_while { |k| k != min_key }
+          end
+
+          keys.map { |k| @serializer.deserialize(@store[k]) }
+        end
+      end
+
+      def build_key(id, index)
+        id + ("_%07d" % index)
+      end
+    end
+  end
+end

data/lib/eventus/persistence/kyotocabinet.rb

@@ -0,0 +1,45 @@
+require 'kyotocabinet'
+
+module Eventus
+  module Persistence
+    class KyotoCabinet
+
+      def initialize(options = {})
+        @db = ::KyotoCabinet::DB::new
+        @db.open(options[:path], ::KyotoCabinet::DB::OCREATE)
+        @serializer = options.fetch(:serializer) { Eventus::Serializers::Marshal }
+      end
+
+      def commit(id, start, events)
+        pid = pack_hex(id)
+        @db.transaction do
+          events.each_with_index do |event, index|
+            key = build_key(pid, start + index)
+            value = @serializer.serialize(event)
+            raise Eventus::ConcurrencyError unless @db.add(key,value)
+          end
+        end
+      end
+
+      def load(id, min = nil)
+        pid = pack_hex(id)
+        keys = @db.match_prefix(pid)
+
+        if min
+          min_key = build_key(pid, min)
+          keys = keys.drop_while { |k| k != min_key }
+        end
+
+        @db.get_bulk(keys, false).values.map { |obj| @serializer.deserialize(obj) }
+      end
+
+      def pack_hex(id)
+        id.match(/^[0-9a-fA-F]+$/) ? [id].pack('H*') : id
+      end
+
+      def build_key(id, index)
+        id + ("_%07d" % index)
+      end
+    end
+  end
+end

data/lib/eventus/persistence.rb

@@ -0,0 +1,6 @@
+module Eventus
+  module Persistence
+    autoload :KyotoCabinet, 'eventus/persistence/kyotocabinet'
+    autoload :InMemory, 'eventus/persistence/in_memory'
+  end
+end

data/lib/eventus/serializers/marshal.rb

@@ -0,0 +1,15 @@
+module Eventus
+  module Serializers
+    module Marshal
+      class << self
+        def serialize(obj)
+          ::Marshal.dump obj
+        end
+
+        def deserialize(obj)
+          ::Marshal.load obj
+        end
+      end
+    end
+  end
+end

data/lib/eventus/serializers/msgpack.rb

@@ -0,0 +1,17 @@
+require 'msgpack'
+
+module Eventus
+  module Serializers
+    module MessagePack
+      class << self
+        def serialize(obj)
+          ::MessagePack.pack(obj)
+        end
+
+        def deserialize(obj)
+          ::MessagePack.unpack(obj)
+        end
+      end
+    end
+  end
+end

data/lib/eventus/serializers.rb

@@ -0,0 +1,6 @@
+module Eventus
+  module Serializers
+    autoload :Marshal, 'eventus/serializers/marshal'
+    autoload :MessagePack, 'eventus/serializers/msgpack'
+  end
+end

data/lib/eventus/store.rb

@@ -0,0 +1,12 @@
+module Eventus
+  class Store
+
+    def initialize(persistence)
+      @persistence = persistence
+    end
+
+    def open id
+      @persistence.get_events(id)
+    end
+  end
+end

data/lib/eventus/stream.rb

@@ -0,0 +1,39 @@
+module Eventus
+  class Stream
+
+    attr_reader :id, :committed_events, :uncommitted_events
+
+    def initialize(id, persistence)
+      @id = id
+      @persistence = persistence
+      @committed_events = []
+      @uncommitted_events = []
+      load_events @persistence.load(id)
+    end
+
+    def add(event)
+      @uncommitted_events << event
+    end
+
+    alias_method :<<, :add
+
+    def commit
+      @persistence.commit @id, version, @uncommitted_events
+      load_events @uncommitted_events
+      @uncommitted_events.clear
+    rescue ConcurrencyError => e
+      load_events @persistence.load(id, version + 1)
+      raise e
+    end
+
+    def version
+      @committed_events.length
+    end
+
+    private
+
+    def load_events(events)
+      events.each { |e| @committed_events << e }
+    end
+  end
+end

data/lib/eventus/version.rb

@@ -0,0 +1,3 @@
+module Eventus
+  VERSION = "0.2.0"
+end

data/lib/eventus.rb

@@ -0,0 +1,17 @@
+module Eventus
+  autoload :Serializers, 'eventus/serializers'
+  autoload :AggregateRoot, 'eventus/aggregate_root'
+
+  class << self
+
+    def persistence
+      @persistence ||= Eventus::Persistence::InMemory.new
+    end
+
+    def persistence=(val)
+      @persistence = val
+    end
+  end
+end
+
+%w{store stream version persistence errors}.each { |r| require "eventus/#{r}" }

data/spec/aggregate_root_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+class TestAgg
+  include Eventus::AggregateRoot
+
+  attr_accessor :loaded
+
+  def bake_cake
+    apply_change :cake_baked, :flavor => 'strawberry'
+  end
+
+  apply :dino do |e|
+    @loaded = true
+  end
+end
+
+describe Eventus::AggregateRoot do
+  let(:events) { [] }
+  let(:persistence) { stub.as_null_object }
+
+  before do
+    TestAgg.stub(:persistence).and_return(persistence)
+  end
+
+  it "should load a new aggregate from find" do
+    result = TestAgg.find('abc')
+    result.should_not be_nil
+  end
+
+  describe "when events exist" do
+    before do
+      persistence.should_receive(:load).with('abc').and_return(events)
+      events << {:name => 'dino', :body => {}}
+    end
+
+    it "should apply the event" do
+      result = TestAgg.find('abc')
+      result.loaded.should == true
+    end
+  end
+
+  describe "when applying a new change" do
+    let(:aggregate) { TestAgg.new }
+    let(:stream) { stub(:stream, :committed_events => []) }
+
+    before do
+      aggregate.populate(stream)
+    end
+
+    it "should be added to the stream" do
+      stream.should_receive(:add)
+      aggregate.bake_cake
+    end
+  end
+
+  describe "when saving" do
+    let(:aggregate) { TestAgg.new }
+    let(:stream) { stub(:stream, :committed_events => []) }
+
+    before do
+      aggregate.populate(stream)
+    end
+
+    it "should commit stream" do
+      stream.should_receive(:commit)
+      aggregate.save
+    end
+  end
+end

data/spec/persistence/in_memory_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe Eventus::Persistence::InMemory do
+  let(:options) { {:path => '%'} }
+  let(:persistence) { Eventus::Persistence::InMemory.new(options) }
+  let(:uuid) { UUID.new }
+
+  it "should store complex objects" do
+    id = uuid.generate :compact
+    o = {'a' => 'super', 'complex' => ['object', 'with', {'nested' => ['members', 'galore', 1]}]}
+    persistence.commit id, 1, [o]
+
+    result = persistence.load id
+    result[0].should == o
+  end
+
+  it "should return no events when key not found" do
+    result = persistence.load "my_id"
+    result.should be_empty
+  end
+
+  it "should return events ordered" do
+    id = uuid.generate :compact
+    persistence.commit id, 5, ["five", "six"]
+    persistence.commit id, 1, ["one", "two"]
+    persistence.commit id, 3, ["three", "four"]
+    persistence.commit "other", 1, ["cake", "batter"]
+
+    result = persistence.load id
+    result.should == ["one", "two", "three", "four", "five", "six"]
+  end
+
+  describe "when events exist" do
+    let(:id) { uuid.generate :compact }
+    let(:events) { (1..20).map {|i| "Body #{i}"} }
+    before do
+      persistence.commit id, 1, events
+      other_events = (1..60).map {|i| "Other #{i}"}
+      persistence.commit uuid.generate(:compact), 1, events
+    end
+
+    it "should load events" do
+      result = persistence.load id
+      result.length.should == 20
+    end
+
+    it "should throw concurrency exception if the same event number is added" do
+      lambda {persistence.commit id, 3, ["This is taken"]}.should raise_error(Eventus::ConcurrencyError)
+    end
+
+    it "should rollback changes on concurrency error" do
+      persistence.commit id, 3, ["first", "second", "third"] rescue nil
+
+      result = persistence.load id
+      result.length.should == 20
+    end
+
+    it "should load all events from a minimum" do
+      result = persistence.load id, 10
+      result.length.should == 11
+    end
+  end
+
+  describe "when serialization is set" do
+    let(:serializer) { stub }
+    before do
+      options[:serializer] = serializer
+    end
+
+    it "should use serializer" do
+      input = "original"
+      ser = "i'm serialized!"
+
+      serializer.should_receive(:serialize).with(input).and_return(ser)
+      serializer.should_receive(:deserialize).with(ser).and_return(input)
+
+      id = uuid.generate :compact
+
+      persistence.commit id, 1, [input]
+      result = persistence.load id
+      result[0].should == input
+    end
+  end
+end

data/spec/persistence/kyotocabinet_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe Eventus::Persistence::KyotoCabinet do
+  let(:options) { {:path => '%'} }
+  let(:persistence) { Eventus::Persistence::KyotoCabinet.new(options) }
+  let(:uuid) { UUID.new }
+
+  it "should pack keys" do
+    1000.times do
+      key = uuid.generate(:compact)
+      packed = persistence.pack_hex(key)
+      packed.unpack('H*')[0].should == key
+    end
+  end
+
+  it "should not pack non-hex strings" do
+    key = 'abc123q'
+    packed = persistence.pack_hex(key)
+    packed.should == key
+  end
+
+  it "should store complex objects" do
+    id = uuid.generate :compact
+    o = {'a' => 'super', 'complex' => ['object', 'with', {'nested' => ['members', 'galore', 1]}]}
+    persistence.commit id, 1, [o]
+
+    result = persistence.load id
+    result[0].should == o
+  end
+
+  it "should return no events when key not found" do
+    result = persistence.load "my_id"
+    result.should be_empty
+  end
+
+  it "should return events ordered" do
+    id = uuid.generate :compact
+    persistence.commit id, 5, ["five", "six"]
+    persistence.commit id, 1, ["one", "two"]
+    persistence.commit id, 3, ["three", "four"]
+    persistence.commit "other", 1, ["cake", "batter"]
+
+    result = persistence.load id
+    result.should == ["one", "two", "three", "four", "five", "six"]
+  end
+
+  describe "when events exist" do
+    let(:id) { uuid.generate :compact }
+    let(:events) { (1..20).map {|i| "Body #{i}"} }
+    before do
+      persistence.commit id, 1, events
+      other_events = (1..60).map {|i| "Other #{i}"}
+      persistence.commit uuid.generate(:compact), 1, events
+    end
+
+    it "should load events" do
+      result = persistence.load id
+      result.length.should == 20
+    end
+
+    it "should throw concurrency exception if the same event number is added" do
+      lambda {persistence.commit id, 3, ["This is taken"]}.should raise_error(Eventus::ConcurrencyError)
+    end
+
+    it "should rollback changes on concurrency error" do
+      persistence.commit id, 3, ["first", "second", "third"] rescue nil
+
+      result = persistence.load id
+      result.length.should == 20
+    end
+
+    it "should load all events from a minimum" do
+      result = persistence.load id, 10
+      result.length.should == 11
+    end
+  end
+
+  describe "when serialization is set" do
+    let(:serializer) { stub }
+    before do
+      options[:serializer] = serializer
+    end
+
+    it "should use serializer" do
+      input = "original"
+      ser = "i'm serialized!"
+
+      serializer.should_receive(:serialize).with(input).and_return(ser)
+      serializer.should_receive(:deserialize).with(ser).and_return(input)
+
+      id = uuid.generate :compact
+
+      persistence.commit id, 1, [input]
+      result = persistence.load id
+      result[0].should == input
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'bundler/setup'
+
+$:.unshift File.expand_path('../../lib', __FILE__)
+require 'eventus'
+
+Bundler.require :development
+
+Dir[File.join(File.dirname(__FILE__), 'support', '*.rb')].each { |d| require d }
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+end

data/spec/store_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Eventus::Store do
+  let(:persistence) { stub(:persistence).as_null_object }
+  let(:store) { Eventus::Store.new(persistence) }
+  let(:uuid) { UUID.new }
+  let(:stream) { stub(:stream) }
+
+  describe "when opening an event stream" do
+    let(:id) { uuid.generate(:compact) }
+    let(:result) { store.open id }
+
+    it "should request from persistence" do
+      persistence.should_receive(:get_events)
+      result
+    end
+
+    it "should return a stream" do
+      result.should_not be_nil
+    end
+  end
+end

data/spec/stream_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe Eventus::Stream do
+  let(:id) { UUID.generate(:compact) }
+  let(:stream) { Eventus::Stream.new(id, persistence) }
+  let(:persistence) { stub(:persistence).as_null_object }
+
+  it "should use id" do
+    stream.id.should == id
+  end
+
+  it "should have no committed events" do
+    stream.committed_events.should be_empty
+  end
+
+  it "should have no uncommitted events" do
+    stream.uncommitted_events.should be_empty
+  end
+
+  describe "when events available from persistence" do
+    before do
+      persistence.should_receive(:load).and_return([stub, stub])
+    end
+
+    it "should have an equal number of events" do
+      stream.version.should == 2
+    end
+
+    it "should have no uncommitted events" do
+      stream.uncommitted_events.should be_empty
+    end
+  end
+
+  describe "when events added" do
+    before do
+      stream << stub
+      stream.add stub
+    end
+
+    it "should have uncommitted events" do
+      stream.uncommitted_events.length.should == 2
+    end
+
+    describe "when committed" do
+      before do
+        persistence.should_receive(:commit)
+        stream.commit
+      end
+
+      it "should have committed events" do
+        stream.version.should == 2
+      end
+
+      it "should have no uncommitted events" do
+        stream.uncommitted_events.should be_empty
+      end
+    end
+  end
+
+  describe "when a concurrency error occurs" do
+    before do
+      persistence.should_receive(:commit).and_raise(Eventus::ConcurrencyError)
+      stream << stub(:event)
+    end
+
+    it "should reraise concurrency error" do
+      lambda {stream.commit}.should raise_error(Eventus::ConcurrencyError)
+    end
+
+    it "should load latest events" do
+      persistence.should_receive(:load).with(id, 1).and_return([stub, stub, stub])
+      stream.commit rescue nil
+      stream.version.should == 3
+    end
+  end
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: eventus
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+  prerelease: 
+platform: ruby
+authors:
+- Jason Staten
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-09 00:00:00.000000000Z
+dependencies: []
+description: An Event Store
+email:
+- jstaten07@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Guardfile
+- README.md
+- Rakefile
+- eventus.gemspec
+- lib/eventus.rb
+- lib/eventus/aggregate_root.rb
+- lib/eventus/errors.rb
+- lib/eventus/persistence.rb
+- lib/eventus/persistence/in_memory.rb
+- lib/eventus/persistence/kyotocabinet.rb
+- lib/eventus/serializers.rb
+- lib/eventus/serializers/marshal.rb
+- lib/eventus/serializers/msgpack.rb
+- lib/eventus/store.rb
+- lib/eventus/stream.rb
+- lib/eventus/version.rb
+- spec/aggregate_root_spec.rb
+- spec/persistence/in_memory_spec.rb
+- spec/persistence/kyotocabinet_spec.rb
+- spec/spec_helper.rb
+- spec/store_spec.rb
+- spec/stream_spec.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 3611850257360750717
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 3611850257360750717
+requirements: []
+rubyforge_project: eventus
+rubygems_version: 1.8.13
+signing_key: 
+specification_version: 3
+summary: Event Store
+test_files:
+- spec/aggregate_root_spec.rb
+- spec/persistence/in_memory_spec.rb
+- spec/persistence/kyotocabinet_spec.rb
+- spec/spec_helper.rb
+- spec/store_spec.rb
+- spec/stream_spec.rb