history_book 0.1.0

data/README.md

@@ -0,0 +1,30 @@
+# HistoryBook [![Build Status](https://secure.travis-ci.org/jtdowney/history_book.png?branch=master)](http://travis-ci.org/jtdowney/history_book)
+
+HistoryBook is a ruby implementation of the [event sourcing](http://martinfowler.com/eaaDev/EventSourcing.html) pattern.
+
+This library provides an interface for event sourcing over a pluggable back end data store. Currently it supports the [Sequel gem](http://sequel.rubyforge.org/) and its data stores as well as an in-memory data store for testing.
+
+## Usage
+
+To run the example below you will need to install (or place in your Gemfile) both the sequel gem and the pg gem.
+
+```ruby
+HistoryBook.configure(:sequel) do |config|
+  config.connection_string = 'postgres://localhost/history_book'
+end
+
+HistoryBook.open('test_id') do |stream|
+  stream << HistoryBook::Event.new(:customer_created, :name => 'Joe Tester', :address => '100 West Washington')
+  stream.commit
+end
+
+HistoryBook.open('test_id') do |stream|
+  stream.events.each do |event|
+    puts "Playback event #{event.type} with #{event.data.inspect}"
+  end
+end
+```
+
+## License
+
+HistoryBook is released under the [MIT license](http://www.opensource.org/licenses/MIT).

data/lib/history_book.rb

@@ -0,0 +1,39 @@
+require 'active_support/core_ext/hash'
+require 'active_support/inflector'
+require 'multi_json'
+require 'thread'
+
+require 'history_book/event'
+require 'history_book/stream'
+require 'history_book/version'
+
+module HistoryBook
+  class << self
+    attr_reader :config
+  end
+
+  def self.configure(driver)
+    driver_klass = _load_driver(driver)
+
+    unless @config.instance_of?(driver_klass)
+      @config = driver_klass.new
+    end
+
+    if block_given?
+      yield @config
+    end
+  end
+
+  def self.open(id)
+    store = config.create_store
+    yield HistoryBook::Stream.new(id, store)
+  end
+
+  def self._load_driver(driver)
+    path = "history_book/#{driver}/configuration"
+    require path
+    path.classify.constantize
+  rescue LoadError
+    raise "Unable to load #{driver} driver for history_book"
+  end
+end

data/lib/history_book/event.rb

@@ -0,0 +1,14 @@
+module HistoryBook
+  class Event
+    attr_reader :type, :data
+
+    def initialize(type, data = {})
+      @type = type
+      @data = data.with_indifferent_access
+    end
+
+    def ==(other)
+      self.type == other.type && self.data == other.data
+    end
+  end
+end

data/lib/history_book/memory/configuration.rb

@@ -0,0 +1,11 @@
+require 'history_book/memory/store'
+
+module HistoryBook
+  module Memory
+    class Configuration
+      def create_store
+        HistoryBook::Memory::Store.new
+      end
+    end
+  end
+end

data/lib/history_book/memory/store.rb

@@ -0,0 +1,32 @@
+module HistoryBook
+  module Memory
+    class Store
+      @@events = {}
+      @@events_lock = Mutex.new
+
+      def load_events(id, options = {})
+        options = {:from => 1, :to => nil}.merge(options)
+        from, to = options.values_at(:from, :to)
+
+        events = @@events.fetch(id, [])
+        _filter_events(events, from, to)
+      end
+
+      def store_events(id, new_events)
+        new_events = Array(new_events)
+        @@events_lock.synchronize do
+          @@events[id] ||= []
+          @@events[id].concat(new_events)
+        end
+      end
+
+      def _filter_events(events, from, to)
+        if to
+          events = events.reject.with_index { |e, i| i > to - 1 }
+        end
+
+        events.select.with_index { |e, i| i >= from - 1 }
+      end
+    end
+  end
+end

data/lib/history_book/sequel/configuration.rb

@@ -0,0 +1,15 @@
+require 'sequel'
+require 'history_book/sequel/store'
+
+module HistoryBook
+  module Sequel
+    class Configuration
+      attr_accessor :connection_string
+
+      def create_store
+        db = ::Sequel.connect(connection_string)
+        HistoryBook::Sequel::Store.new(db)
+      end
+    end
+  end
+end

data/lib/history_book/sequel/store.rb

@@ -0,0 +1,82 @@
+module HistoryBook
+  module Sequel
+    class Store
+      def initialize(db)
+        @db = db
+
+        _create_events_table
+      end
+
+      def load_events(id, options = {})
+        options = {:from => 1, :to => nil}.merge(options)
+        from, to = options.values_at(:from, :to)
+
+        rows = _load_rows(id, from, to)
+        rows.map do |row|
+          _transform_row(row)
+        end
+      end
+
+      def store_events(id, new_events)
+        @db.transaction do
+          max_revision = _max_revision(id)
+
+          new_events = Array(new_events)
+          new_events.each do |new_event|
+            max_revision += 1
+            @db[:events].insert(
+              :stream_id => id,
+              :revision => max_revision,
+              :timestamp => DateTime.now.utc,
+              :type => new_event.type.to_s,
+              :data => _encode_data(new_event.data)
+            )
+          end
+        end
+      end
+
+      def _create_events_table
+        @db.create_table?(:events) do
+          primary_key :id
+          String :stream_id
+          Integer :revision
+          DateTime :timestamp
+          String :type
+          File :data
+          index [:stream_id, :revision], :unique => true
+        end
+      end
+
+      def _load_rows(id, from, to)
+        rows = @db.
+          from(:events).
+          where(:stream_id => id).
+          where('revision >= ?', from)
+
+        if to
+          rows = rows.where('revision <= ?', to)
+        end
+
+        rows
+      end
+
+      def _max_revision(id)
+        @db.from(:events).where(:stream_id => id).max(:revision) || 0
+      end
+
+      def _encode_data(data)
+        MultiJson.encode(data.to_hash).to_sequel_blob
+      end
+
+      def _decode_data(data)
+        MultiJson.decode(data).with_indifferent_access
+      end
+
+      def _transform_row(row)
+        type = row[:type].to_sym
+        data = _decode_data(row[:data])
+        HistoryBook::Event.new(type, data)
+      end
+    end
+  end
+end

data/lib/history_book/stream.rb

@@ -0,0 +1,22 @@
+module HistoryBook
+  class Stream
+    attr_reader :events, :uncommitted_events
+
+    def initialize(id, store)
+      @id = id
+      @store = store
+      @events = store.load_events(id)
+      @uncommitted_events = []
+    end
+
+    def <<(event)
+      @uncommitted_events << event
+    end
+
+    def commit
+      @store.store_events(@id, @uncommitted_events)
+      @events.concat(@uncommitted_events)
+      @uncommitted_events = []
+    end
+  end
+end

data/lib/history_book/version.rb

@@ -0,0 +1,3 @@
+module HistoryBook
+  VERSION = '0.1.0'
+end

data/spec/history_book/event_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe HistoryBook::Event do
+  describe '==' do
+    it 'should be false if nothing is equal' do
+      event1 = HistoryBook::Event.new(:foo, :bar => 1)
+      event2 = HistoryBook::Event.new(:bar, :foo => 2)
+      event1.should_not == event2
+    end
+
+    it 'should be false if only type is the same' do
+      event1 = HistoryBook::Event.new(:foo, :bar => 1)
+      event2 = HistoryBook::Event.new(:foo, :foo => 2)
+      event1.should_not == event2
+    end
+
+    it 'should be false if only data is the same' do
+      event1 = HistoryBook::Event.new(:foo, :bar => 1)
+      event2 = HistoryBook::Event.new(:bar, :bar => 1)
+      event1.should_not == event2
+    end
+
+    it 'should be true if everything is the same' do
+      event1 = HistoryBook::Event.new(:foo, :bar => 1)
+      event2 = HistoryBook::Event.new(:foo, :bar => 1)
+      event1.should == event2
+    end
+  end
+end

data/spec/history_book/memory/configuration_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe HistoryBook::Memory::Configuration do
+  describe 'create_store' do
+    it 'should return a memory store' do
+      config = HistoryBook::Memory::Configuration.new
+      config.create_store.should be_instance_of(HistoryBook::Memory::Store)
+    end
+  end
+end

data/spec/history_book/memory/store_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe HistoryBook::Memory::Store do
+  before(:each) do
+    HistoryBook::Memory::Store.reset!
+    @store = HistoryBook::Memory::Store.new
+  end
+
+  it_behaves_like 'a storage driver'
+
+  describe 'load_events' do
+    it 'should return events saved across instances' do
+      event1 = HistoryBook::Event.new(:foobar, :foo => 1)
+      event2 = HistoryBook::Event.new(:foobar, :foo => 2)
+
+      store1 = HistoryBook::Memory::Store.new
+      store1.store_events('test_id', event1)
+
+      store2 = HistoryBook::Memory::Store.new
+      store2.store_events('test_id', event2)
+      store2.load_events('test_id').should == [event1, event2]
+    end
+  end
+end

data/spec/history_book/sequel/configuration_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe HistoryBook::Sequel::Configuration do
+  describe 'create_store' do
+    it 'should return a memory store' do
+      config = HistoryBook::Sequel::Configuration.new
+      config.connection_string = 'sqlite:/'
+      config.create_store.should be_instance_of(HistoryBook::Sequel::Store)
+    end
+  end
+end

data/spec/history_book/sequel/store_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe HistoryBook::Sequel::Store do
+  around(:each) do |example|
+    @db = Sequel.sqlite(':memory:')
+    @store = HistoryBook::Sequel::Store.new(@db)
+    @db.transaction do
+      example.run
+    end
+  end
+
+  it_behaves_like 'a storage driver'
+
+  describe 'initialize' do
+    it 'should create an events table' do
+      @db.drop_table?(:events)
+      HistoryBook::Sequel::Store.new(@db)
+      @db.table_exists?(:events).should be_true
+    end
+  end
+end

data/spec/history_book/stream_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe HistoryBook::Stream do
+  before(:each) do
+    HistoryBook::Memory::Store.reset!
+    @store = HistoryBook::Memory::Store.new
+
+    @stream = HistoryBook::Stream.new('test_id', @store)
+  end
+
+  describe '<<' do
+    it 'should append uncommitted events' do
+      event = HistoryBook::Event.new(:foobar, :foo => 1)
+      @stream << event
+      @stream.uncommitted_events.should == [event]
+    end
+  end
+
+  describe 'commit' do
+    it 'should commit all uncommitted events' do
+      event = HistoryBook::Event.new(:foobar, :foo => 1)
+      @stream << event
+      @stream.commit
+      @stream.events.should == [event]
+      @stream.uncommitted_events.should be_empty
+    end
+  end
+
+  describe 'events' do
+    it 'should be empty if there are no prior events' do
+      @stream.events.should be_empty
+    end
+
+    it 'should be populated with existing events' do
+      event = HistoryBook::Event.new(:foobar, :foo => 1)
+      @stream << event
+      @stream.commit
+      @stream = HistoryBook::Stream.new('test_id', @store)
+      @stream.events.should == [event]
+    end
+  end
+
+  describe 'uncommitted_events' do
+    it 'should be empty to start' do
+      @stream.uncommitted_events.should be_empty
+    end
+  end
+end

data/spec/history_book_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe HistoryBook do
+  before(:each) do
+    HistoryBook.configure(:memory)
+    HistoryBook::Memory::Store.reset!
+  end
+
+  describe 'self.configure' do
+    it 'should create a driver specific configuration' do
+      HistoryBook.config.should be_instance_of(HistoryBook::Memory::Configuration)
+    end
+
+    it 'should yield a configuration object' do
+      yielded = false
+      HistoryBook.configure(:memory) do |config|
+        yielded = true
+        config.should == HistoryBook.config
+      end
+      yielded.should be_true
+    end
+
+    it 'should not overwrite an existing configuration object of the same type' do
+      old_config = HistoryBook.config
+      HistoryBook.configure(:memory)
+      HistoryBook.config.object_id.should == old_config.object_id
+    end
+
+    it 'should overwrite an existing configuration object not of the same type' do
+      old_config = HistoryBook.config
+      HistoryBook.configure(:sequel)
+      HistoryBook.config.object_id.should_not == old_config.object_id
+    end
+
+    it 'should raise an error if driver does not exist' do
+      expect do
+        HistoryBook.configure(:asdf)
+      end.to raise_error("Unable to load asdf driver for history_book")
+    end
+  end
+
+  describe 'self.open' do
+    it 'should open an event stream for reading and writting' do
+      event = HistoryBook::Event.new(:something_happened, :foo => 'bar')
+      HistoryBook.open('test_id') do |stream|
+        stream << event
+        stream.commit
+      end
+
+      HistoryBook.open('test_id') do |stream|
+        stream.events.should == [event]
+      end
+    end
+
+    it 'should yield an event stream' do
+      yielded = false
+      HistoryBook.open('test_id') do |stream|
+        yielded = true
+        stream.should_not be_nil
+      end
+      yielded.should be_true
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require 'history_book'
+require 'history_book/memory/configuration'
+require 'history_book/sequel/configuration'
+
+support_dir = File.expand_path('../support', __FILE__)
+Dir.glob("#{support_dir}/**/*.rb") do |file|
+  require file
+end
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.order = 'random'
+end

data/spec/support/resettable_memory_store.rb

@@ -0,0 +1,11 @@
+module HistoryBook
+  module Memory
+    class Store
+      def self.reset!
+        @@events_lock.synchronize do
+          @@events = {}
+        end
+      end
+    end
+  end
+end

data/spec/support/shared_examples_for_stores.rb

@@ -0,0 +1,63 @@
+shared_examples 'a storage driver' do
+  describe 'load_events' do
+    it 'should be empty when no events are stored' do
+      @store.load_events('empty_id').should be_empty
+    end
+
+    it 'should return previously stored events' do
+      event = HistoryBook::Event.new(:foobar, :foo => 1)
+      @store.store_events('test_id', event)
+      @store.load_events('test_id').should == [event]
+    end
+
+    it 'should return all events up to a specified sequence' do
+      event1 = HistoryBook::Event.new(:foobar, :foo => 1)
+      event2 = HistoryBook::Event.new(:foobar, :foo => 2)
+      @store.store_events('test_id', event1)
+      @store.store_events('test_id', event2)
+      @store.load_events('test_id', :to => 1).should == [event1]
+    end
+
+    it 'should return all events since a specified sequence' do
+      event1 = HistoryBook::Event.new(:foobar, :foo => 1)
+      event2 = HistoryBook::Event.new(:foobar, :foo => 2)
+      @store.store_events('test_id', event1)
+      @store.store_events('test_id', event2)
+      @store.load_events('test_id', :from => 2).should == [event2]
+    end
+
+    it 'should return all events in a specified range' do
+      event1 = HistoryBook::Event.new(:foobar, :foo => 1)
+      event2 = HistoryBook::Event.new(:foobar, :foo => 2)
+      event3 = HistoryBook::Event.new(:foobar, :foo => 3)
+      event4 = HistoryBook::Event.new(:foobar, :foo => 4)
+      @store.store_events('test_id', [event1, event2, event3, event4])
+      @store.load_events('test_id', :from => 2, :to => 3).should == [event2, event3]
+    end
+  end
+
+  describe 'store_events' do
+    it 'should store events in order' do
+      event1 = HistoryBook::Event.new(:foobar, :foo => 1)
+      event2 = HistoryBook::Event.new(:foobar, :foo => 2)
+      @store.store_events('test_id', event1)
+      @store.store_events('test_id', event2)
+      @store.load_events('test_id').should == [event1, event2]
+    end
+
+    it 'should store an array of events' do
+      event1 = HistoryBook::Event.new(:foobar, :foo => 1)
+      event2 = HistoryBook::Event.new(:foobar, :foo => 2)
+      @store.store_events('test_id', [event1, event2])
+      @store.load_events('test_id').should == [event1, event2]
+    end
+
+    it 'should store events by id' do
+      event1 = HistoryBook::Event.new(:foobar, :foo => 1)
+      event2 = HistoryBook::Event.new(:foobar, :foo => 2)
+      @store.store_events('test_id1', event1)
+      @store.store_events('test_id2', event2)
+      @store.load_events('test_id1').should == [event1]
+    end
+  end
+end

metadata

@@ -0,0 +1,188 @@
+--- !ruby/object:Gem::Specification
+name: history_book
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- John Downey
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.40'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.40'
+- !ruby/object:Gem::Dependency
+  name: sqlite3-ruby
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: yajl-ruby
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+description: This library provides an interface for event sourcing over a pluggable
+  back end data store. Currently it supports the Sequel gem and its data stores as
+  well as an in-memory data store for testing.
+email:
+- jdowney@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/history_book/event.rb
+- lib/history_book/memory/configuration.rb
+- lib/history_book/memory/store.rb
+- lib/history_book/sequel/configuration.rb
+- lib/history_book/sequel/store.rb
+- lib/history_book/stream.rb
+- lib/history_book/version.rb
+- lib/history_book.rb
+- spec/history_book/event_spec.rb
+- spec/history_book/memory/configuration_spec.rb
+- spec/history_book/memory/store_spec.rb
+- spec/history_book/sequel/configuration_spec.rb
+- spec/history_book/sequel/store_spec.rb
+- spec/history_book/stream_spec.rb
+- spec/history_book_spec.rb
+- spec/spec_helper.rb
+- spec/support/resettable_memory_store.rb
+- spec/support/shared_examples_for_stores.rb
+- README.md
+homepage: http://github.com/jtdowney/history_book
+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'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: HistoryBook is a ruby implementation of the event sourcing pattern.
+test_files:
+- spec/history_book/event_spec.rb
+- spec/history_book/memory/configuration_spec.rb
+- spec/history_book/memory/store_spec.rb
+- spec/history_book/sequel/configuration_spec.rb
+- spec/history_book/sequel/store_spec.rb
+- spec/history_book/stream_spec.rb
+- spec/history_book_spec.rb
+- spec/spec_helper.rb
+- spec/support/resettable_memory_store.rb
+- spec/support/shared_examples_for_stores.rb