event_sourced_accounting 0.1.6 → 0.2.2

data/lib/esa/blocking_processor.rb

@@ -34,16 +34,28 @@ module ESA
 
     def self.produce_events(accountable)
       ruleset = Ruleset.extension_instance(accountable)
+
       if ruleset.present?
-        last_event_time = accountable.esa_events.maximum(:time)
-        unrecorded_events = ruleset.unrecorded_events_as_attributes(accountable)
-        valid_events = unrecorded_events.select{|e| last_event_time.nil? or e[:time] >= last_event_time}
-        accountable.esa_events.new(valid_events)
+        events = ruleset.addable_unrecorded_events_as_attributes(accountable)
+        accountable.esa_events.new(events)
       else
         []
       end
     end
 
+    def self.event_attrs_with_adjustment(ruleset, accountable, events)
+      if ruleset.is_adjustment_event_needed?(accountable)
+        events.unshift({
+          accountable: accountable,
+          ruleset: ruleset,
+          nature: :adjustment,
+          time: [events.map{|e| e[:time]}.min, Time.zone.now].compact.min,
+        })
+      else
+        events
+      end
+    end
+
     def self.process_event(event)
       flags_created = create_flags(event)
 
@@ -102,14 +114,7 @@ module ESA
           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)
+          adjustment = initialize_adjustment_flag(event, flag)
           event.flags << adjustment
 
           [flag, adjustment]
@@ -119,6 +124,17 @@ module ESA
       end
     end
 
+    def self.initialize_adjustment_flag(event, flag)
+      attrs = {
+        :accountable => event.accountable,
+        :nature => flag.nature,
+        :state => flag.state,
+        :event => event,
+      }
+
+      event.accountable.esa_flags.new(attrs)
+    end
+
     def self.produce_flags_for_regular(event)
       if event.ruleset.present?
         existing_flags = event.flags.all
@@ -157,19 +173,18 @@ module ESA
     end
 
     def self.produce_transactions(flag)
-      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|
-          transaction = existing_transactions.find{|tx| tx.matches_spec?(attrs)}
+      txs = flag.accountable.esa_transactions.new(missing_transactions(flag))
+      flag.transactions += txs
+      txs
+    end
 
-          if transaction.nil?
-            transaction = flag.accountable.esa_transactions.new(attrs)
-            flag.transactions << transaction
-          end
+    def self.missing_transactions(flag)
+      if flag.ruleset.present? and flag.transition.present? and flag.transition.in? [-1, 0, 1]
+        existing = flag.transactions.all
+        required = flag.ruleset.flag_transactions_as_attributes(flag)
 
-          transaction
+        required.reject do |attrs|
+          existing.find{|tx| tx.matches_spec?(attrs)}.present?
         end
       else
         []

data/lib/esa/configuration.rb

@@ -16,6 +16,7 @@ module ESA
     attr_accessor :context_freshness_threshold
     attr_accessor :context_providers
     attr_accessor :context_tree
+    attr_accessor :context_walk_ignore
 
     def initialize
       @base_classes = [ESA::Ruleset, ESA::Event, ESA::Flag, ESA::Transaction].freeze
@@ -34,25 +35,37 @@ module ESA
         'account'          => ESA::ContextProviders::AccountContextProvider,
         'accountable'      => ESA::ContextProviders::AccountableContextProvider,
         'accountable_type' => ESA::ContextProviders::AccountableTypeContextProvider,
-        'monthly'          => [ESA::ContextProviders::DateContextProvider, {period: :month}],
-        'daily'            => [ESA::ContextProviders::DateContextProvider, {period: :day}],
+        'month'            => [ESA::ContextProviders::DateContextProvider, {period: :month}],
+        'date'             => [ESA::ContextProviders::DateContextProvider, {period: :date}],
       }
 
       @context_tree = {
         'account' => {
-          'monthly' => {
-            'daily' => {},
+          'month'   => {
+            'date' => {},
           },
         },
-        'monthly' => {
+        'period' => {
           'account' => {
-            'daily' => {},
+            'date' => {},
           },
         },
-        'daily' => {
+        'year' => {
+          'account' => {
+            'date' => {},
+          },
+        },
+        'month'   => {
+          'account' => {
+            'date' => {},
+          },
+        },
+        'date' => {
           'account' => {},
         },
       }
+
+      @context_walk_ignore = ['filter']
     end
 
     def register(accountable, short_name=nil)
@@ -83,7 +96,8 @@ module ESA
     end
 
     def context_providers_for_path(path=[])
-      @context_providers.slice(*self.walk_context_tree(path).keys)
+      clean_path = path - context_walk_ignore
+      @context_providers.slice(*self.walk_context_tree(clean_path).keys)
     end
   end
 end

data/lib/esa/context_provider.rb

@@ -38,7 +38,8 @@ module ESA
 
     def self.contained_subcontexts(context, namespace, existing, options = {})
       contained_ids = contained_ids(context, options)
-      existing_ids = existing.map{|sub| context_id(sub, options)}
+      existing_grouped = existing.group_by{|sub| context_id(sub, options)}
+      existing_ids = existing_grouped.keys
 
       new_ids = contained_ids - existing_ids
 
@@ -46,7 +47,11 @@ module ESA
         instantiate(context, namespace, id, options)
       end
 
-      new_subcontexts + existing.select{|sub| context_id(sub).in? contained_ids}
+      keep_subcontexts = existing_grouped.map do |id,group|
+        (id.in? contained_ids) ? group.first : nil
+      end.compact
+
+      new_subcontexts + keep_subcontexts
     end
   end
 end

data/lib/esa/filters/accountable_filter.rb

@@ -34,7 +34,12 @@ module ESA
           scope :with_accountable, lambda { |accountable,type|
             joins(:transaction).where(esa_transactions: {accountable_id: accountable, accountable_type: type})
           }
+          scope :excl_accountable, lambda { |accountable,type|
+            joins(:transaction).where(ESA::Transaction.arel_table[:accountable_id].not_eq(accountable), ESA::Transaction.arel_table[:accountable_type].not_eq(type))
+          }
+
           scope :with_accountable_def, lambda { |definitions| joins(:transaction).joins("INNER JOIN (#{ESA::Filters::AccountableFilter.make_union_query(definitions)}) `accountables-#{(hash ^ definitions.hash).to_s(36)}` ON `esa_transactions`.`accountable_id` = `accountables-#{(hash ^ definitions.hash).to_s(36)}`.`id` AND `esa_transactions`.`accountable_type` = `accountables-#{(hash ^ definitions.hash).to_s(36)}`.`type`") }
+          scope :excl_accountable_def, lambda { |definitions| joins(:transaction).joins("LEFT OUTER JOIN (#{ESA::Filters::AccountableFilter.make_union_query(definitions)}) `accountables-#{(hash ^ definitions.hash).to_s(36)}` ON `esa_transactions`.`accountable_id` = `accountables-#{(hash ^ definitions.hash).to_s(36)}`.`id` AND `esa_transactions`.`accountable_type` = `accountables-#{(hash ^ definitions.hash).to_s(36)}`.`type`").where("`accountables-#{(hash ^ definitions.hash).to_s(36)}`.`id` IS NULL") }
         end
       end
 
@@ -45,7 +50,12 @@ module ESA
           scope :with_accountable, lambda { |accountable,type|
             where(accountable_id: accountable, accountable_type: type)
           }
+          scope :excl_accountable, lambda { |accountable,type|
+            where(arel_table[:accountable_id].not_eq(accountable), arel_table[:accountable_type].not_eq(type))
+          }
+
           scope :with_accountable_def, lambda { |definitions| joins("INNER JOIN (#{ESA::Filters::AccountableFilter.make_union_query(definitions)}) `accountables-#{(hash ^ definitions.hash).to_s(36)}` ON `#{table_name}`.`accountable_id` = `accountables-#{(hash ^ definitions.hash).to_s(36)}`.`id` AND `#{table_name}`.`accountable_type` = `accountables-#{(hash ^ definitions.hash).to_s(36)}`.`type`") }
+          scope :excl_accountable_def, lambda { |definitions| joins("LEFT OUTER JOIN (#{ESA::Filters::AccountableFilter.make_union_query(definitions)}) `accountables-#{(hash ^ definitions.hash).to_s(36)}` ON `#{table_name}`.`accountable_id` = `accountables-#{(hash ^ definitions.hash).to_s(36)}`.`id` AND `#{table_name}`.`accountable_type` = `accountables-#{(hash ^ definitions.hash).to_s(36)}`.`type`").where("`accountables-#{(hash ^ definitions.hash).to_s(36)}`.`id` IS NULL") }
         end
       end
     end

data/lib/esa/filters/accountable_type_filter.rb

@@ -6,6 +6,7 @@ module ESA
 
         included do
           scope :with_accountable_type, lambda { |type| joins(:transaction).where(esa_transactions: {accountable_type: type}) }
+          scope :excl_accountable_type, lambda { |type| joins(:transaction).where(ESA::Transaction.arel_table[:accountable_type].not_eq(type)) }
         end
       end
 
@@ -14,6 +15,7 @@ module ESA
 
         included do
           scope :with_accountable_type, lambda { |type| where(accountable_type: type) }
+          scope :excl_accountable_type, lambda { |type| where(arel_table[:accountable_type].not_eq(type)) }
         end
       end
     end

data/lib/esa/subcontext_checker.rb

@@ -1,13 +1,25 @@
 module ESA
   class SubcontextChecker
-    def self.check(context)
-      ESA.configuration.context_providers_for_path(context.effective_path).each do |namespace,provider|
+    def self.providers(context, options = {})
+      if :namespace.in? options
+        if options[:namespace].respond_to? :each
+          ESA.configuration.context_providers.slice(*options[:namespace])
+        else
+          ESA.configuration.context_providers.slice("#{options[:namespace]}")
+        end
+      else
+        ESA.configuration.context_providers_for_path(context.effective_path)
+      end
+    end
+
+    def self.check(context, options = {})
+      providers(context, options).each do |namespace,provider|
         if provider.is_a? Class and provider.respond_to? :check_subcontexts
           provider.check_subcontexts(context, namespace)
-        elsif provider.respond_to? :count and provider.count == 2 and 
+        elsif provider.respond_to? :count and provider.count == 2 and
               provider[0].is_a? Class and provider[0].respond_to? :check_subcontexts and provider[1].is_a? Hash
-          klass, options = provider
-          klass.check_subcontexts(context, namespace, options)
+          provider_klass, provider_options = provider
+          provider_klass.check_subcontexts(context, namespace, provider_options)
         end
       end
     end

data/lib/esa/version.rb

@@ -1,3 +1,3 @@
 module ESA
-  VERSION = "0.1.6"
+  VERSION = "0.2.2"
 end