event_sourced_record 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 092ed18da567347e5ac8f364e1d0f462f53e017d
-  data.tar.gz: ee8bd1282829f2b7f4f0f67a52415ef5d2d2b433
+  metadata.gz: 11467089bb5e302e5ba7458442510f7c635a9665
+  data.tar.gz: 6eb6064de3952fc90fc8ddba4aea5cf8b417e220
 SHA512:
-  metadata.gz: 5453d5b029fc488d6ac88d910b5c200bc9fe435b30616256c1058aa7dc686024c263ec8f8b66bf3db3427031d2d105d288760bbad91005efdc32096429ac1a68
-  data.tar.gz: c8a38090c8720b7fd0d5476ccd56dec501bebe5503077eafb63da0a7c91834a5af9d4d7911d73f10228619cff5c531f43ab8f9ff00f9efb24ad060ef8fdbd8e7
+  metadata.gz: e6d3a67f2edaf5c8d3907ea7eb2c9423fa39508542673acdcf3b881cabf05301b65893fa6057cfecf393e99f44f07f37afc7a5ab5d07049dea8b57a9ba24992e
+  data.tar.gz: d3ede2905cfacc55d72692e469c7d954eec68fa58b0221b542a38c76fdfea23eb6cc412f627941c7bdf15e36b05d97a0af2229b62bb08fba45b9ae8f780da532

data/Appraisals

@@ -1,3 +1,7 @@
+appraise "rails-3-2" do
+  gem "rails", "3.2.21"
+end
+
 appraise "rails-4-0" do
   gem "rails", "4.0.13"
 end
@@ -5,4 +9,3 @@ end
 appraise "rails-4-2" do
   gem "rails", "4.2.0"
 end
-

data/Getting_Started.md

@@ -0,0 +1,284 @@
+# Getting started with Event Sourced Record
+
+This document is intended to teach you how to use Event Sourced Record, and explains some of the concepts behind event sourcing in general.  It assumes you're already familiar with Rails.
+
+Say you're starting a company that sells a shampoo subscription through the mail, and you want to use Event Sourcing to handle your subscription model.
+
+## Requirements
+
+Event Sourced Record supports Rails 3.2 and higher.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'event_sourced_record'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install event_sourced_record
+    
+Event Sourced Record uses observers, so you'll need to add them to your Gemfile:
+
+    gem 'rails-observers'
+    
+## Generate your classes
+
+You can use `rails generate event_sourced_record` to get started:
+
+    $ rails generate event_sourced_record Subscription \
+            user_id:integer bottles_per_shipment:integer \
+            bottles_left:integer
+            
+This generates two migrations, which you might as well run now:
+
+    $ rake db:migrate
+    
+This takes the same attribute list as `rails generate model`, but generates a number of different types of files.  Let's look at them in turn:
+
+### Subscription
+
+This is the model that you'd create in a typical Rails application, but here you'll find that we don't do much with it directly.
+
+    class Subscription < ActiveRecord::Base
+      has_many :subscription_events
+
+      validates :uuid, uniqueness: true
+    end
+
+`Subscription` holds data in a convenient form, but it's not responsible for changing its own state.  That's the responsiblity of the calculator, using the associated events.
+
+In Event Sourcing parlance, `Subscription` is a "projection", meaning that everything in it can be derived from data and logic that lives elsewhere.
+
+### SubscriptionEvent
+
+You might never end up showing this model to end-users, but in fact it's the authoritative data in this system.  With all the events, you can rebuild the projections, but not the other way around.
+
+`SubscriptionEvent` represents a timestamped event associated with a particular `Subscription`.  Each event should be treated as read-only; it's meant to be written once and then never modified.
+
+    class SubscriptionEvent < ActiveRecord::Base
+      include EventSourcedRecord::Event
+
+      event_type :creation do
+        # attributes :user_id
+        #
+        # validates :user_id, presence: true
+      end
+    end
+
+### SubscriptionCalculator
+
+This service class replays the event sequence to build a Subscription record that reflects current state.  You'll flesh it out by adding methods that advance the state of the Subscription for each individual type of event.
+
+    class SubscriptionCalculator < EventSourcedRecord::Calculator
+      events :subscription_events
+
+      def advance_creation(event)
+
+      end
+    end
+
+
+### SubscriptionEventObserver
+
+You can run `SubscriptionCalculator` yourself whenever you like, but `SubscriptionEventObserver` takes care of a core use-case. It monitors `SubscriptionEvent` (and other event classes, as we'll see) and tells `SubscriptionCalculator` to build or rebuild the `Subscription` every time there's a new event class saved.
+
+    class SubscriptionEventObserver < ActiveRecord::Observer
+      observe :subscription_event
+
+      def after_create(event)
+        SubscriptionCalculator.new(event).run.save!
+      end
+    end
+    
+The generator registers this observer in `config/application.rb`:
+
+    config.active_record.observers = :subscription_event_observer
+
+## Creation
+
+The generated code starts you out with a `creation` event, but we'll want to define it to get some use out of it.
+
+Above, we specified that subscriptions will have `user_id`, `bottles_per_shipment`, and `bottles_left`.  During the creation, we assume we can get `user_id` from `current_user` in the controller, and `bottles_per_shipment` is something that the user will specify during the initial signup.  Let's say, also, that sign up requires that you buy some bottles up-front, which we'll define on the initial event but not on `Subscription`.
+
+### Define the creation event type
+
+Fill out the `event_type` block in `subscription_event.rb`:
+
+    class SubscriptionEvent < ActiveRecord::Base
+      include EventSourcedRecord::Event
+
+      event_type :creation do
+        attributes :bottles_per_shipment, :bottles_purchased, :user_id
+
+        validates :bottles_per_shipment, presence: true, numericality: true
+        validates :bottles_purchased, presence: true, numericality: true
+        validates :user_id, presence: true
+      end
+    end
+    
+This lets you build and save events with the attributes `bottles_per_shipment`,
+`bottles_purchased`, and `user_id`, and validates those attributes -- as long as the event type is set by using the auto-generated scope:
+
+    event = SubscriptionEvent.creation.new(
+      bottles_purchased: 6,
+      user_id: current_user.id
+    )
+    puts "Trying to purchase #{event.bottles_purchased} bottles"
+    event.valid?                         # false
+    event.errors[:bottles_per_shipment]  # ["can't be blank", "is not a number"]    
+
+### Handle the creation in the calculator
+
+Fill out the `advance_creation` method in `subscription_calculator.rb`:
+
+    class SubscriptionCalculator < EventSourcedRecord::Calculator
+      events :subscription_events
+
+      def advance_creation(event)
+        @subscription.user_id = event.user_id
+        @subscription.bottles_per_shipment = event.bottles_per_shipment
+        @subscription.bottles_left = event.bottles_purchased
+      end
+    end
+    
+Note that for `user_id` and `bottles_per_shipment` we simply copy the field from the event to the subscription, but in the case of `bottles_purchased`, that is translated to `Subscription#bottles_left`.  This field will go up and down over time.
+
+### Create a subscription (indirectly)
+
+Creating a subscription is a matter of creating the event itself:
+
+    event = SubscriptionEvent.creation.new(
+      bottles_per_shipment: 1,
+      bottles_purchased: 6,
+      user_id: current_user.id
+    )
+    event.save!
+    subscription = Subscription.last
+    puts "Created subscription #{subscription.id}"
+    
+### What's happening here?
+
+There's a lot going on here.  If you're curious, here's what's happening under the hood:
+
+1. `SubscriptionEvent` saves, provided its event type validations are satisfied.
+1. `SubscriptionObserver` is notified that a `SubscriptionEvent` was saved, so it runs the calculator.
+1. `SubscriptionCalculator` collects all associated events around the `Subscription`, orders them by `created_at`, and runs them in order.
+1. In the case of creation, we don't actually have a `Subscription` at the time we run the calculator for the first time.  So `SubscriptionCalculator` makes use of an auto-generated `subscription_uuid` attribute to tell subscriptions apart even when some of them have yet to be created in the database.
+1. For each event, `SubscriptionCalculator` calls `advance_[event_type]`, which is responsible for updating the attributes on `@subscription` accordingly.
+1. `SubscriptionObserver` takes the record returned by `SubscriptionCalculator` and saves it to the database.
+
+This is a lot of indirection, which you don't have to understand right away.  When you hit more complex situations later, you'll find this indirection will come in handy.
+
+## Change the settings for a subscription
+
+Occasionally, subscribers will want to change their settings.  Let's say in this case we'll only allow them to change `bottles_per_shipment`.  So we add a new event type in `SubscriptionEvent`:
+
+    class SubscriptionEvent < ActiveRecord::Base
+      event_type :change_settings do
+        attributes :bottles_per_shipment
+
+        validates :bottles_per_shipment, numericality: true
+      end
+    end
+    
+And we add a method to handle this new event type in the calculator:
+
+    class SubscriptionCalculator < EventSourcedRecord::Calculator
+      def advance_change_settings(event)
+        @subscription.bottles_per_shipment = event.bottles_per_shipment
+      end
+    end
+
+If we want to change the subscription from the last example from 1 bottle per shipment to 2 bottles per shipment, this looks like this:
+
+    subscription.bottles_per_shipment # 1
+    SubscriptionEvent.change_settings.create!(
+      subscription_uuid: subscription.uuid, bottles_per_shipment: 2
+    )
+    subscription.reload
+    subscription.bottles_per_shipment # 2
+    
+## Shipment
+
+We created `SubscriptionEvent` to store events about `Subscription`, but you may find you have other kinds of classes that are like events in that they are time-based and relatively immutable.  Let's say that shipments of shampoo function this way in our system: As soon as they are inserted in the database they are applied against the associated subscription.
+
+So let's create a `Shipment` class, using the standard Rails generator:
+
+    rails generate model Shipment subscription_id:integer num_bottles:integer
+    
+And let's say that everytime a `Shipment` goes out the door, we deduct `Shipment#num_bottles` from `bottles_left` on the associated `Subscription`.  To do that we'll need to change the calculator, and the observer.
+
+In `subscription_calculator.rb` we make two changes.  First, we add `:shipments` to `events`, which tells the calculator to include `Shipment` as an event that needs to be considered.  Then we add an `advance_shipment` method to handle each associated `Shipment`.
+
+    class SubscriptionCalculator < EventSourcedRecord::Calculator
+      events :subscription_events, :shipments
+
+      def advance_shipment(shipment)
+        @subscription.bottles_left -= shipment.num_bottles
+      end
+    end
+    
+In `subscription_event_observer.rb`, we add `:shipment` to `observer`, so the observer will know to fire when we create a shipment.
+
+    class SubscriptionEventObserver < ActiveRecord::Observer
+      observe :subscription_event, :shipment
+
+      def after_create(event)
+        SubscriptionCalculator.new(event).run.save!
+      end
+    end
+    
+Note that `SubscriptionEventObserver#after_create` didn't change.  When a `Shipment` is created, `after_create` will treat that `Shipment` like another type of event.
+
+## About calculators
+    
+To get the most benefit out of the calculator, you should make its work idempotent: That is, you should be to run it twice and have no side effects.  And don't forget that every time you call `SubscriptionCalculator#run`, it runs through all events in order, even events that have been considered before.  So things like sending emails, charging a credit card for a recurring order, or firing off analytic events should not happen anywhere inside `SubscriptionCalculator`.
+
+The best way to think of it is that `Subscription` is a cache, and `SubscriptionCalculator` contains the logic that fills that cache.  Just as you wouldn't want to send an email every time you saved data in Redis, you wouldn't want to send an email every time you called `SubscriptionCalculator#run`.
+
+For this reason, you'll find that event sourcing fits nicely with architectural styles that move these sorts of side effects out of the model, such as [service classes](https://blog.engineyard.com/2014/keeping-your-rails-controllers-dry-with-services) or [Data Context Interaction](http://dci-in-ruby.info/).
+
+## Extending Subscription in production
+
+Over time, your application will change, and `Subscription` will change accordingly.  It will handle new concepts which you will need to add to both pre-existing and future subscriptions.
+
+Because `Subscription` is just a cache, event sourcing gives us a consistent way to handle both pre-existing and future records:
+
+1. Write a migration if needed to add or change fields on the `subscriptions` table.
+1. Modify `SubscriptionCalculator` to take the new fields into account.
+1. Test, merge, and deploy to production.
+1. Rebuild every `Subscription`, with code such as:
+
+
+    Subscription.all.each do |subscription|
+      SubscriptionCalculator.new(subscription).run.save!
+    end
+    
+Because you have designed `SubscriptionCalculator` to be idempotent, it is safe to re-run at any time you want -- for example, if you want to fill in a database column that didn't exist before.
+
+## Debugging Subscription in production
+
+The same process can work for fixing many bugs in production. Events themselves are usually a simple act of recording the user's intention.  Errors usually emerge in `SubscriptionCalculator`, which is responsible for the tougher work of interpreting a sequence of events.
+
+So when you find a bug, you can often fix it via this process:
+
+1. Write a test to reproduce the bug.
+1. Fix `SubscriptionCalculator` to fix the bug.
+1. Merge and deploy to production.
+1. Rebuild every `Subscription` with the code above.
+
+Remember, `SubscriptionCalculator` is idempotent, so this process will fix all the records affected by the bug will leaving the others unchanged.  It will also spare you the agonizing effort of picking through data in `rails console` to guess which records are broken. Why go to the trouble?  Just re-run the whole thing and move on.
+
+## Reporting
+
+Because `SubscriptionCalculator` rebuilds a record in sequence, it's a piece of cake to only partially rebuild up to a certain time, which can save a lot of time in generating retrospective reports:
+
+    calculator = SubscriptionCalculator.new(subscription)
+    sub_at_end_of_year = calculator.run(last_event_time: Date.new(2014,12,31))
+    
+Note that the returned instance is un-saved, and shouldn't be saved to `subscriptions`, but it's now a piece of cake to take those values and send them to whatever reporting system you have in place.

data/README.md

@@ -6,6 +6,10 @@ With Event Sourcing, every change to the state of an object is recorded as an im
 
 For more, see Martin Fowler's writeup of the pattern: http://martinfowler.com/eaaDev/EventSourcing.html
 
+## Requirements
+
+Event Sourced Record supports Rails 3.2 and higher.
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -24,10 +28,10 @@ Event Sourced Record uses observers, so you'll need to add them to your Gemfile:
 
     gem 'rails-observers'
     
-Note that only Rails 4 is supported as of this writing.  Rails 3 support is coming soon.
-
 ## Usage
 
+See `Getting_Started.md` for a detailed example.
+
 Generate the required classes with `rails generate event_sourced_record`:
 
     rails generate event_sourced_record Subscription \

data/lib/event_sourced_record/event.rb

@@ -23,6 +23,16 @@ module EventSourcedRecord::Event
     end
   end
 
+  def respond_to?(meth, include_all = false)
+    if event_type_config && event_type_config.attributes.include?(meth)
+      true
+    elsif event_type_config && event_type_config.attributes.any? { |a| "#{a}=" == meth }
+      true
+    else
+      super
+    end
+  end
+
   private
 
   def ensure_data

data/lib/event_sourced_record/version.rb

@@ -1,3 +1,3 @@
 module EventSourcedRecord
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/lib/generators/event_sourced_record/event_generator.rb

@@ -1,18 +1,27 @@
-class EventSourcedRecord::EventGenerator < Rails::Generators::NamedBase
+require 'generators/event_sourced_record'
+
+class EventSourcedRecord::EventGenerator < ActiveRecord::Generators::Base
   source_root File.expand_path('../templates', __FILE__)
   argument :attributes, 
     :type => :array, :default => []
 
   def create_migration_file
-    attributes_str = attributes.map { |attr|
-      attr_banner = attr.name
-      attr_banner << ":#{attr.type}" if attr.type
-      attr_banner << ':index' if attr.has_index?
-      attr_banner
-    }.join(' ')
-    generate(
-      "migration", "create_#{event_table_name} #{attributes_str}"
-    )
+    ar_major_version = ActiveRecord::VERSION::MAJOR
+    if ar_major_version >= 4
+      attributes_str = attributes.map { |attr|
+        attr_banner = attr.name
+        attr_banner << ":#{attr.type}" if attr.type
+        attr_banner << ':index' if attr.has_index?
+        attr_banner
+      }.join(' ')
+      generate(
+        "migration", "create_#{event_table_name} #{attributes_str}"
+      )
+    else
+      migration_template(
+        "event_migration.ar3.rb", "db/migrate/create_#{event_table_name}.rb"
+      )
+    end
   end
 
   def create_model_file
@@ -22,10 +31,18 @@ class EventSourcedRecord::EventGenerator < Rails::Generators::NamedBase
     )
   end
 
+  def attributes_with_index
+    attributes.select { |a| a.has_index? || (a.reference? && options[:indexes]) }
+  end
+
   hook_for :test_framework, as: :model
 
   private
 
+  def event_migration_class_name
+    "create_#{event_table_name}".camelize
+  end
+
   def event_class_name
     class_name
   end

data/lib/generators/event_sourced_record/projection_generator.rb

@@ -1,21 +1,36 @@
-class EventSourcedRecord::ProjectionGenerator < Rails::Generators::NamedBase
+require 'generators/event_sourced_record'
+
+class EventSourcedRecord::ProjectionGenerator < ActiveRecord::Generators::Base
   source_root File.expand_path('../templates', __FILE__)
   argument :attributes, 
     :type => :array, :default => []
 
   def create_migration_file
-    generate(
-      "migration", "create_#{projection_table_name} #{migration_attributes}"
-    )
+    ar_major_version = ActiveRecord::VERSION::MAJOR
+    if ar_major_version >= 4
+      generate(
+        "migration", "create_#{projection_table_name} #{migration_attributes}"
+      )
+    else
+      migration_template(
+        "projection_migration.ar3.rb", 
+        "db/migrate/create_#{projection_table_name}.rb"
+      )
+    end
   end
 
   def create_model_file
+    ar_major_version = ActiveRecord::VERSION::MAJOR
     template(
-      'projection_model.rb', 
+      "projection_model.ar#{ar_major_version}.rb", 
       File.join('app/models', class_path, "#{projection_file_name}.rb")
     )
   end
 
+  def attributes_with_index
+    attributes.select { |a| a.has_index? || (a.reference? && options[:indexes]) }
+  end
+
   hook_for :test_framework, as: :model
 
   private
@@ -31,6 +46,9 @@ class EventSourcedRecord::ProjectionGenerator < Rails::Generators::NamedBase
     attr_strings.join(' ')
   end
 
+  def projection_migration_class_name
+    "create_#{projection_table_name}".camelize
+  end
 
   def projection_class_name
     class_name

data/lib/generators/event_sourced_record/templates/event_migration.ar3.rb

@@ -0,0 +1,16 @@
+class <%= event_migration_class_name %> < ActiveRecord::Migration
+  def change
+    create_table :<%= event_table_name %> do |t|
+<% attributes.each do |attribute| -%>
+      t.<%= attribute.type %> :<%= attribute.name %><%= attribute.inject_options %>
+<% end -%>
+<% if options[:timestamps] %>
+      t.timestamps
+<% end -%>
+    end
+<% attributes_with_index.each do |attribute| -%>
+    add_index :<%= table_name %>, :<%= attribute.index_name %><%= attribute.inject_index_options %>
+<% end -%>
+  end
+end
+

data/lib/generators/event_sourced_record/templates/projection_migration.ar3.rb

@@ -0,0 +1,16 @@
+class <%= projection_migration_class_name %> < ActiveRecord::Migration
+  def change
+    create_table :<%= projection_table_name %> do |t|
+<% attributes.each do |attribute| -%>
+      t.<%= attribute.type %> :<%= attribute.name %><%= attribute.inject_options %>
+<% end -%>
+<% if options[:timestamps] %>
+      t.timestamps
+<% end -%>
+    end
+<% attributes_with_index.each do |attribute| -%>
+    add_index :<%= table_name %>, :<%= attribute.index_name %><%= attribute.inject_index_options %>
+<% end -%>
+  end
+end
+

data/lib/generators/event_sourced_record/templates/projection_model.ar3.rb

@@ -0,0 +1,11 @@
+<% module_namespacing do -%>
+class <%= projection_class_name %> < <%= projection_parent_class_name.classify %>
+<% attributes.select {|attr| attr.reference? }.each do |attribute| -%>
+  belongs_to :<%= attribute.name %>
+<% end -%>
+  has_many :<%= file_name %>_events
+
+  validates :uuid, uniqueness: true
+end
+<% end -%>
+

data/lib/generators/event_sourced_record.rb

@@ -0,0 +1,6 @@
+require 'rails/generators/active_record'
+require 'generators/event_sourced_record/event_sourced_record_generator'
+require 'generators/event_sourced_record/calculator_generator'
+require 'generators/event_sourced_record/event_generator'
+require 'generators/event_sourced_record/observer_generator'
+require 'generators/event_sourced_record/projection_generator'

data/test/generators/event_generator_test.rb

@@ -20,9 +20,16 @@ class EventSourcedRecord::EventGeneratorTest < Rails::Generators::TestCase
   end
 
   test "creates a migration for the event class" do
-    assert @generate_calls['migration'].include?(
-      "create_subscription_events subscription_uuid:string:index event_type:string data:text created_at:datetime"
-    )
+    ar_major_version = ActiveRecord::VERSION::MAJOR
+    if ar_major_version >= 4
+      assert @generate_calls['migration'].include?(
+        "create_subscription_events subscription_uuid:string:index event_type:string data:text created_at:datetime"
+      )
+    else
+      assert_migration("db/migrate/create_subscription_events.rb") do |contents|
+        assert_match(/t.string :event_type/, contents)
+      end
+    end
   end
 
   test "creates a model for the event class" do

data/test/generators/projection_generator_test.rb

@@ -19,18 +19,26 @@ class EventSourcedRecord::ProjectionGeneratorTest < Rails::Generators::TestCase
   end
 
   test "creates a migration for the projection class" do
-    assert(
-      @generate_calls['migration'].include?(
-        "create_subscriptions user_id:integer bottles_per_shipment:integer bottles_left:integer uuid:string:uniq"
-      ),
-      @generate_calls.inspect
-    )
+    ar_major_version = ActiveRecord::VERSION::MAJOR
+    if ar_major_version >= 4
+      assert(
+        @generate_calls['migration'].include?(
+          "create_subscriptions user_id:integer bottles_per_shipment:integer bottles_left:integer uuid:string:uniq"
+        ),
+        @generate_calls.inspect
+      )
+    else
+      assert_migration("db/migrate/create_subscriptions.rb") do |contents|
+        assert_match(/t.integer :user_id/, contents)
+      end
+    end
   end
 
   test "creates a model for the projection class" do
     assert_file("app/models/subscription.rb") do |contents|
       assert_match(/class Subscription < ActiveRecord::Base/, contents)
       assert_match(/validates :uuid, uniqueness: true/, contents)
+      assert_no_match(/attr_accessible :bottles_left/, contents)
     end
   end
 end

data/test/test_helper.rb

@@ -3,13 +3,15 @@ require 'rails/test_help'
 require 'rails/generators/test_case'
 require 'pry'
 require 'mocha/test_unit'
+#require 'rails/generators/active_record'
 $: << 'lib'
 require 'event_sourced_record'
-require 'generators/event_sourced_record/event_sourced_record_generator'
-require 'generators/event_sourced_record/calculator_generator'
-require 'generators/event_sourced_record/event_generator'
-require 'generators/event_sourced_record/observer_generator'
-require 'generators/event_sourced_record/projection_generator'
+require 'generators/event_sourced_record'
+#require 'generators/event_sourced_record/event_sourced_record_generator'
+#require 'generators/event_sourced_record/calculator_generator'
+#require 'generators/event_sourced_record/event_generator'
+#require 'generators/event_sourced_record/observer_generator'
+#require 'generators/event_sourced_record/projection_generator'
 require 'active_record'
 
 ActiveRecord::Base.establish_connection(

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: event_sourced_record
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Francis Hwang
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-13 00:00:00.000000000 Z
+date: 2015-01-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -146,6 +146,7 @@ files:
 - ".gitignore"
 - Appraisals
 - Gemfile
+- Getting_Started.md
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -155,6 +156,7 @@ files:
 - lib/event_sourced_record/event.rb
 - lib/event_sourced_record/event/event_type_config.rb
 - lib/event_sourced_record/version.rb
+- lib/generators/event_sourced_record.rb
 - lib/generators/event_sourced_record/USAGE
 - lib/generators/event_sourced_record/calculator_generator.rb
 - lib/generators/event_sourced_record/event_generator.rb
@@ -162,9 +164,12 @@ files:
 - lib/generators/event_sourced_record/observer_generator.rb
 - lib/generators/event_sourced_record/projection_generator.rb
 - lib/generators/event_sourced_record/templates/calculator.rb
+- lib/generators/event_sourced_record/templates/event_migration.ar3.rb
 - lib/generators/event_sourced_record/templates/event_model.rb
 - lib/generators/event_sourced_record/templates/observer.rb
-- lib/generators/event_sourced_record/templates/projection_model.rb
+- lib/generators/event_sourced_record/templates/projection_migration.ar3.rb
+- lib/generators/event_sourced_record/templates/projection_model.ar3.rb
+- lib/generators/event_sourced_record/templates/projection_model.ar4.rb
 - lib/generators/rspec/service_generator.rb
 - lib/generators/rspec/templates/service_spec.rb
 - lib/generators/test_unit/service_generator.rb