double_entry 1.0.1 → 2.0.0.beta1

data/lib/double_entry/reporting/aggregate.rb

@@ -2,21 +2,29 @@
 module DoubleEntry
   module Reporting
     class Aggregate
-      attr_reader :function, :account, :code, :range, :filter, :currency
+      attr_reader :function, :account, :partner_account, :code, :range, :filter, :currency
 
-      def self.formatted_amount(function, account, code, range, options = {})
-        new(function, account, code, range, options).formatted_amount
+      def self.formatted_amount(function:, account:, code:, range:, partner_account: nil, filter: nil)
+        new(
+          function: function,
+          account: account,
+          code: code,
+          range: range,
+          partner_account: partner_account,
+          filter: filter,
+        ).formatted_amount
       end
 
-      def initialize(function, account, code, range, options = {})
+      def initialize(function:, account:, code:, range:, partner_account: nil, filter: nil)
         @function = function.to_s
         fail AggregateFunctionNotSupported unless %w(sum count average).include?(@function)
 
-        @account = account
-        @code = code ? code.to_s : nil
-        @range = range
-        @filter = options[:filter]
-        @currency = DoubleEntry::Account.currency(account)
+        @account         = account
+        @code            = code.try(:to_s)
+        @range           = range
+        @partner_account = partner_account
+        @filter          = filter
+        @currency        = DoubleEntry::Account.currency(account)
       end
 
       def amount(force_recalculation = false)
@@ -52,7 +60,14 @@ module DoubleEntry
         if range.class == YearRange
           aggregate = calculate_yearly_aggregate
         else
-          aggregate = LineAggregate.aggregate(function, account, code, range, filter)
+          aggregate = LineAggregate.aggregate(
+            function: function,
+            account: account,
+            partner_account: partner_account,
+            code: code,
+            range: range,
+            named_scopes: filter
+          )
         end
 
         if range_is_complete?
@@ -73,7 +88,9 @@ module DoubleEntry
           calculate_yearly_average
         else
           result = (1..12).inject(formatted_amount(0)) do |total, month|
-            total + Aggregate.new(function, account, code, MonthRange.new(:year => range.year, :month => month), :filter => filter).formatted_amount
+            total + Aggregate.new(function: function, account: account, code: code,
+                                  range: MonthRange.new(:year => range.year, :month => month),
+                                  partner_account: partner_account, filter: filter).formatted_amount
           end
           result.is_a?(Money) ? result.cents : result
         end
@@ -82,8 +99,10 @@ module DoubleEntry
       def calculate_yearly_average
         # need this seperate function, because an average of averages is not the correct average
         year_range = YearRange.new(:year => range.year)
-        sum = Aggregate.new(:sum, account, code, year_range, :filter => filter).formatted_amount
-        count = Aggregate.new(:count, account, code, year_range, :filter => filter).formatted_amount
+        sum = Aggregate.new(function: :sum, account: account, code: code, range: year_range,
+                            partner_account: partner_account, filter: filter).formatted_amount
+        count = Aggregate.new(function: :count, account: account, code: code, range: year_range,
+                              partner_account: partner_account, filter: filter).formatted_amount
         (count == 0) ? 0 : (sum / count).cents
       end
 
@@ -93,16 +112,17 @@ module DoubleEntry
 
       def field_hash
         {
-          :function => function,
-          :account => account,
-          :code => code,
-          :year => range.year,
-          :month => range.month,
-          :week => range.week,
-          :day => range.day,
-          :hour => range.hour,
-          :filter => filter.inspect,
-          :range_type => range.range_type.to_s,
+          :function        => function,
+          :account         => account,
+          :partner_account => partner_account,
+          :code            => code,
+          :year            => range.year,
+          :month           => range.month,
+          :week            => range.week,
+          :day             => range.day,
+          :hour            => range.hour,
+          :filter          => filter.inspect,
+          :range_type      => range.range_type.to_s,
         }
       end
     end

data/lib/double_entry/reporting/aggregate_array.rb

@@ -9,17 +9,18 @@ module DoubleEntry
       #
       # For example, you could request all sales
       # broken down by month and it would return an array of values
-      attr_reader :function, :account, :code, :filter, :range_type, :start, :finish, :currency
+      attr_reader :function, :account, :partner_account, :code, :filter, :range_type, :start, :finish, :currency
 
-      def initialize(function, account, code, options)
-        @function = function.to_s
-        @account = account
-        @code = code
-        @filter = options[:filter]
-        @range_type = options[:range_type]
-        @start = options[:start]
-        @finish = options[:finish]
-        @currency = DoubleEntry::Account.currency(account)
+      def initialize(function:, account:, code:, partner_account: nil, filter: nil, range_type: nil, start: nil, finish: nil)
+        @function        = function.to_s
+        @account         = account
+        @code            = code
+        @partner_account = partner_account
+        @filter          = filter
+        @range_type      = range_type
+        @start           = start
+        @finish          = finish
+        @currency        = DoubleEntry::Account.currency(account)
 
         retrieve_aggregates
         fill_in_missing_aggregates
@@ -39,7 +40,8 @@ module DoubleEntry
         # (this includes aggregates for the still-running period)
         all_periods.each do |period|
           unless @aggregates[period.key]
-            @aggregates[period.key] = Aggregate.formatted_amount(function, account, code, period, :filter => filter)
+            @aggregates[period.key] = Aggregate.formatted_amount(function: function, account: account, code: code,
+                                                                 range: period, partner_account: partner_account, filter: filter)
           end
         end
       end
@@ -50,8 +52,9 @@ module DoubleEntry
         scope = LineAggregate.
                 where(:function => function).
                 where(:range_type => 'normal').
-                where(:account => account.to_s).
-                where(:code => code.to_s).
+                where(:account => account.try(:to_s)).
+                where(:partner_account => partner_account.try(:to_s)).
+                where(:code => code.try(:to_s)).
                 where(:filter => filter.inspect).
                 where(LineAggregate.arel_table[range_type].not_eq(nil))
         @aggregates = scope.each_with_object({}) do |result, hash|

data/lib/double_entry/reporting/line_aggregate.rb

@@ -2,8 +2,9 @@
 module DoubleEntry
   module Reporting
     class LineAggregate < ActiveRecord::Base
-      def self.aggregate(function, account, code, range, named_scopes)
-        collection_filter = LineAggregateFilter.new(account, code, range, named_scopes)
+      def self.aggregate(function:, account:, partner_account:, code:, range:, named_scopes:)
+        collection_filter = LineAggregateFilter.new(account: account, partner_account: partner_account,
+                                                    code: code, range: range, filter_criteria: named_scopes)
         collection = collection_filter.filter
         collection.send(function, :amount)
       end

data/lib/double_entry/reporting/line_aggregate_filter.rb

@@ -2,8 +2,10 @@
 module DoubleEntry
   module Reporting
     class LineAggregateFilter
-      def initialize(account, code, range, filter_criteria)
+
+      def initialize(account:, partner_account:, code:, range:, filter_criteria:)
         @account         = account
+        @partner_account = partner_account
         @code            = code
         @range           = range
         @filter_criteria = filter_criteria || []
@@ -20,6 +22,7 @@ module DoubleEntry
                      where(:account => @account).
                      where(:created_at => @range.start..@range.finish)
         collection = collection.where(:code => @code) if @code
+        collection = collection.where(:partner_account => @partner_account) if @partner_account
 
         collection
       end
@@ -42,10 +45,11 @@ module DoubleEntry
       #         :name => :ten_dollar_purchases
       #       }
       #     },
-      #     # an example of providing a single metadatum criteria to filter on
+      #     # an example of providing multiple metadatum criteria to filter on
       #     {
       #       :metadata => {
-      #         :meme => :business_cat
+      #         :meme => :business_cat,
+      #         :category => :fun_times,
       #       }
       #     }
       #   ]
@@ -66,13 +70,7 @@ module DoubleEntry
       end
 
       def filter_by_metadata(collection, metadata)
-        metadata.reduce(collection.joins(:metadata)) do |filtered_collection, (key, value)|
-          filtered_collection.where(metadata_table => { :key => key, :value => value })
-        end
-      end
-
-      def metadata_table
-        DoubleEntry::LineMetadata.table_name.to_sym
+        DoubleEntry::Reporting::LineMetadataFilter.filter(collection: collection, metadata: metadata)
       end
     end
   end

data/lib/double_entry/reporting/line_metadata_filter.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+module DoubleEntry
+  module Reporting
+    class LineMetadataFilter
+
+      def self.filter(collection:, metadata:)
+        table_alias_index = 0
+
+        metadata.reduce(collection) do |filtered_collection, (key, value)|
+          table_alias = "m#{table_alias_index}"
+          table_alias_index += 1
+
+          filtered_collection.
+            joins("INNER JOIN #{line_metadata_table} as #{table_alias} ON #{table_alias}.line_id = #{lines_table}.id").
+            where("#{table_alias}.key = ? AND #{table_alias}.value = ?", key, value)
+        end
+      end
+
+    private
+
+      def self.line_metadata_table
+        DoubleEntry::LineMetadata.table_name
+      end
+      private_class_method :line_metadata_table
+
+      def self.lines_table
+        DoubleEntry::Line.table_name
+      end
+      private_class_method :lines_table
+
+    end
+  end
+end

data/lib/double_entry/transfer.rb

@@ -1,19 +1,17 @@
 # encoding: utf-8
+require 'forwardable'
+
 module DoubleEntry
   class Transfer
     class << self
-      attr_writer :transfers, :code_max_length
+      attr_accessor :code_max_length
+      attr_writer :transfers
 
       # @api private
       def transfers
         @transfers ||= Set.new
       end
 
-      # @api private
-      def code_max_length
-        @code_max_length ||= 47
-      end
-
       # @api private
       def transfer(amount, options = {})
         fail TransferIsNegative if amount.negative?
@@ -25,37 +23,43 @@ module DoubleEntry
     end
 
     # @api private
-    class Set < Array
+    class Set
+      extend Forwardable
+      delegate [:each, :map] => :all
+
       def define(attributes)
-        self << Transfer.new(attributes)
+        Transfer.new(attributes).tap do |transfer|
+          key = [transfer.from, transfer.to, transfer.code]
+          if _find(*key)
+            fail DuplicateTransfer
+          else
+            backing_collection[key] = transfer
+          end
+        end
       end
 
-      def find(from, to, code)
-        _find(from.identifier, to.identifier, code)
+      def find(from_account, to_account, code)
+        _find(from_account.identifier, to_account.identifier, code)
       end
 
-      def find!(from, to, code)
-        find(from, to, code).tap do |transfer|
-          fail TransferNotAllowed, [from.identifier, to.identifier, code].inspect unless transfer
+      def find!(from_account, to_account, code)
+        find(from_account, to_account, code).tap do |transfer|
+          fail TransferNotAllowed, [from_account.identifier, to_account.identifier, code].inspect unless transfer
         end
       end
 
-      def <<(transfer)
-        if _find(transfer.from, transfer.to, transfer.code)
-          fail DuplicateTransfer
-        else
-          super(transfer)
-        end
+      def all
+        backing_collection.values
       end
 
     private
 
+      def backing_collection
+        @backing_collection ||= Hash.new
+      end
+
       def _find(from, to, code)
-        detect do |transfer|
-          transfer.from == from &&
-            transfer.to == to &&
-            transfer.code == code
-        end
+        backing_collection[[from, to, code]]
       end
     end
 
@@ -65,7 +69,7 @@ module DoubleEntry
       @code = attributes[:code]
       @from = attributes[:from]
       @to = attributes[:to]
-      if code.length > Transfer.code_max_length
+      if Transfer.code_max_length && code.length > Transfer.code_max_length
         fail TransferCodeTooLongError,
              "transfer code '#{code}' is too long. Please limit it to #{Transfer.code_max_length} characters."
       end
@@ -115,8 +119,10 @@ module DoubleEntry
 
     def create_line_metadata(credit, debit, metadata)
       metadata.each_pair do |key, value|
-        LineMetadata.create!(:line => credit, :key => key, :value => value)
-        LineMetadata.create!(:line => debit, :key => key, :value => value)
+        Array(value).each do |each_value|
+          LineMetadata.create!(:line => credit, :key => key, :value => each_value)
+          LineMetadata.create!(:line => debit, :key => key, :value => each_value)
+        end
       end
     end
   end

data/lib/double_entry/validation.rb

@@ -1 +1,2 @@
+require 'double_entry/validation/account_fixer'
 require 'double_entry/validation/line_check'

data/lib/double_entry/validation/account_fixer.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module DoubleEntry
+  module Validation
+    class AccountFixer
+      def recalculate_account(account)
+        DoubleEntry.lock_accounts(account) do
+          recalculated_balance = Money.zero(account.currency)
+
+          lines_for_account(account).each do |line|
+            recalculated_balance += line.amount
+            if line.balance != recalculated_balance
+              line.update_attribute(:balance, recalculated_balance)
+            end
+          end
+
+          update_balance_for_account(account, recalculated_balance)
+        end
+      end
+
+      private
+
+      def lines_for_account(account)
+        Line.where(
+          account: account.identifier.to_s,
+          scope: account.scope_identity.to_s
+        ).order(:id)
+      end
+
+      def update_balance_for_account(account, balance)
+        account_balance = Locking.balance_for_locked_account(account)
+        account_balance.update_attribute(:balance, balance)
+      end
+    end
+  end
+end

data/lib/double_entry/validation/line_check.rb

@@ -4,13 +4,16 @@ require 'set'
 module DoubleEntry
   module Validation
     class LineCheck < ActiveRecord::Base
-      default_scope -> { order('created_at') }
 
-      def self.perform!
-        new.perform
+      def self.last_line_id_checked
+        order('created_at DESC').limit(1).pluck(:last_line_id).first || 0
       end
 
-      def perform
+      def self.perform!(fixer: nil)
+        new.perform(fixer: fixer)
+      end
+
+      def perform(fixer: nil)
         log = ''
         current_line_id = nil
 
@@ -24,10 +27,10 @@ module DoubleEntry
         end
 
         active_accounts.each do |account|
-          incorrect_accounts << account      unless cached_balance_correct?(account)
+          incorrect_accounts << account unless cached_balance_correct?(account, log)
         end
 
-        incorrect_accounts.each { |account| recalculate_account(account) }
+        incorrect_accounts.each(&fixer.method(:recalculate_account)) if fixer
 
         unless active_accounts.empty?
           LineCheck.create!(
@@ -40,13 +43,8 @@ module DoubleEntry
 
     private
 
-      def last_run_line_id
-        latest = LineCheck.last
-        latest ? latest.last_line_id : 0
-      end
-
       def new_lines_since_last_run
-        Line.where('id > ?', last_run_line_id)
+        Line.with_id_greater_than(LineCheck.last_line_id_checked)
       end
 
       def running_balance_correct?(line, log)
@@ -88,39 +86,23 @@ module DoubleEntry
           #{previous_line.inspect}
           #{line.inspect}
 
-          END_OF_MESSAGE
-      end
-
-      def cached_balance_correct?(account)
-        DoubleEntry.lock_accounts(account) do
-          return AccountBalance.find_by_account(account).balance == account.balance
-        end
+        END_OF_MESSAGE
       end
 
-      def recalculate_account(account)
+      def cached_balance_correct?(account, log)
         DoubleEntry.lock_accounts(account) do
-          recalculated_balance = Money.zero(account.currency)
-
-          lines_for_account(account).each do |line|
-            recalculated_balance += line.amount
-            line.update_attribute(:balance, recalculated_balance) if line.balance != recalculated_balance
-          end
-
-          update_balance_for_account(account, recalculated_balance)
+          cached_balance = AccountBalance.find_by_account(account).balance
+          running_balance = account.balance
+          correct = (cached_balance == running_balance)
+          log << <<~MESSAGE unless correct
+            *********************************
+            Error on account #{account}: #{cached_balance} (cached balance) != #{running_balance} (running balance)
+            *********************************
+
+          MESSAGE
+          return correct
         end
       end
-
-      def lines_for_account(account)
-        Line.where(
-          :account => account.identifier.to_s,
-          :scope   => account.scope_identity.to_s,
-        ).order(:id)
-      end
-
-      def update_balance_for_account(account, balance)
-        account_balance = Locking.balance_for_locked_account(account)
-        account_balance.update_attribute(:balance, balance)
-      end
     end
   end
 end