event_sourced_accounting 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1a83ae6907d7a2585115b51cbd1aaea238f15a3e
-  data.tar.gz: a3cfe1ed43083547c9416b652e99ffbc14de6ff3
+  metadata.gz: e28546ed4b08b5d9b469930f571e4569117beb0d
+  data.tar.gz: eb9c05d4dae1d65d80b7bcc5fae05f7562219232
 SHA512:
-  metadata.gz: 46bf5e9fe3c43bbf55125adef82617d589654abcfadb139fa85fc3f700f78756f1f2af5f1cb7d92cc15608e65e1b35444e6301615cfbd88d1f289b53f47213bd
-  data.tar.gz: 2ff9df539e8295630998372e49e468b90f9642f15d4fe12d95d767d4295da853b9eaa1149387054f3cd70063706672fdffd21ac8189cba0167766b65fadb6981
+  metadata.gz: ae325b397c7c0c356b5d98da5880de818a348a7565c485b4f671a1d7560bf8538b0c712eab2e0b70e27773d782965c8e559c3ab14ae9814aec721cdf1263717e
+  data.tar.gz: debb565a7e5e6d23c81904cbf5d789ff2a874e87f0a206920262fbab7b60bce600989824cbfc194396d6f69f44400b4628f6127042fa9a98b3bf2aff1c90c5e4

data/README.markdown

@@ -1,7 +1,8 @@
 [![Gem Version](https://badge.fury.io/rb/event_sourced_accounting.svg)](http://badge.fury.io/rb/event_sourced_accounting)
 [![Dependency Status](https://gemnasium.com/lnagel/event-sourced-accounting.svg)](https://gemnasium.com/lnagel/event-sourced-accounting)
 [![Build Status](https://api.travis-ci.org/lnagel/event-sourced-accounting.svg)](https://travis-ci.org/lnagel/event-sourced-accounting)
-[![Code Climate](https://codeclimate.com/github/lnagel/event-sourced-accounting.png)](https://codeclimate.com/github/lnagel/event-sourced-accounting)
+[![Code Climate](https://img.shields.io/codeclimate/github/lnagel/event-sourced-accounting.svg)](https://codeclimate.com/github/lnagel/event-sourced-accounting)
+[![Code Climate](https://img.shields.io/codeclimate/coverage/github/lnagel/event-sourced-accounting.svg)](https://codeclimate.com/github/lnagel/event-sourced-accounting)
 
 Event-Sourced Accounting
 =================
@@ -21,9 +22,9 @@ The documentation and test coverage is expected to be completed within April-May
 Installation
 ============
 
-- Add `gem "event-sourced-accounting"` to your Gemfile
+- Add `gem "event_sourced_accounting"` to your Gemfile
 
-- generate migration files with `rails g esa`
+- generate migration files with `rails g event_sourced_accounting`
 
 - run migrations `rake db:migrate`
 

data/app/models/esa/contexts/date_context.rb

@@ -59,7 +59,7 @@ module ESA
         @filters = []
 
         if self.start_date.present? and self.end_date.present?
-          @filters << lambda { |relation| relation.between_dates(self.start_date, self.end_date) }
+          @filters << lambda { |relation| relation.with_date_range(self.start_date..self.end_date) }
         elsif self.start_date.present?
           @filters << lambda { |relation| relation.with_date_gte(self.start_date) }
         elsif self.end_date.present?

data/app/models/esa/flag.rb

@@ -50,6 +50,22 @@ module ESA
       self.transition == -1
     end
 
+    def matches_spec?(spec)
+      self.nature == spec[:nature].to_s and
+      self.state == spec[:state]
+    end
+
+    def transactions_match_specs?(specs)
+      if self.transactions.count == specs.count
+        self.transactions.map do |tx|
+          tx_spec = specs.find{|a| a[:description] == tx.description} || {}
+          tx.matches_spec?(tx_spec)
+        end.all?
+      else
+        false
+      end
+    end
+
     private
 
     def validate_transition

data/app/models/esa/ruleset.rb

@@ -76,15 +76,11 @@ module ESA
         accountable.esa_flags.transitioning.most_recent(nature)
       end.compact
 
-      most_recent_flags.select(&:is_set?).reject do |flag|
-        attributes = flag_transactions_as_attributes(flag)
-
-        flag.transactions.map do |tx|
-          tx_attrs = attributes.find{|a| a[:description] == tx.description}
-          tx_attrs_amounts = (tx_attrs[:credits] + tx_attrs[:debits]).map{|a| [a[:account], a[:amount]]}
-          tx_amounts = tx.amounts.map{|a| [a.account, a.amount]}
-          (tx_attrs_amounts - tx_amounts).empty?
-        end.all?
+      set_flags = most_recent_flags.select(&:is_set?)
+
+      set_flags.reject do |flag|
+        specs = flag_transactions_as_attributes(flag)
+        flag.transactions_match_specs?(specs)
       end
     end
 
@@ -96,65 +92,61 @@ module ESA
 
     def flag_transactions_when_unset(flag)
       self.flag_transactions_when_set(flag).each do |tx|
-        description = tx[:description] + " / reversed"
-        debits = tx[:credits] # swap
-        credits = tx[:debits] # swap
-        tx[:description] = description
-        tx[:debits] = debits
-        tx[:credits] = credits
+        tx[:description] = "#{tx[:description]} / reversed"
+        tx[:debits], tx[:credits] = tx[:credits], tx[:debits] # swap
       end
     end
 
     def flag_transactions_when_adjusted(flag)
       flag.transactions.map do |tx|
         if tx.valid?
+          spec = tx.spec
           [
-            {
-              :time => flag.time,
-              :description => tx.description,
-              :credits => tx.amounts.credits.map{|a| {:account => a.account, :amount => a.amount}},
-              :debits => tx.amounts.debits.map{|a| {:account => a.account, :amount => a.amount}},
-            },
-            {
+            # original transaction, which must be kept
+            spec,
+            # adjustment transaction, which must be added
+            spec.merge({
               :time => flag.adjustment_time,
-              :description => tx.description + " / adjusted",
-              :debits => tx.amounts.credits.map{|a| {:account => a.account, :amount => a.amount}}, # swap
-              :credits => tx.amounts.debits.map{|a| {:account => a.account, :amount => a.amount}}, # swap
-            }
+              :description => "#{tx.description} / adjusted",
+              :debits => spec[:credits], # swap
+              :credits => spec[:debits], # swap
+            })
           ]
         end
       end.compact.flatten
     end
 
-    def flag_transactions_as_attributes(flag)
+    def flag_transactions(flag)
       if flag.adjusted?
-        transactions = self.flag_transactions_when_adjusted(flag)
-      elsif flag.became_set? or (flag.is_set? and flag.event.present? and flag.event.nature.adjustment?)
-        transactions = self.flag_transactions_when_set(flag)
+        flag_transactions_when_adjusted(flag)
+      elsif flag.is_set? and (flag.became_set? or (flag.event.present? and flag.event.nature.adjustment?))
+        flag_transactions_when_set(flag)
       elsif flag.became_unset?
-        transactions = self.flag_transactions_when_unset(flag)
+        flag_transactions_when_unset(flag)
       else
-        transactions = []
+        []
       end
+    end
 
-      transactions.map do |tx|
+    def flag_transactions_as_attributes(flag)
+      flag_transactions(flag).map do |tx|
         tx[:time] ||= flag.time
         tx[:accountable] ||= flag.accountable
         tx[:flag] ||= flag
 
         amounts = (tx[:debits] + tx[:credits]).map{|a| a[:amount]}
-
         if amounts.map{|a| a <= BigDecimal(0)}.all?
-          debits = tx[:credits].map{|a| a[:amount] = BigDecimal(0) - a[:amount]; a } # swap
-          credits = tx[:debits].map{|a| a[:amount] = BigDecimal(0) - a[:amount]; a } # swap
-          tx[:debits] = debits
-          tx[:credits] = credits
+          tx[:debits], tx[:credits] = inverted(tx[:credits]), inverted(tx[:debits]) # invert & swap
         end
 
         tx
       end
     end
 
+    def inverted(amounts)
+      amounts.map{|a| a.dup.merge({amount: BigDecimal(0) - a[:amount]}) }
+    end
+
     def find_account(type, name)
       if self.chart.present? and Account.valid_type?(type)
         self.chart.accounts.

data/app/models/esa/transaction.rb

@@ -43,6 +43,32 @@ module ESA
       end
     end
 
+    def spec
+      {
+        :time => self.time,
+        :description => self.description,
+        :credits => self.amounts.credits.map{|a| {:account => a.account, :amount => a.amount}},
+        :debits => self.amounts.debits.map{|a| {:account => a.account, :amount => a.amount}},
+      }
+    end
+
+    def matches_spec?(spec)
+      self.description == spec[:description] and self.amounts_match_spec?(spec)
+    end
+
+    def amounts_match_spec?(spec)
+      to_check = [
+            [self.amounts.credits.all, spec[:credits]],
+            [self.amounts.debits.all, spec[:debits]]
+          ]
+
+      to_check.map do |amounts,amount_spec|
+        a = amounts.map{|a| [a.account, a.amount]}
+        s = amount_spec.map{|a| [a[:account], a[:amount]]}
+        (a - s).empty? and (s - a).empty?
+      end.all?
+    end
+
     private
 
     def default_values

data/lib/esa/blocking_processor.rb

@@ -10,11 +10,7 @@ module ESA
       events_created = create_events(accountable)
 
       if events_created
-        unprocessed_events = accountable.esa_events.
-            where(processed: false).
-            order('time ASC, created_at ASC')
-
-        unprocessed_events.each do |event|
+        unprocessed_events(accountable).each do |event|
           event.processed = process_event(event)
           event.save if event.changed?
 
@@ -26,6 +22,12 @@ module ESA
       end
     end
 
+    def self.unprocessed_events(accountable)
+      accountable.esa_events.
+          where(processed: false).
+          order(:time, :created_at, :id)
+    end
+
     def self.create_events(accountable)
       produce_events(accountable).map(&:save).all?
     end
@@ -46,20 +48,9 @@ module ESA
       flags_created = create_flags(event)
 
       if flags_created
-        unprocessed_flags = []
-
-        if event.nature.adjustment?
-          unprocessed_flags += event.accountable.esa_flags.
-              where(adjusted: true, processed: false).
-              order('time ASC, created_at ASC')
-        end
-
-        unprocessed_flags += event.flags.
-            where(processed: false).
-            order('time ASC, created_at ASC')
-
-        unprocessed_flags.map do |flag|
+        unprocessed_flags(event).map do |flag|
           flag.processed = process_flag(flag)
+
           if flag.changed?
             flag.save and flag.processed
           else
@@ -71,6 +62,22 @@ module ESA
       end
     end
 
+    def self.unprocessed_flags(event)
+      flags = []
+
+      if event.nature.adjustment?
+        flags += event.accountable.esa_flags.
+            where(adjusted: true, processed: false).
+            order(:time, :created_at, :id)
+      end
+
+      flags += event.flags.
+          where(processed: false).
+          order(:time, :created_at, :id)
+
+      flags
+    end
+
     def self.create_flags(event)
       if not event.processed and not event.processed_was
         produce_flags(event).map(&:save).all?
@@ -80,42 +87,55 @@ module ESA
     end
 
     def self.produce_flags(event)
-      flags = event.flags.all
+      if event.nature.adjustment?
+        produce_flags_for_adjustment(event)
+      else
+        produce_flags_for_regular(event)
+      end
+    end
+
+    def self.produce_flags_for_adjustment(event)
       if event.ruleset.present?
-        if event.nature.adjustment?
-          adjusted_flags = event.ruleset.flags_needing_adjustment(event.accountable)
-          adjusted_flags.map do |flag|
-            flag.processed = false
-            flag.adjusted = true
-            flag.adjustment_time = event.time
-
-            attrs = {
-              :accountable => event.accountable,
-              :nature => flag.nature,
-              :state => flag.state,
-              :event => event,
-            }
-
-            adjustment = event.accountable.esa_flags.new(attrs)
-            event.flags << adjustment
-
-            [flag, adjustment]
-          end.flatten
-        else
-          required_flags = event.ruleset.event_flags_as_attributes(event)
-          required_flags.map do |attrs|
-            existing = flags.find{|f| f.nature == attrs[:nature].to_s and f.state == attrs[:state]}
-            if existing.present?
-              existing
-            else
-              flag = event.accountable.esa_flags.new(attrs)
-              event.flags << flag
-              flag
-            end
+        adjusted_flags = event.ruleset.flags_needing_adjustment(event.accountable)
+        adjusted_flags.map do |flag|
+          flag.processed = false
+          flag.adjusted = true
+          flag.adjustment_time = event.time
+
+          attrs = {
+            :accountable => event.accountable,
+            :nature => flag.nature,
+            :state => flag.state,
+            :event => event,
+          }
+
+          adjustment = event.accountable.esa_flags.new(attrs)
+          event.flags << adjustment
+
+          [flag, adjustment]
+        end.flatten
+      else
+        []
+      end
+    end
+
+    def self.produce_flags_for_regular(event)
+      if event.ruleset.present?
+        existing_flags = event.flags.all
+        required_flags = event.ruleset.event_flags_as_attributes(event)
+
+        required_flags.map do |attrs|
+          flag = existing_flags.find{|flag| flag.matches_spec?(attrs)}
+
+          if flag.nil?
+            flag = event.accountable.esa_flags.new(attrs)
+            event.flags << flag
           end
+
+          flag
         end
       else
-        flags
+        []
       end
     end
 
@@ -137,21 +157,22 @@ module ESA
     end
 
     def self.produce_transactions(flag)
-      transactions = flag.transactions.all
       if flag.ruleset.present? and flag.transition.present? and flag.transition.in? [-1, 0, 1]
+        existing_transactions = flag.transactions.all
         required_transactions = flag.ruleset.flag_transactions_as_attributes(flag)
+
         required_transactions.map do |attrs|
-          existing = transactions.find{|f| f.description == attrs[:description]}
-          if existing.present?
-            existing
-          else
+          transaction = existing_transactions.find{|tx| tx.matches_spec?(attrs)}
+
+          if transaction.nil?
             transaction = flag.accountable.esa_transactions.new(attrs)
             flag.transactions << transaction
-            transaction
           end
+
+          transaction
         end
       else
-        transactions
+        []
       end
     end
   end

data/lib/esa/filters/date_time_filter.rb

@@ -1,52 +1,48 @@
 module ESA
   module Filters
     module DateTimeFilter
-      module TransactionDate
+      module DateScopes
         extend ActiveSupport::Concern
 
         included do
-          scope :between_dates, lambda { |date1,date2| joins(:transaction).where(esa_transactions: {time: date1.midnight..date2.end_of_day}) }
-          scope :with_date,     lambda { |date| joins(:transaction).where(esa_transactions: {time: date.midnight..date.end_of_day}) }
-
-          scope :with_date_lt,  lambda { |date| with_time_lt(date.midnight) }
-          scope :with_date_gt,  lambda { |date| with_time_gt(date.end_of_day) }
-          scope :with_date_lte, lambda { |date| with_time_lte(date.end_of_day) }
-          scope :with_date_gte, lambda { |date| with_time_gte(date.midnight) }
-
-          scope :with_time_lt,  lambda { |time| joins(:transaction).where(ESA::Transaction.arel_table[:time].lt( time)) }
-          scope :with_time_gt,  lambda { |time| joins(:transaction).where(ESA::Transaction.arel_table[:time].gt( time)) }
-          scope :with_time_lte, lambda { |time| joins(:transaction).where(ESA::Transaction.arel_table[:time].lteq(time)) }
-          scope :with_time_gte, lambda { |time| joins(:transaction).where(ESA::Transaction.arel_table[:time].gteq(time)) }
-
-          scope :created_before, lambda { |time| joins(:transaction).where(ESA::Transaction.arel_table[:created_at].lt(time)) }
+          scope :with_date_range, lambda { |range| with_time_range(range.begin.midnight..range.end.end_of_day) }
+          scope :with_date_lt,    lambda { |date| with_time_lt(date.midnight) }
+          scope :with_date_gt,    lambda { |date| with_time_gt(date.end_of_day) }
+          scope :with_date_lte,   lambda { |date| with_time_lte(date.end_of_day) }
+          scope :with_date_gte,   lambda { |date| with_time_gte(date.midnight) }
         end
       end
 
-      module ObjectDate
+      module TransactionTime
         extend ActiveSupport::Concern
+        include DateScopes
 
         included do
-          scope :between_dates, lambda { |date1,date2| where(time: date1.midnight..date2.end_of_day) }
-          scope :with_date,     lambda { |date| where(time: date.midnight..date.end_of_day) }
-
-          scope :with_date_lt,  lambda { |date| with_time_lt(date.midnight) }
-          scope :with_date_gt,  lambda { |date| with_time_gt(date.end_of_day) }
-          scope :with_date_lte, lambda { |date| with_time_lte(date.end_of_day) }
-          scope :with_date_gte, lambda { |date| with_time_gte(date.midnight) }
+          scope :with_time_range, lambda { |range| joins(:transaction).where(esa_transactions: {time: range}) }
+          scope :with_time_lt,    lambda { |time|  joins(:transaction).where(ESA::Transaction.arel_table[:time].lt(time)) }
+          scope :with_time_gt,    lambda { |time|  joins(:transaction).where(ESA::Transaction.arel_table[:time].gt(time)) }
+          scope :with_time_lte,   lambda { |time|  joins(:transaction).where(ESA::Transaction.arel_table[:time].lteq(time)) }
+          scope :with_time_gte,   lambda { |time|  joins(:transaction).where(ESA::Transaction.arel_table[:time].gteq(time)) }
+        end
+      end
 
-          scope :with_time_lt,  lambda { |time| where(arel_table[:time].lt( time)) }
-          scope :with_time_gt,  lambda { |time| where(arel_table[:time].gt( time)) }
-          scope :with_time_lte, lambda { |time| where(arel_table[:time].lteq(time)) }
-          scope :with_time_gte, lambda { |time| where(arel_table[:time].gteq(time)) }
+      module ObjectTime
+        extend ActiveSupport::Concern
+        include DateScopes
 
-          scope :created_before, lambda { |time| where(arel_table[:created_at].lt(time)) }
+        included do
+          scope :with_time_range, lambda { |range| where(time: range) }
+          scope :with_time_lt,    lambda { |time|  where(arel_table[:time].lt(time)) }
+          scope :with_time_gt,    lambda { |time|  where(arel_table[:time].gt(time)) }
+          scope :with_time_lte,   lambda { |time|  where(arel_table[:time].lteq(time)) }
+          scope :with_time_gte,   lambda { |time|  where(arel_table[:time].gteq(time)) }
         end
       end
     end
   end
 end
 
-ESA::Amount.send :include, ESA::Filters::DateTimeFilter::TransactionDate
-ESA::Event.send :include, ESA::Filters::DateTimeFilter::ObjectDate
-ESA::Flag.send :include, ESA::Filters::DateTimeFilter::ObjectDate
-ESA::Transaction.send :include, ESA::Filters::DateTimeFilter::ObjectDate
+ESA::Amount.send :include, ESA::Filters::DateTimeFilter::TransactionTime
+ESA::Event.send :include, ESA::Filters::DateTimeFilter::ObjectTime
+ESA::Flag.send :include, ESA::Filters::DateTimeFilter::ObjectTime
+ESA::Transaction.send :include, ESA::Filters::DateTimeFilter::ObjectTime

data/lib/esa/filters/timestamp_filter.rb

@@ -0,0 +1,16 @@
+module ESA
+  module Filters
+    module TimestampFilter
+      extend ActiveSupport::Concern
+
+      included do
+        scope :created_before, lambda { |time| where(arel_table[:created_at].lt(time)) }
+      end
+    end
+  end
+end
+
+ESA::Amount.send :include, ESA::Filters::TimestampFilter
+ESA::Event.send :include, ESA::Filters::TimestampFilter
+ESA::Flag.send :include, ESA::Filters::TimestampFilter
+ESA::Transaction.send :include, ESA::Filters::TimestampFilter

data/lib/esa/version.rb

@@ -1,3 +1,3 @@
 module ESA
-  VERSION = "0.1.1"
+  VERSION = "0.1.3"
 end

data/lib/esa.rb

@@ -50,6 +50,7 @@ require 'esa/filters/accountable_type_filter'
 require 'esa/filters/chart_filter'
 require 'esa/filters/context_filter'
 require 'esa/filters/date_time_filter'
+require 'esa/filters/timestamp_filter'
 
 require 'esa/config'
 

data/lib/generators/{esa/esa_generator.rb → event_sourced_accounting/event_sourced_accounting_generator.rb}

@@ -2,7 +2,7 @@
 require 'rails/generators'
 require 'rails/generators/migration'
 
-class ESAGenerator < Rails::Generators::Base
+class EventSourcedAccountingGenerator < Rails::Generators::Base
  include Rails::Generators::Migration
 
  def self.source_root

data/lib/generators/{esa → event_sourced_accounting}/templates/migration.rb

@@ -5,7 +5,7 @@ class CreateEsaTables < ActiveRecord::Migration
 
       t.timestamps
     end
-    add_index :esa_charts, [:name]
+    add_index :esa_charts, :name, :unique => true
 
     create_table :esa_accounts do |t|
       t.string     :code
@@ -17,7 +17,8 @@ class CreateEsaTables < ActiveRecord::Migration
 
       t.timestamps
     end
-    add_index :esa_accounts, [:name, :type, :chart_id]
+    add_index :esa_accounts, [:chart_id, :name], :unique => true
+    add_index :esa_accounts, [:chart_id, :name, :type]
     add_index :esa_accounts, :normal_balance
 
     create_table :esa_events, :force => true do |t|
@@ -127,9 +128,33 @@ class CreateEsaTables < ActiveRecord::Migration
     add_index :esa_contexts, :start_date
     add_index :esa_contexts, :end_date
     add_index :esa_contexts, :freshness
+
+    add_foreign_key :esa_accounts, :esa_charts, column: 'chart_id'
+    add_foreign_key :esa_events, :esa_rulesets, column: 'ruleset_id'
+    add_foreign_key :esa_flags, :esa_events, column: 'event_id'
+    add_foreign_key :esa_flags, :esa_rulesets, column: 'ruleset_id'
+    add_foreign_key :esa_transactions, :esa_flags, column: 'flag_id'
+    add_foreign_key :esa_rulesets, :esa_charts, column: 'chart_id'
+    add_foreign_key :esa_amounts, :esa_accounts, column: 'account_id'
+    add_foreign_key :esa_amounts, :esa_transactions, column: 'transaction_id'
+    add_foreign_key :esa_contexts, :esa_charts, column: 'chart_id'
+    add_foreign_key :esa_contexts, :esa_contexts, column: 'parent_id'
+    add_foreign_key :esa_contexts, :esa_accounts, column: 'account_id'
   end
 
   def self.down
+    remove_foreign_key :esa_accounts, name: "esa_accounts_chart_id_fk"
+    remove_foreign_key :esa_amounts, name: "esa_amounts_account_id_fk"
+    remove_foreign_key :esa_amounts, name: "esa_amounts_transaction_id_fk"
+    remove_foreign_key :esa_contexts, name: "esa_contexts_account_id_fk"
+    remove_foreign_key :esa_contexts, name: "esa_contexts_chart_id_fk"
+    remove_foreign_key :esa_contexts, name: "esa_contexts_parent_id_fk"
+    remove_foreign_key :esa_events, name: "esa_events_ruleset_id_fk"
+    remove_foreign_key :esa_flags, name: "esa_flags_event_id_fk"
+    remove_foreign_key :esa_flags, name: "esa_flags_ruleset_id_fk"
+    remove_foreign_key :esa_rulesets, name: "esa_rulesets_chart_id_fk"
+    remove_foreign_key :esa_transactions, name: "esa_transactions_flag_id_fk"
+
     drop_table :esa_charts
     drop_table :esa_accounts
     drop_table :esa_events

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: event_sourced_accounting
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Lenno Nagel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-07 00:00:00.000000000 Z
+date: 2014-04-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -52,6 +52,20 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: 0.0.4
+- !ruby/object:Gem::Dependency
+  name: foreigner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -226,13 +240,14 @@ files:
 - lib/esa/blocking_processor.rb
 - lib/esa/filters/chart_filter.rb
 - lib/esa/filters/accountable_type_filter.rb
+- lib/esa/filters/timestamp_filter.rb
 - lib/esa/filters/context_filter.rb
 - lib/esa/filters/date_time_filter.rb
 - lib/esa/filters/accountable_filter.rb
 - lib/esa/filters/account_filter.rb
-- lib/generators/esa/esa_generator.rb
-- lib/generators/esa/templates/migration.rb
-- lib/generators/esa/USAGE
+- lib/generators/event_sourced_accounting/event_sourced_accounting_generator.rb
+- lib/generators/event_sourced_accounting/templates/migration.rb
+- lib/generators/event_sourced_accounting/USAGE
 - lib/esa.rb
 - LICENSE
 - Rakefile