euston 1.0.1-java

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+gemspec
+

data/Rakefile

@@ -0,0 +1,155 @@
+require 'date'
+require 'rspec/core/rake_task'
+
+#############################################################################
+#
+# Helper functions
+#
+#############################################################################
+
+def name
+  @name ||= Dir['*.gemspec'].first.split('.').first
+end
+
+def version
+  line = File.read("lib/#{name}/version.rb")[/^\s*VERSION\s*=\s*.*/]
+  line.match(/.*VERSION\s*=\s*['"](.*)['"]/)[1]
+end
+
+def date
+  Date.today.to_s
+end
+
+def rubyforge_project
+  name
+end
+
+def gemspec_file
+  "#{name}.gemspec"
+end
+
+def gem_file
+  "#{name}-#{version}.gem"
+end
+
+def replace_header(head, header_name, provider = nil)
+  if provider
+    value = send(provider)
+  else
+    value = "'#{send(header_name)}'"
+  end
+
+  provider ||= header_name
+  head.sub!(/(\.#{header_name}\s*= ).*/) { "#{$1}#{value}"}
+end
+
+def platform
+  jruby? ? '-java' : ''
+end
+
+def platform_dependant_gem_file
+  "#{name}-#{version}#{platform}.gem"
+end
+
+def platform_dependent_version
+  "'#{version}#{platform}'"
+end
+
+def jruby?
+  RUBY_PLATFORM.to_s == 'java'
+end
+
+#############################################################################
+#
+# Custom tasks
+#
+#############################################################################
+
+default_rspec_opts = %w[--colour --format Fuubar]
+
+desc "Run all examples"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = default_rspec_opts
+end
+
+#############################################################################
+#
+# Packaging tasks
+#
+#############################################################################
+
+def built_gem
+  @built_gem ||= Dir["#{name}*.gem"].first
+end
+
+desc "Create tag v#{platform_dependent_version} and build and push #{platform_dependant_gem_file} to Rubygems"
+task :release => :build do
+  unless `git branch` =~ /^\* master$/
+    puts "You must be on the master branch to release!"
+    exit!
+  end
+
+  sh "git commit --allow-empty -a -m 'Release #{platform_dependent_version}'"
+  sh "git tag v#{platform_dependent_version}"
+  sh "git push origin master"
+  sh "git push origin v#{platform_dependent_version}"
+
+  command = "gem push pkg/#{platform_dependant_gem_file}"
+
+  if jruby?
+    puts "--------------------------------------------------------------------------------------"
+    puts "can't push to rubygems using jruby at the moment, so switch to mri and run: #{command}"
+    puts "--------------------------------------------------------------------------------------"
+  else
+    sh command
+  end
+end
+
+desc "Build #{platform_dependant_gem_file} into the pkg directory"
+task :build => :gemspec do
+  sh "mkdir -p pkg"
+  sh "gem build #{gemspec_file}"
+  sh "mv #{built_gem} pkg"
+end
+
+desc "Generate #{gemspec_file}"
+task :gemspec => :validate do
+  # read spec file and split out manifest section
+  spec = File.read(gemspec_file)
+  head, manifest, tail = spec.split("  # = MANIFEST =\n")
+
+  # replace name version and date
+  replace_header(head, :name)
+  replace_header(head, :version)
+  replace_header(head, :date)
+  #comment this out if your rubyforge_project has a different name
+  #replace_header(head, :rubyforge_project)
+
+  # determine file list from git ls-files
+  files = `git ls-files`.
+    split("\n").
+    sort.
+    reject { |file| file =~ /^\./ }.
+    reject { |file| file =~ /^(rdoc|pkg)/ }.
+    map { |file| "    #{file}" }.
+    join("\n")
+
+  # piece file back together and write
+  manifest = "  s.files = %w[\n#{files}\n  ]\n"
+  spec = [head, manifest, tail].join("  # = MANIFEST =\n")
+  File.open(gemspec_file, 'w') { |io| io.write(spec) }
+  puts "Updated #{gemspec_file}"
+end
+
+desc "Validate #{gemspec_file}"
+task :validate do
+  libfiles = Dir['lib/*'] - ["lib/#{name}.rb", "lib/#{name}"]
+  unless libfiles.empty?
+    puts "Directory `lib` should only contain a `#{name}.rb` file and `#{name}` dir."
+    exit!
+  end
+  unless Dir['VERSION*'].empty?
+    puts "A `VERSION` file at root level violates Gem best practices."
+    exit!
+  end
+end

data/euston.gemspec

@@ -0,0 +1,44 @@
+Gem::Specification.new do |s|
+  s.name        = 'euston'
+  s.version     = '1.0.1'
+  s.date        = '2011-09-27'
+  s.platform    = RUBY_PLATFORM.to_s == 'java' ? 'java' : Gem::Platform::RUBY
+  s.authors     = ['Lee Henson', 'Guy Boertje']
+  s.email       = ['lee.m.henson@gmail.com', 'guyboertje@gmail.com']
+  s.summary     = %q{Cqrs tooling.}
+  s.description = ''
+  s.homepage    = 'http://github.com/leemhenson/euston'
+
+  # = MANIFEST =
+  s.files = %w[
+    Gemfile
+    Rakefile
+    euston.gemspec
+    lib/euston.rb
+    lib/euston/aggregate_command_map.rb
+    lib/euston/aggregate_root.rb
+    lib/euston/command_bus.rb
+    lib/euston/command_handler.rb
+    lib/euston/command_headers.rb
+    lib/euston/event_handler.rb
+    lib/euston/event_headers.rb
+    lib/euston/null_logger.rb
+    lib/euston/repository.rb
+    lib/euston/version.rb
+    spec/aggregate_command_map_spec.rb
+    spec/aggregate_root_samples.rb
+    spec/aggregate_root_spec.rb
+    spec/spec_helper.rb
+  ]
+  # = MANIFEST =
+
+  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.add_dependency 'activesupport',       '~> 3.0.9'
+  s.add_dependency 'euston-eventstore',   '~> 1.0.0'
+  s.add_dependency 'require_all',         '~> 1.2.0'
+  s.add_development_dependency 'fuubar',  '~> 0.0.0'
+  s.add_development_dependency 'rspec',   '~> 2.6.0'
+  s.add_development_dependency 'uuid',    '~> 2.3.0'
+end

data/lib/euston/aggregate_command_map.rb

@@ -0,0 +1,91 @@
+module Euston
+  class AggregateMap < Array
+    def find_entry_by_type(type)
+      find { |a| a[:type] == type }
+    end
+
+    def find_entry_with_mapping_match(spec)
+      find { |m| m[:mappings].any_mapping_matching?(spec) }
+    end
+  end
+
+  class AggregateEntry < Hash
+    def find_identifier_by_type(type)
+      mapping = self[:mappings].find_mapping_for_type(type)
+      return mapping[:identifier] if mapping
+      nil
+    end
+  end
+
+  class MappingMap < Array
+    def has_mapping?(value, key = :type)
+      self.any? { |m| m[key] == value }
+    end
+
+    def find_mapping_for_type(type)
+      find { |c| c[:type] == type }
+    end
+
+    def any_mapping_matching?(spec)
+      any? { |c| (c.keys & spec.keys).all? {|k| c[k] == spec[k]} }
+    end
+
+    def find_mapping_matching(spec)
+      find {|c| (c.keys & spec.keys).all? {|k| c[k] == spec[k]} }
+    end
+
+    def push_if_unique(mapping, type)
+      return if has_mapping?(type)
+      push(mapping)
+    end
+  end
+
+  class AggregateCommandMap
+    class << self
+      attr_reader :map #for tests
+
+      def map_command_as_aggregate_constructor(type, command, identifier, to_i = [])
+        @map ||= AggregateMap.new
+        mapping = { :kind => :construct, :type => command, :identifier => identifier, :to_i => to_i }
+        if ( aggregate_entry = @map.find_entry_by_type(type) )
+          aggregate_entry[:mappings].push_if_unique(mapping, command)
+        else
+          @map << AggregateEntry.new.merge!( :type => type, :mappings => MappingMap.new.push(mapping) )
+        end
+      end
+
+      def map_command_as_aggregate_method(type, command, identifier, to_i = [])
+        mapping = { :kind => :consume, :type => command, :identifier => identifier, :to_i => to_i }
+        aggregate_entry =  @map.find_entry_by_type(type)
+        aggregate_entry[:mappings].push_if_unique(mapping, command)
+      end
+
+      def deliver_command(headers, command)
+        args = [headers, command]
+        query = {:kind => :construct, :type => headers.type}
+        if (entry = @map.find_entry_with_mapping_match( query ))
+          aggregate = load_aggregate(entry, *args) || create_aggregate(entry, *args)
+        else
+          query[:kind] = :consume
+          entry = @map.find_entry_with_mapping_match( query )
+          return unless entry
+          aggregate = load_aggregate(entry, *args)
+        end
+        aggregate.consume_command( headers, command )
+      end
+
+      private
+
+      def create_aggregate(map_entry, headers, command)
+        identifier = map_entry.find_identifier_by_type(headers.type)
+        aggregate_id = command[identifier] || Euston.uuid.generate
+        map_entry[:type].new(aggregate_id)
+      end
+
+      def load_aggregate(map_entry, headers, command)
+        identifier = map_entry.find_identifier_by_type(headers.type)
+        Repository.find(map_entry[:type], command[identifier])
+      end
+    end
+  end
+end

data/lib/euston/aggregate_root.rb

@@ -0,0 +1,137 @@
+module Euston
+  module AggregateRoot
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def applies event, version, &consumer
+        define_method "__consume__#{event}__v#{version}" do |*args| instance_exec *args, &consumer end
+      end
+
+      def consumes *arguments, &consumer #*args is an array of symbols plus an optional options hash at the end
+        commands, options = [], {}
+        while (arg = arguments.shift) do
+          commands << arg if arg.is_a?(Symbol)
+            options = arg if arg.is_a?(Hash)
+        end
+        commands.each do |command|
+          define_method "__consume__#{command}" do |*args| instance_exec *args, &consumer end
+
+          map_command :map_command_as_aggregate_method, self, command, options
+        end
+      end
+
+      def created_by command, options = {}, &consumer
+        define_method "__consume__#{command}" do |*args| instance_exec *args, &consumer end
+
+        map_command :map_command_as_aggregate_constructor, self, command, options
+      end
+
+      def hydrate(stream)
+        instance = self.new
+        instance.send :reconstitute_from_history, stream
+        instance
+      end
+
+      private
+
+      def map_command(entry_point, type, command, opts)
+        id = opts.has_key?(:id) ? opts[:id] : :id
+        to_i = opts.key?(:to_i) ? opts[:to_i] : []
+
+        Euston::AggregateCommandMap.send entry_point, type, command, id, to_i
+      end
+    end
+
+    module InstanceMethods
+      def initialize aggregate_id = nil
+        @aggregate_id = aggregate_id unless aggregate_id.nil?
+      end
+
+      attr_reader :aggregate_id
+
+      def initial_version
+        @initial_version ||= 0
+      end
+
+      def has_uncommitted_changes?
+        !uncommitted_events.empty?
+      end
+
+      def committed_commands
+        @committed_commands ||= []
+      end
+
+      def uncommitted_events
+        @uncommitted_events ||= []
+      end
+
+      def consume_command(headers, command)
+        headers = Euston::CommandHeaders.from_hash(headers) if headers.is_a?(Hash)
+        return if committed_commands.include? headers.id
+
+        @current_headers = headers
+        @current_command = command
+
+        handle_command headers, command
+        self
+      end
+
+      def replay_event(headers, event)
+        headers = Euston::EventHeaders.from_hash(headers) if headers.is_a?(Hash)
+        command = headers.command
+        committed_commands << command[:id] unless command.nil? || committed_commands.include?(command[:id])
+
+        handle_event headers, event
+        @initial_version = initial_version + 1
+      end
+
+      def version
+        initial_version + uncommitted_events.length
+      end
+
+      protected
+
+      def apply_event(type, version, body = {})
+        event = Euston::EventStore::EventMessage.new(body.is_a?(Hash) ? body : body.marshal_dump)
+        event.headers.merge! :id => Euston.uuid.generate,
+                             :type => type,
+                             :version => version,
+                             :timestamp => Time.now.to_f
+
+        unless @current_headers.nil?
+          event.headers.merge! :command => @current_headers.to_hash.merge(:body => @current_command)
+        end
+
+        handle_event Euston::EventHeaders.from_hash(event.headers), event.body
+        uncommitted_events << event
+      end
+
+      def handle_command(headers, command)
+        name = "__consume__#{headers.type}"
+        method(name).call OpenStruct.new(command).freeze
+      end
+
+      def handle_event(headers, event)
+        name = "__consume__#{headers.type}__v#{headers.version}"
+        if respond_to? name.to_sym
+          method(name).call OpenStruct.new(event).freeze
+        else
+          raise "Couldn't find an event handler for #{headers.type} (v#{headers.version}) on #{self.class}. Did you forget an 'applies' block?"
+        end
+      end
+
+      def reconstitute_from_history(stream)
+        events = stream.committed_events
+        return if events.empty?
+
+        raise "This aggregate cannot apply a historical event stream because it is not empty." unless uncommitted_events.empty? && initial_version == 0
+
+        @aggregate_id = stream.stream_id
+
+        events.each_with_index do |event, i|
+          replay_event Euston::EventHeaders.from_hash(event.headers), event.body
+        end
+      end
+    end
+  end
+end

data/lib/euston/command_bus.rb

@@ -0,0 +1,10 @@
+module Euston
+  module CommandBus
+    def self.publish headers, command
+      aggregate = AggregateCommandMap.deliver_command headers, command
+      raise "No aggregate found to handle command: #{headers} #{command}" if aggregate.nil?
+
+      Repository.save aggregate
+    end
+  end
+end

data/lib/euston/command_handler.rb

@@ -0,0 +1,25 @@
+module Euston
+  module CommandHandler
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def version number, &consumer
+        define_method "__version__#{number}" do |*args|
+          if block_given?
+            instance_exec *args, &consumer
+          else
+            publish args.shift, args.shift
+          end
+        end
+      end
+    end
+
+    module InstanceMethods
+      protected
+
+      def publish headers, command
+        Euston::CommandBus.publish headers, command
+      end
+    end
+  end
+end

data/lib/euston/command_headers.rb

@@ -0,0 +1,25 @@
+module Euston
+  class CommandHeaders
+    attr_reader :id, :type, :version, :log_completion
+
+    def initialize id, type, version, log_completion = false
+      @id = id
+      @type = type
+      @version = version
+      @log_completion = log_completion
+    end
+
+    def to_hash
+      {
+        :id => id,
+        :type => type,
+        :version => version,
+        :log_completion => log_completion
+      }
+    end
+
+    def self.from_hash hash
+      self.new hash[:id], hash[:type].to_sym, hash[:version], ( hash[:log_completion] || false )
+    end
+  end
+end

data/lib/euston/event_handler.rb

@@ -0,0 +1,13 @@
+module Euston
+  module EventHandler
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def consumes type, version, &consumer
+        define_method "__event_handler__#{type}__#{version}" do |*args|
+          instance_exec *args, &consumer
+        end
+      end
+    end
+  end
+end

data/lib/euston/event_headers.rb

@@ -0,0 +1,17 @@
+module Euston
+  class EventHeaders
+    attr_reader :id, :type, :version, :timestamp, :command
+
+    def initialize id, type, version, timestamp = Time.now, command = nil
+      @id = id
+      @type = type
+      @version = version
+      @timestamp = Time.at(timestamp).utc
+      @command = command
+    end
+
+    def self.from_hash hash
+      self.new hash[:id], hash[:type].to_sym, hash[:version], hash[:timestamp], hash[:command]
+    end
+  end
+end

data/lib/euston/null_logger.rb

@@ -0,0 +1,16 @@
+# extracted from Rack
+# https://github.com/rack/rack/blob/master/lib/rack/nulllogger.rb
+
+require 'singleton'
+
+module Euston
+  class NullLogger
+    include Singleton
+
+    def info(progname = nil, &block);  end
+    def debug(progname = nil, &block); end
+    def warn(progname = nil, &block);  end
+    def error(progname = nil, &block); end
+    def fatal(progname = nil, &block); end
+  end
+end

data/lib/euston/repository.rb

@@ -0,0 +1,20 @@
+module Euston
+  module Repository
+    class << self
+      attr_accessor :event_store
+
+      def find type, id
+        stream = event_store.open_stream :stream_id => id
+        return nil if stream.committed_events.empty?
+
+        type.hydrate stream
+      end
+
+      def save aggregate
+        stream = event_store.open_stream :stream_id => aggregate.aggregate_id
+        aggregate.uncommitted_events.each { |e| stream << e }
+        stream.commit_changes Euston.uuid.generate
+      end
+    end
+  end
+end

data/lib/euston/version.rb

@@ -0,0 +1,3 @@
+module Euston
+  VERSION = "1.0.1"
+end

data/lib/euston.rb

@@ -0,0 +1,25 @@
+require 'active_support/concern'
+require 'require_all'
+require 'ostruct'
+
+module Euston
+  class << self
+    attr_accessor :uuid, :logger
+  end
+end
+
+if RUBY_PLATFORM.to_s == 'java'
+  module Uuid
+    def self.generate
+      Java::JavaUtil::UUID.randomUUID().toString()
+    end
+  end
+else
+  require 'uuid'
+  Uuid = UUID.new
+end
+
+Euston.uuid = Uuid
+
+require 'euston-eventstore'
+require_rel 'euston'

data/spec/aggregate_command_map_spec.rb

@@ -0,0 +1,101 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+module Euston
+
+  describe "AggregateCommandMap" do
+    let(:guid1) {Euston.uuid.generate}
+    let(:guid2) {Euston.uuid.generate}
+
+    let(:command_cw) { { :headers => CommandHeaders.new(Euston.uuid.generate, :create_widget, 1),
+                      :body => { :id => guid1} } }
+    let(:command_iw) { { :headers => CommandHeaders.new(Euston.uuid.generate, :import_widget, 1),
+                      :body => { :id => guid1, :imported_count => 5 } } }
+    let(:command_aw) { { :headers => CommandHeaders.new(Euston.uuid.generate, :log_access_to_widget, 1),
+                      :body => { :widget_id => guid1 } } }
+    let(:command_cp) { { :headers => CommandHeaders.new(Euston.uuid.generate, :create_product, 1),
+                      :body => { :id => guid2} } }
+    let(:command_ip) { { :headers => CommandHeaders.new(Euston.uuid.generate, :import_product, 1),
+                      :body => { :id => guid2, :imported_count => 5 } } }
+    let(:command_ap) { { :headers => CommandHeaders.new(Euston.uuid.generate, :log_access_to_product, 1),
+                      :body => { :product_id => guid2 } } }
+
+    describe "when creating new Aggregates" do
+      let(:aggregate) { Sample::Widget.new( Euston.uuid.generate ) }
+      let(:aggregate2) { Sample::Product.new( Euston.uuid.generate ) }
+
+      it "then side effects are seen" do
+
+        aggregate.committed_commands.should have(0).items
+        aggregate2.committed_commands.should have(0).items
+
+        Sample::Widget.new( Euston.uuid.generate )
+
+        AggregateCommandMap.map.should have(2).items
+
+        #ap AggregateCommandMap.map
+
+        entry1 = AggregateCommandMap.map[0]
+        entry1[:type].should eql(Euston::Sample::Widget)
+        entry1[:mappings].should have(3).items
+
+        entry2 = AggregateCommandMap.map[1]
+        entry2[:type].should eql(Euston::Sample::Product)
+        entry2[:mappings].should have(3).items
+
+      end
+    end
+
+    describe "when consuming commands with first constructor" do
+      it "is followed by a consumes command" do
+
+        results = {}
+        Repository.stub(:find) do |type, id|
+          results[id]
+        end
+
+        aggregate = AggregateCommandMap.deliver_command command_cw[:headers], command_cw[:body]
+        results[aggregate.aggregate_id] = aggregate
+        aggregate.uncommitted_events.should have(1).item
+
+        aggregate2 = AggregateCommandMap.deliver_command command_aw[:headers], command_aw[:body]
+        aggregate2.uncommitted_events.should have(2).items
+
+      end
+    end
+
+    describe "when consuming commands with the second constructor" do
+      it "is followed by a consumes command" do
+
+        results = {}
+        Repository.stub(:find) do |type, id|
+          results[id]
+        end
+
+        aggregate = AggregateCommandMap.deliver_command command_iw[:headers], command_iw[:body]
+        results[aggregate.aggregate_id] = aggregate
+        aggregate.uncommitted_events.should have(1).item
+
+        aggregate2 = AggregateCommandMap.deliver_command command_aw[:headers], command_aw[:body]
+        aggregate2.uncommitted_events.should have(2).items
+      end
+    end
+
+    describe "when consuming commands with the two constructs" do
+      it "is followed by a consumes command" do
+
+        results = {}
+        Repository.stub(:find) do |type, id|
+          results[id]
+        end
+
+        aggregate = AggregateCommandMap.deliver_command command_iw[:headers], command_iw[:body]
+        results[aggregate.aggregate_id] = aggregate
+        aggregate.uncommitted_events.should have(1).item
+        AggregateCommandMap.deliver_command command_iw[:headers], command_iw[:body]
+        AggregateCommandMap.deliver_command command_aw[:headers], command_aw[:body]
+        aggregate.uncommitted_events.should have(3).items
+      end
+    end
+  end
+
+end

data/spec/aggregate_root_samples.rb

@@ -0,0 +1,60 @@
+module Euston
+  module Sample
+    class Widget
+      include Euston::AggregateRoot
+
+      created_by :create_widget do |command|
+        apply_event :widget_created, 1, command
+      end
+
+      created_by :import_widget do |command|
+        apply_event :widget_imported, 1, :access_count => (@access_count || 0) + command.imported_count
+      end
+
+      consumes :log_access_to_widget, :id => :widget_id do |command|
+        apply_event :widget_access_logged, 1, :widget_id => command.widget_id,
+                                       :access_count => @access_count + 1
+      end
+
+      applies :widget_created, 1 do |event|
+        @access_count = 0
+      end
+
+      applies :widget_imported, 1 do |event|
+        @access_count = event.access_count
+      end
+
+      applies :widget_access_logged, 1 do |event|
+        @access_count = event.access_count
+      end
+    end
+
+    class Product
+      include Euston::AggregateRoot
+
+      created_by :create_product do |command|
+        apply_event :product_created, 1, command
+      end
+
+      created_by :import_product do |command|
+        apply_event :product_imported, 1, :access_count => command.imported_count
+      end
+
+      consumes :log_access_to_product, :id => :product_id do |command|
+        apply_event :product_access_logged, 1, :product_id => command.product_id,
+                                       :access_count => @access_count + 1
+      end
+      applies :product_created, 1 do |event|
+        @access_count = 0
+      end
+
+      applies :product_imported, 1 do |event|
+        @access_count = event.access_count
+      end
+
+      applies :product_access_logged, 1 do |event|
+        @access_count = event.access_count
+      end
+    end
+  end
+end

data/spec/aggregate_root_spec.rb

@@ -0,0 +1,22 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+module Euston
+  describe 'aggregate root' do
+    context 'duplicate command consumption' do
+      let(:aggregate) { Sample::Widget.new }
+      let(:aggregate2) { Sample::Widget.new }
+      let(:command) { { :headers => CommandHeaders.new(Euston.uuid.generate, :create_widget, 1),
+                        :body => { :id => Euston.uuid.generate } } }
+
+      it 'does not handle the same command twice' do
+        aggregate.consume_command command[:headers], command[:body]
+        aggregate.uncommitted_events.should have(1).item
+
+        aggregate.uncommitted_events.each { |e| aggregate2.replay_event e.headers, e.body }
+
+        aggregate2.consume_command command[:headers], command[:body]
+        aggregate2.uncommitted_events.should have(0).items
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'euston'
+require 'aggregate_root_samples'

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: euston
+version: !ruby/object:Gem::Version
+  prerelease:
+  version: 1.0.1
+platform: java
+authors:
+- Lee Henson
+- Guy Boertje
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2011-09-27 00:00:00.000000000 +01:00
+default_executable:
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  version_requirements: &2164 !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.9
+    none: false
+  requirement: *2164
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: euston-eventstore
+  version_requirements: &2182 !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+    none: false
+  requirement: *2182
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: require_all
+  version_requirements: &2198 !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+    none: false
+  requirement: *2198
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: fuubar
+  version_requirements: &2214 !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.0
+    none: false
+  requirement: *2214
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rspec
+  version_requirements: &2232 !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.6.0
+    none: false
+  requirement: *2232
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: uuid
+  version_requirements: &2248 !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+    none: false
+  requirement: *2248
+  prerelease: false
+  type: :development
+description: ''
+email:
+- lee.m.henson@gmail.com
+- guyboertje@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Rakefile
+- euston.gemspec
+- lib/euston.rb
+- lib/euston/aggregate_command_map.rb
+- lib/euston/aggregate_root.rb
+- lib/euston/command_bus.rb
+- lib/euston/command_handler.rb
+- lib/euston/command_headers.rb
+- lib/euston/event_handler.rb
+- lib/euston/event_headers.rb
+- lib/euston/null_logger.rb
+- lib/euston/repository.rb
+- lib/euston/version.rb
+- spec/aggregate_command_map_spec.rb
+- spec/aggregate_root_samples.rb
+- spec/aggregate_root_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/leemhenson/euston
+licenses: []
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+requirements: []
+rubyforge_project:
+rubygems_version: 1.5.1
+signing_key:
+specification_version: 3
+summary: Cqrs tooling.
+test_files: []
+...