sandthorn 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 10d8ea5557695337009c236ea93deaf0eef47d13
-  data.tar.gz: d9f2920cb7b31df316859f51ed76864a360b6ccd
+  metadata.gz: 406c440420a9d7f88fe93583721b54b2f5d21248
+  data.tar.gz: 9f9158b4be2dd23d95e952c9a9649a17a2b6b4c5
 SHA512:
-  metadata.gz: bf97fec50cc1c40ff231a1907a4e7e6a134338766329e7eadb69220047b06a3307a18fa1c703952ac497477d78a10480cc80504735d8239102fda77b7f1c895c
-  data.tar.gz: dd51c3758eb294f6f766f7b5fa5d7fc5fe31facdf76bc0eeaa95d44e5c55aae0d898cce785653cbda7104e733d7e201f46c50da430edba179cea9c2ab6c4bda7
+  metadata.gz: cc57b92951bd52e571e2428c33fa81b297bfe6a7a488569fd54cf116f822b5dee4549377adb003344004e4f7868a0aa76086b938cf210b6a45dd378373303a7c
+  data.tar.gz: 2843b99f89f0b2261b0b554f2812dc198b6d21084cf0890a3d2a0b1540bdb1145c49bcf3a5ffeb78a5f07ce1998201a6a21b3e2a24b5da9a43bb0a440fcf8ab8

data/Gemfile.lock

@@ -16,45 +16,51 @@ GEM
       term-ansicolor
       thor
     diff-lcs (1.2.5)
-    docile (1.1.3)
-    gem-release (0.7.1)
+    docile (1.1.5)
+    gem-release (0.7.3)
     method_source (0.8.2)
-    mime-types (2.2)
-    multi_json (1.9.2)
+    mime-types (2.3)
+    multi_json (1.10.1)
+    netrc (0.7.7)
     pg (0.17.1)
-    pry (0.9.12.6)
-      coderay (~> 1.0)
-      method_source (~> 0.8)
+    pry (0.10.0)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
       slop (~> 3.4)
     pry-doc (0.6.0)
       pry (~> 0.9)
       yard (~> 0.8)
-    rake (10.2.2)
-    rest-client (1.6.7)
-      mime-types (>= 1.16)
-    rspec (2.14.1)
-      rspec-core (~> 2.14.0)
-      rspec-expectations (~> 2.14.0)
-      rspec-mocks (~> 2.14.0)
-    rspec-core (2.14.8)
-    rspec-expectations (2.14.5)
-      diff-lcs (>= 1.1.3, < 2.0)
-    rspec-mocks (2.14.6)
+    rake (10.3.2)
+    rest-client (1.7.2)
+      mime-types (>= 1.16, < 3.0)
+      netrc (~> 0.7)
+    rspec (3.0.0)
+      rspec-core (~> 3.0.0)
+      rspec-expectations (~> 3.0.0)
+      rspec-mocks (~> 3.0.0)
+    rspec-core (3.0.3)
+      rspec-support (~> 3.0.0)
+    rspec-expectations (3.0.3)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.0.0)
+    rspec-mocks (3.0.3)
+      rspec-support (~> 3.0.0)
+    rspec-support (3.0.3)
     sandthorn_driver_sequel (1.1.0)
       pg
       sequel
-    sequel (4.9.0)
-    simplecov (0.8.2)
+    sequel (4.13.0)
+    simplecov (0.9.0)
       docile (~> 1.1.0)
       multi_json
       simplecov-html (~> 0.8.0)
     simplecov-html (0.8.0)
-    slop (3.5.0)
+    slop (3.6.0)
     sqlite3 (1.3.9)
     term-ansicolor (1.3.0)
       tins (~> 1.0)
     thor (0.19.1)
-    tins (1.1.0)
+    tins (1.3.0)
     yard (0.8.7.4)
 
 PLATFORMS

data/README.md

@@ -4,16 +4,32 @@
 [![Gem Version](https://badge.fury.io/rb/sandthorn.png)](http://badge.fury.io/rb/sandthorn)
 
 # Sandthorn Event Sourcing
-A ruby framework for saving an object's state as a series of events, and tracking non state changing events.
+A ruby library for saving an object's state as a series of events.
 
-## What is Event Sourcing
+## What is Event Sourcing?
 
 "Capture all changes to an application state as a sequence of events."
 [Event Sourcing](http://martinfowler.com/eaaDev/EventSourcing.html)
 
-## The short story
+## When do I need event sourcing?
 
-Think of it as an object database where you not only what the new value of the attribute is but when and why it changed.
+If the history of how an object came to be is important a well known technique is to generate a separate history log. The log is generated in parallel with the object and all actions to the object needs to be stored to the log by a separate method call. With event sourcing the history log is now integrated with the object and generated based on the actions that are made on the object, the log is now the fact that the object is built upon.
+
+
+## Why Sandthorn?
+
+If you have been following [Uncle Bob](http://blog.8thlight.com/uncle-bob/2014/05/11/FrameworkBound.html) you know what he thinks of the "Rails way" and how we get bound to the Rails framework. We have created Sandthorn to decouple our models from Active Record and restore them to what they should be, i.e., Plain Old Ruby Objects (PORO) with a twist of Sandthorn magic.
+
+Check out examples of Sandthorn:
+
+* [Examples](https://github.com/Sandthorn/sandthorn_examples) including a product shop and TicTacToe game.
+* Live [demo](http://demo.sandthorn.org) comparing Active Record and Sandthorn.
+
+## How do I use Sandthorn?
+
+
+
+Think of it as an object database where you store not only what the new value of an attribute is, but also when and why it changed.
 _Example:_
 
 ```ruby
@@ -65,12 +81,9 @@ ship.save
 
 new_ship = Ship.find ship.id
 puts new_ship.name
-
-# For more info look at the specs.
-
 ```
 
-## Installation
+# Installation
 
 Add this line to your application's Gemfile:
 
@@ -84,18 +97,144 @@ Or install it yourself as:
 
     $ gem install sandthorn
 
-## Usage
+# Configuring Sandthorn
+
+Sandthorn relies on a driver is specific to the data storage that you are using. This means Sandthorn can be used with any data storage given that a driver exists.
+
+To setup a driver you need to add it to your project's Gemfile and configure it in your application code.
+
+    gem 'sandthorn_driver_sequel'
+
+The driver is configured when your application launches. Here's an example of how to do it using the Sequel driver and a sqlite3 database.
+
+```ruby
+url = "sqlite://spec/db/sequel_driver.sqlite3"
+driver = SandthornDriverSequel.driver_from_url(url: url)
+catch_all_config = [ { driver: driver } ]
+Sandthorn.configuration = catch_all_config
+```
+
+First we specify the path to the sqlite3 database in the `url` variable. Secondly, the specific driver is instantiated with the `url`. Hence, the driver could be instantiated using a different configuration, for example, an address to a Postgres database. Finally, `Sandthorn.configure` accepts a keyword list with options. The only option which is required is `driver`.
+
+The first time you use the Sequel driver it is necessary to install the database schema.
+
+```ruby
+url = "sqlite://spec/db/sequel_driver.sqlite3"
+SandthornDriverSequel::Migration.new url: url
+SandthornDriverSequel.migrate_db url: url
+```
+
+Optionally, when using Sandthorn in your tests you can configure it in a `spec_helper.rb` which is then required by your test suites [example](https://github.com/Sandthorn/sandthorn_examples/blob/master/sandthorn_tictactoe/spec/spec_helper.rb#L20-L30). Note that the Sequel driver accepts a special parameter to empty the database between each test.
+
+The Sequel driver is the only production-ready driver to date.
+
+# Usage
+
+Any object that should have event sourcing capability must include the methods provided by `Sandthorn::AggregateRoot`. These make it possible to `commit` events and `save` changes to an aggregate. Use the `include` directive as follows:
+
+```ruby
+require 'sandthorn'
+
+class Board
+  include Sandthorn::AggregateRoot
+end
+```
+
+All objects that include `Sandthorn::AggregateRoot` is provided with an `aggregate_id` which is a [UUID](http://en.wikipedia.org/wiki/Universally_unique_identifier).
+
+### `Sandthorn::AggregateRoot.commit`
+
+It is required that an event is commited to the aggregate to be stored as an event. `commit` extracts the object's delta and locally caches the state changes that has been applied to the aggregate. Commonly, commit is called when an event is applied. In [CQRS](http://martinfowler.com/bliki/CQRS.html), events are named using past tense.
+
+```ruby
+def mark player, pos_x, pos_y
+  # change some state
+  marked
+end
+
+def marked
+  commit
+end
+```
+
+`commit` determines the state changes by monitoring the object's readable fields.
+
+### `Sandthorn::AggregateRoot.save`
+
+Once one or more commits have been applied to an aggregate it should be saved. This means all commited events will be persisted by the specific Sandthorn driver. `save` is called by the owning object.
+
+```ruby
+board = Board.new
+board.mark :o, 0, 1
+board.save
+```
+
+### `Sandthorn::AggregateRoot.all`
+
+It is possible to retrieve an array with all instances of a specific aggregate.
+
+```ruby
+Board.all
+```
+
+Since it return's an `Array` you can, for example, filter on an aggregate's fields
+
+```ruby
+Board.all.select { |board| board.active == true }
+```
+
+### `Sandthorn::AggregateRoot.find`
+
+Using `find` it is possible to retrieve a specific aggregate using it's id.
+
+```ruby
+uuid = '550e8400-e29b-41d4-a716-446655440000'
+board = Board.find(uuid)
+board.aggregate_id == uuid
+```
+
+If no aggregate with the specifid id is found, a `Sandthorn::Errors::AggregateNotFound` exception is raised.
+
+
+### `Sandthorn::AggregateRoot.aggregate_trace`
+
+Using `aggregate_trace` one can store meta data with events. The data is not aggregate specific, for example, one can store who executed a specific command on the aggregate.
+
+```ruby
+board.aggregate_trace {player: "Fred"} do |aggregate|
+   aggregate.mark :o, 0, 1
+   aggregate.save
+end
+```
+
+`aggregate_trace` can also be specified on a class.
+
+````ruby
+Board.aggregate_trace {ip: :127.0.0.1} do
+  board = Board.new
+  board.mark :o , 0, 1
+  board.save
+end
+```
+
+In this case, the resulting events from the commands `new` and `mark` will have the trace `{ip: :127.0.0.1}` attached to them.
+
+
+# Development
+
+Run tests: `rake`
+
+Run benchmark tests: `rake benchmark`
 
-TODO: Write usage instructions here
+Load a console: `rake console`
 
-## Development
+# Contributing
 
-run:
-   `rake console`
+We're happy to accept pull requests that makes the code cleaner or more idiomatic, the documentation more understandable, or improves the testsuite. Even considering opening an issue for what's troubling you or writing a blog post about how you used Sandthorn is  worth a lot too!
 
-## Contributing
+In general, the contribution process for code works like this.
 
-1. Fork it
+1. Fork this repo
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)

data/lib/sandthorn.rb

@@ -58,14 +58,31 @@ module Sandthorn
     def get_events aggregate_types: [], take: 0, after_sequence_number: 0
       drivers = drivers_for_aggregate_types type_names: aggregate_types
       raise Sandthorn::Errors::Error.new "Cannot get events from multiple contexts simultaneously, only one single context can be handled at a time." unless drivers.length == 1
-      driver = drivers.first 
+      driver = drivers.first
       events = driver.get_events aggregate_types: aggregate_types, take: take, after_sequence_number: after_sequence_number
       events.each do |event|
         event[:event_args] = deserialize event[:event_data]
         event.delete(:event_data)
-      end 
+      end
       events
     end
+
+    def obsolete_snapshots type_names: [], min_event_distance: 0
+      drivers = drivers_for_aggregate_types type_names: type_names
+      obsolete = drivers.flat_map { |driver| driver.obsolete_snapshots(class_names: type_names, max_event_distance: min_event_distance) }
+      yielder = []
+      obsolete.each do |single_obsolete|
+          type = Kernel.const_get single_obsolete[:aggregate_type]
+          aggregate = type.aggregate_find single_obsolete[:aggregate_id]
+          if block_given?
+            yield aggregate
+          else
+            yielder << aggregate
+          end
+      end
+      yielder unless block_given?
+    end
+
     private
     def driver_for class_name, &block
       driver = identify_driver_from_class class_name
@@ -73,8 +90,8 @@ module Sandthorn
       driver
     end
     def identify_driver_from_class class_name
-      matches = configuration.select do |conf| 
-        r = Regexp.new "^#{conf[:aggregate_pattern]}" 
+      matches = configuration.select do |conf|
+        r = Regexp.new "^#{conf[:aggregate_pattern]}"
         pattern = class_name.to_s
         conf[:aggregate_pattern].nil? || r.match(pattern)
       end

data/lib/sandthorn/aggregate_root_base.rb

@@ -7,6 +7,7 @@ module Sandthorn
       attr_reader :aggregate_current_event_version
       attr_reader :aggregate_originating_version
       attr_reader :aggregate_stored_serialized_object
+      attr_reader :aggregate_trace_information
 
       alias :id :aggregate_id
 
@@ -22,45 +23,65 @@ module Sandthorn
           event[:event_data] = Sandthorn.serialize event[:event_args]
           event[:event_args] = nil #Not send extra data over the wire
         end
+
         unless aggregate_events.empty?
-          Sandthorn.save_events( aggregate_events, aggregate_originating_version, aggregate_id, self.class.name)
+          Sandthorn.save_events(
+            aggregate_events,
+            aggregate_originating_version,
+            aggregate_id,
+            self.class.name
+          )
+
           @aggregate_events = []
           @aggregate_originating_version = @aggregate_current_event_version
         end
+
         self
       end
 
+      def aggregate_trace args
+        @aggregate_trace_information = args
+        yield self if block_given?
+        @aggregate_trace_information = nil
+      end
+
       def commit *args
         aggregate_attribute_deltas = get_delta
-        
+
         unless aggregate_attribute_deltas.empty?
           method_name = caller_locations(1,1)[0].label.gsub("block in ", "")
           increase_current_aggregate_version!
-          data = {:method_name => method_name, :method_args => args, :attribute_deltas => aggregate_attribute_deltas}
-          data.merge!({trace: @aggregate_trace_information}) unless @aggregate_trace_information.nil? || @aggregate_trace_information.empty?
-          @aggregate_events << ({:aggregate_version => @aggregate_current_event_version, :event_name => method_name, :event_args => data})
+
+          data = {
+            method_name: method_name,
+            method_args: args,
+            attribute_deltas: aggregate_attribute_deltas
+          }
+          trace_information = @aggregate_trace_information
+          unless trace_information.nil? || trace_information.empty?
+            data.merge!({ trace: trace_information })
+          end
+
+          @aggregate_events << ({
+            aggregate_version: @aggregate_current_event_version,
+            event_name: method_name,
+            event_args: data
+          })
         end
+
         self
       end
 
       alias :record_event :commit
-      
-      # def aggregate_trace args
-      #   @aggregate_trace_information = args
-      #   yield self
-      #   @aggregate_trace_information = nil
-      # end
 
       module ClassMethods
 
-        # @@aggregate_trace_information = nil
-        # def aggregate_trace args
-        #   @@aggregate_trace_information = args
-        #   @aggregate_trace_information = args
-        #   yield self
-        #   @@aggregate_trace_information = nil
-        #   @aggregate_trace_information = nil
-        # end
+        @@aggregate_trace_information = nil
+        def aggregate_trace args
+          @@aggregate_trace_information = args
+          yield self
+          @@aggregate_trace_information = nil
+        end
 
         def all
           aggregate_id_list = Sandthorn.get_aggregate_list_by_typename(self.name)
@@ -75,34 +96,41 @@ module Sandthorn
         def aggregate_find aggregate_id
           class_name = self.respond_to?(:name) ? self.name : self.class # to be able to extend a string for example.
           events = Sandthorn.get_aggregate(aggregate_id, class_name)
-          raise Sandthorn::Errors::AggregateNotFound unless events and !events.empty?
 
-          transformed_events = events.map { |e| e.merge(event_args: Sandthorn.deserialize(e[:event_data])) }
+          unless events and !events.empty?
+            raise Sandthorn::Errors::AggregateNotFound
+          end
+
+          transformed_events = events.map do |e|
+            e.merge(event_args: Sandthorn.deserialize(e[:event_data]))
+          end
+
           aggregate_build transformed_events
         end
 
         def new *args
-          aggregate = super
-          aggregate.aggregate_base_initialize
-          aggr = aggregate
-
-          #aggregate.aggregate_trace @@aggregate_trace_information do |aggr|
-          aggregate.aggregate_initialize
-          aggregate.send :set_aggregate_id, Sandthorn.generate_aggregate_id
-          aggregate.send :commit, *args
-          aggregate
-          #end
+          super.tap do |aggregate|
+            aggregate.aggregate_trace @@aggregate_trace_information do |aggr|
+              aggr.aggregate_base_initialize
+              aggr.aggregate_initialize
+              aggr.send :set_aggregate_id, Sandthorn.generate_aggregate_id
+              aggr.send :commit, *args
+              return aggr
+            end
+          end
         end
 
         def aggregate_build events
           current_aggregate_version = 0
+
           if first_event_snapshot?(events)
-            aggregate = start_build_from_snapshot events 
+            aggregate = start_build_from_snapshot events
             current_aggregate_version = aggregate.aggregate_originating_version
             events.shift
           else
             aggregate = start_build_from_new events
           end
+
           attributes = build_instance_vars_from_events events
           current_aggregate_version = events.last[:aggregate_version] unless events.empty?
           aggregate.send :clear_aggregate_events
@@ -112,9 +140,11 @@ module Sandthorn
           aggregate.send :set_instance_variables!, attributes
           aggregate
         end
+
         private
+
         def build_instance_vars_from_events events
-          events.inject({}) do |instance_vars, event |
+          events.each_with_object({}) do |event, instance_vars|
             event_args = event[:event_args]
             event_name = event[:event_name]
             attribute_deltas = event_args[:attribute_deltas]
@@ -124,22 +154,26 @@ module Sandthorn
               end
               instance_vars.merge! deltas
             end
-            instance_vars
           end
         end
+
         def first_event_snapshot? events
           events.first[:event_name].to_sym == :aggregate_set_from_snapshot
         end
+
         def start_build_from_snapshot events
           snapshot = events.first[:event_args][0]
         end
+
         def start_build_from_new events
           new_args = events.first[:event_args][:method_args]
+
           if new_args.nil?
             aggregate = new
           else
-            aggregate = new *new_args
+            aggregate = new(*new_args)
           end
+
           aggregate.send :aggregate_clear_current_event_version!
           aggregate
         end
@@ -154,7 +188,12 @@ module Sandthorn
       end
 
       def extract_relevant_aggregate_instance_variables
-        instance_variables.select { |i| i.to_s=="@aggregate_id" || !i.to_s.start_with?("@aggregate_") }
+        instance_variables.select do |variable|
+          equals_aggregate_id = variable.to_s == "@aggregate_id"
+          does_not_contain_aggregate = !variable.to_s.start_with?("@aggregate_")
+
+          equals_aggregate_id || does_not_contain_aggregate
+        end
       end
 
       def set_orginating_aggregate_version! aggregate_version

data/lib/sandthorn/aggregate_root_marshal.rb

@@ -13,13 +13,17 @@ module Sandthorn
       def set_instance_variables! attribute
         super attribute
         init_vars = extract_relevant_aggregate_instance_variables
-        init_vars.each {|attribute_name| @aggregate_stored_instance_variables[attribute_name] = ::Marshal.dump(instance_variable_get(attribute_name)) }
+
+        init_vars.each do |attribute_name|
+          @aggregate_stored_instance_variables[attribute_name] =
+            ::Marshal.dump(instance_variable_get(attribute_name))
+        end
       end
 
       def get_delta
         deltas = extract_relevant_aggregate_instance_variables
-        deltas.each { |d| delta_attribute(d)}
-        
+        deltas.each { |d| delta_attribute(d) }
+
         result = @aggregate_attribute_deltas
         clear_aggregate_deltas
         result
@@ -30,6 +34,7 @@ module Sandthorn
       def delta_attribute attribute_name
         old_dump = @aggregate_stored_instance_variables[attribute_name]
         new_dump = ::Marshal.dump(instance_variable_get(attribute_name))
+
         unless old_dump == new_dump
           store_attribute_deltas attribute_name, new_dump, old_dump
           store_aggregate_instance_variable attribute_name, new_dump
@@ -39,7 +44,12 @@ module Sandthorn
       def store_attribute_deltas attribute_name, new_dump, old_dump
         new_value_to_store = ::Marshal.load(new_dump)
         old_value_to_store = old_dump ? ::Marshal.load(old_dump) : nil
-        @aggregate_attribute_deltas << { :attribute_name => attribute_name.to_s.delete("@"), :old_value => old_value_to_store, :new_value => new_value_to_store}
+
+        @aggregate_attribute_deltas << {
+          attribute_name: attribute_name.to_s.delete("@"),
+          old_value: old_value_to_store,
+          new_value: new_value_to_store
+        }
       end
 
       def store_aggregate_instance_variable attribute_name, new_dump
@@ -51,4 +61,4 @@ module Sandthorn
       end
     end
   end
-end
+end

data/lib/sandthorn/aggregate_root_snapshot.rb

@@ -9,17 +9,26 @@ module Sandthorn
     end
 
     def aggregate_snapshot!
-      raise Errors::SnapshotError.new "Can't take snapshot on object with unsaved events" if @aggregate_events.count > 0
+      if @aggregate_events.count > 0
+        raise Errors::SnapshotError,
+          "Can't take snapshot on object with unsaved events"
+      end
+
       @aggregate_snapshot = {
-        :event_name => "aggregate_set_from_snapshot",
-        :event_args => [self],
-        :aggregate_version => @aggregate_current_event_version
+        event_name: "aggregate_set_from_snapshot",
+        event_args: [self],
+        aggregate_version: @aggregate_current_event_version
       }
     end
 
     def save_snapshot
-      raise Errors::SnapshotError.new "No snapshot has been created!" unless aggregate_snapshot
-      @aggregate_snapshot[:event_data] = Sandthorn.serialize aggregate_snapshot[:event_args]
+      unless aggregate_snapshot
+        raise Errors::SnapshotError, "No snapshot has been created!"
+      end
+
+      @aggregate_snapshot[:event_data] = Sandthorn
+        .serialize aggregate_snapshot[:event_args]
+
       @aggregate_snapshot[:event_args] = nil
       Sandthorn.save_snapshot aggregate_snapshot, aggregate_id, self.class.name
       @aggregate_snapshot = nil

data/lib/sandthorn/event_inspector.rb

@@ -2,51 +2,83 @@ module Sandthorn
   module EventInspector
     def has_unsaved_event? event_name, options = {}
       unsaved = events_with_trace_info
+
       if self.aggregate_events.empty?
         unsaved = []
       else
-        unsaved.reject! { |e| e[:aggregate_version] < self.aggregate_events.first[:aggregate_version] } 
+        unsaved.reject! do |e| 
+          e[:aggregate_version] < self
+            .aggregate_events.first[:aggregate_version]
+        end
       end
+
       matching_events = unsaved.select { |e| e[:event_name] == event_name }
       event_exists = matching_events.length > 0
       trace = has_trace? matching_events, options.fetch(:trace, {})
 
-      return event_exists && trace
+      !!(event_exists && trace)
     end
+
     def has_saved_event? event_name, options = {}
       saved = events_with_trace_info
-      saved.reject! { |e| e[:aggregate_version] >= self.aggregate_events.first[:aggregate_version] } unless self.aggregate_events.empty?
+
+      unless self.aggregate_events.empty?
+        saved.reject! do |e| 
+          e[:aggregate_version] >= self
+            .aggregate_events.first[:aggregate_version]
+        end
+      end
+
       matching_events = saved.select { |e| e[:event_name] == event_name }
       event_exists = matching_events.length > 0
       trace = has_trace? matching_events, options.fetch(:trace, {})
 
-      return event_exists && trace
+      !!(event_exists && trace)
     end
+
     def has_event? event_name, options = {}
-      matching_events = events_with_trace_info.select { |e| e[:event_name] == event_name }
+      matching_events = events_with_trace_info
+        .select { |e| e[:event_name] == event_name }
+
       event_exists = matching_events.length > 0
       trace = has_trace? matching_events, options.fetch(:trace, {})
-      return event_exists && trace
+      !!(event_exists && trace)
     end
+
     def events_with_trace_info
       saved = Sandthorn.get_aggregate_events self.aggregate_id, self.class 
       unsaved = self.aggregate_events
-      all = saved.concat(unsaved).sort { |a, b| a[:aggregate_version] <=> b[:aggregate_version] }
+      all = saved
+        .concat(unsaved)
+        .sort { |a, b| a[:aggregate_version] <=> b[:aggregate_version] }
+
       extracted = all.collect do |e| 
         if e[:event_args].nil? && !e[:event_data].nil?
           data = Sandthorn.deserialize e[:event_data]
         else
           data = e[:event_args]
         end
-        trace = data[:trace] unless data.nil? || !data.is_a?(Hash)
-        {aggregate_version: e[:aggregate_version], event_name: e[:event_name].to_sym, trace: trace }  
+
+        unless data.nil? || !data.is_a?(Hash)
+          trace = data[:trace]
+        end
+
+        {
+          aggregate_version: e[:aggregate_version],
+          event_name: e[:event_name].to_sym, 
+          trace: trace 
+        }
       end
-      return extracted
+
+      extracted
     end
+
     private
+
     def get_unsaved_events event_name
       self.aggregate_events.select { |e| e[:event_name] == event_name.to_s  }
     end
+
     def get_saved_events event_name
       saved_events = Sandthorn.get_aggregate_events self.aggregate_id, self.class
       saved_events.select { |e| e[:event_name] == event_name.to_s  }
@@ -60,4 +92,4 @@ module Sandthorn
       true
     end
   end
-end
+end

data/lib/sandthorn/version.rb

@@ -1,3 +1,3 @@
 module Sandthorn
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/spec/sandthorn_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+class AnAggregate
+  include Sandthorn::AggregateRoot
+  attr_accessor :test_block_count
+  def initialize
+    @test_block_count = false
+  end
+  def touch; touched; end
+  def touched; commit; end
+end
+
+describe Sandthorn do
+  before(:each) {
+    @aggregate = AnAggregate.new
+    @aggregate.touch
+    @aggregate.save
+  }
+
+  context "when doing snapshots" do
+    it "retrieves a list of obsolete snapshots" do
+      obsolete_aggregates = Sandthorn.obsolete_snapshots type_names: [AnAggregate], min_event_distance: 0
+      expect(obsolete_aggregates).to_not be_empty
+    end
+
+    it "accepts a block that is applied to each aggregate" do
+      obsolete_aggregates = []
+      Sandthorn.obsolete_snapshots type_names: [AnAggregate], min_event_distance: 0 do |aggr|
+        aggr.test_block_count = true
+        obsolete_aggregates << aggr
+      end
+      expect(obsolete_aggregates.all? { |aggregate| aggregate.test_block_count == true }).to be_truthy
+    end
+
+    it "only retrieves aggregates older than min_event_distance" do
+      obsolete_aggregates = Sandthorn.obsolete_snapshots type_names: [AnAggregate], min_event_distance: 10
+      expect(obsolete_aggregates).to be_empty
+    end
+  end
+end

data/spec/tracing_spec.rb

@@ -1,121 +1,107 @@
-# require 'spec_helper'
-# require 'sandthorn/event_inspector'
-# require 'sandthorn/aggregate_root_dirty_hashy'
+require 'spec_helper'
+require 'sandthorn/event_inspector'
+require 'sandthorn/aggregate_root_snapshot'
 
-# class UsualSuspect
-#   include Sandthorn::AggregateRoot::DirtyHashy
+class UsualSuspect
+  include Sandthorn::AggregateRoot
 
-#   def initialize full_name
-#     @full_name = full_name
-#     @charges = []
-#   end
+  def initialize full_name
+    @full_name = full_name
+    @charges = []
+  end
 
-#   def charge_suspect_of_crime! crime_name
-#     suspect_was_charged crime_name
-#   end
+  def charge_suspect_of_crime! crime_name
+    suspect_was_charged crime_name
+  end
   
-#   private
-#   def suspect_was_charged crime_name
-#     @charges << crime_name
-#     record_event crime_name
-#   end
-# end
+  private
+  def suspect_was_charged crime_name
+    @charges << crime_name
+    record_event crime_name
+  end
+end
 
-# class Simple 
-# end
-# module Go
-#   def go
-#     @foo = "bar"
-#     record_event
-#   end
-# end
+class Simple
+  include Sandthorn::AggregateRoot
+end
+module Go
+  def go
+    @foo = "bar"
+    record_event
+  end
+end
 
-# describe "using a traced change" do
-#   context "when extending an instance with aggregate_root" do
-#     it "should record tracing if specified" do
-#       simple = Simple.new
-#       simple.extend Sandthorn::EventInspector
-#       simple.extend Sandthorn::AggregateRoot::DirtyHashy
-#       simple.extend Sandthorn::AggregateRootSnapshot
+describe "using a traced change" do
+  context "when extending an instance with aggregate_root" do
+    it "should record tracing if specified" do
+      simple = Simple.new
+      simple.extend Sandthorn::EventInspector
+      simple.extend Sandthorn::AggregateRootSnapshot
       
-#       simple.extend Go
-#       simple.aggregate_trace "123" do |traced|
-#         traced.go
-#       end
-#       simple.events_with_trace_info.last[:trace].should eql("123")
-#     end
-#   end
-#   context "when not tracing" do
-#     it "should not have any trace event info at all on new" do
-#       suspect = UsualSuspect.new "Ronny"
-#       event = suspect.aggregate_events.first
-#       event[:trace].should be_nil
-#     end
-#     it "should not have any trace event info at all on regular event" do
-#       suspect = UsualSuspect.new "Ronny"
-#       event = suspect.aggregate_events.first
-#       event[:trace].should be_nil
-#     end
-#   end
-#   context "when changing aggregate in a traced context" do
-#     let(:suspect) {UsualSuspect.new("Conny").extend Sandthorn::EventInspector}
-#     it "should record modififier in the event" do
-#       suspect.aggregate_trace "Lars Krantz" do |s|
-#         s.charge_suspect_of_crime! "Theft"
-#       end
-#       event = suspect.events_with_trace_info.last
-#       event[:trace].should eql "Lars Krantz"
-#     end
+      simple.extend Go
+      simple.aggregate_trace "123" do |traced|
+        traced.go
+      end
+      simple.events_with_trace_info.last[:trace].should eql("123")
+    end
+  end
+  context "when not tracing" do
+    it "should not have any trace event info at all on new" do
+      suspect = UsualSuspect.new "Ronny"
+      event = suspect.aggregate_events.first
+      event[:trace].should be_nil
+    end
+    it "should not have any trace event info at all on regular event" do
+      suspect = UsualSuspect.new "Ronny"
+      event = suspect.aggregate_events.first
+      event[:trace].should be_nil
+    end
+  end
+  context "when changing aggregate in a traced context" do
+    let(:suspect) {UsualSuspect.new("Conny").extend Sandthorn::EventInspector}
+    it "should record modififier in the event" do
+      suspect.aggregate_trace "Ture Sventon" do |s|
+        s.charge_suspect_of_crime! "Theft"
+      end
+      event = suspect.events_with_trace_info.last
+      event[:trace].should eql "Ture Sventon"
+    end
 
-#     it "should record optional other tracing information" do
-#       trace_info = {ip: "127.0.0.1", client: "Mozilla"}
-#       suspect.aggregate_trace trace_info do |s| 
-#         s.charge_suspect_of_crime! "Murder"       
-#       end
-#       event = suspect.events_with_trace_info.last
-#       event[:trace].should eql trace_info 
-#     end
-#   end
-#   context "when initializing a new aggregate in a traced context" do
-#     it "should record modifier in the new event" do
-#       UsualSuspect.aggregate_trace "Lars Krantz" do
-#         suspect = UsualSuspect.new("Sonny").extend Sandthorn::EventInspector
-#         event = suspect.events_with_trace_info.first
-#         event[:trace].should eql "Lars Krantz"
-#       end
-#     end
-#     it "should record tracing for all events in the trace block" do
-#       trace_info = {gender: :unknown, occupation: :master} 
-#       UsualSuspect.aggregate_trace trace_info do
-#         suspect = UsualSuspect.new("Sonny").extend Sandthorn::EventInspector
-#         suspect.charge_suspect_of_crime! "Hit and run"
-#         event = suspect.events_with_trace_info.last
-#         event[:trace].should eql trace_info
-#       end
-#     end
-#     it "should record tracing for all events in the trace block" do
-#       trace_info = {user_aggregate_id: "foo-bar-x", gender: :unknown, occupation: :master} 
-#       UsualSuspect.aggregate_trace trace_info do
-#         suspect = UsualSuspect.new("Conny").extend Sandthorn::EventInspector
-#         suspect.charge_suspect_of_crime! "Desception"
-#         event = suspect.events_with_trace_info.last
-#         event[:trace].should eql trace_info
-#       end
-#     end
-#     it "should only record info within block" do
-#       fork do
-#         UsualSuspect.aggregate_trace "Lars Krantz" do
-#           suspect = UsualSuspect.new("Sonny").extend Sandthorn::EventInspector
-#           event = suspect.events_with_trace_info.first
-#           event[:trace].should eql "Lars Krantz"
-#           sleep 1
-#         end
-#       end
-#       sleep 0.5
-#       s2 = UsualSuspect.new("Ronny").extend Sandthorn::EventInspector
-#       event = s2.events_with_trace_info.first
-#       event[:trace].should be_nil
-#     end
-#   end 
+    it "should record optional other tracing information" do
+      trace_info = {ip: "127.0.0.1", client: "Mozilla"}
+      suspect.aggregate_trace trace_info do |s| 
+        s.charge_suspect_of_crime! "Murder"       
+      end
+      event = suspect.events_with_trace_info.last
+      event[:trace].should eql trace_info 
+    end
+  end
+  context "when initializing a new aggregate in a traced context" do
+    it "should record modifier in the new event" do
+      UsualSuspect.aggregate_trace "Ture Sventon" do
+        suspect = UsualSuspect.new("Sonny").extend Sandthorn::EventInspector
+        event = suspect.events_with_trace_info.first
+        event[:trace].should eql "Ture Sventon"
+      end
+    end
+    it "should record tracing for all events in the trace block" do
+      trace_info = {gender: :unknown, occupation: :master} 
+      UsualSuspect.aggregate_trace trace_info do
+        suspect = UsualSuspect.new("Sonny").extend Sandthorn::EventInspector
+        suspect.charge_suspect_of_crime! "Hit and run"
+        event = suspect.events_with_trace_info.last
+        event[:trace].should eql trace_info
+      end
+    end
+    it "should record tracing for all events in the trace block" do
+      trace_info = {user_aggregate_id: "foo-bar-x", gender: :unknown, occupation: :master} 
+      UsualSuspect.aggregate_trace trace_info do
+        suspect = UsualSuspect.new("Conny").extend Sandthorn::EventInspector
+        suspect.charge_suspect_of_crime! "Desception"
+        event = suspect.events_with_trace_info.last
+        event[:trace].should eql trace_info
+      end
+    end
+  end 
 
-# end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sandthorn
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Lars Krantz
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-10 00:00:00.000000000 Z
+date: 2014-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -204,6 +204,7 @@ files:
 - spec/different_driver_spec.rb
 - spec/event_inspector_spec.rb
 - spec/get_events_spec.rb
+- spec/sandthorn_spec.rb
 - spec/spec_helper.rb
 - spec/tracing_spec.rb
 homepage: ''
@@ -240,6 +241,7 @@ test_files:
 - spec/different_driver_spec.rb
 - spec/event_inspector_spec.rb
 - spec/get_events_spec.rb
+- spec/sandthorn_spec.rb
 - spec/spec_helper.rb
 - spec/tracing_spec.rb
 has_rdoc: