double_entry 0.1.0 → 0.2.0

data/README.md

@@ -133,7 +133,7 @@ the accounts, and permitted transfers between those accounts.
 The configuration file should be kept in your application's load path.  For example,
 *config/initializers/double_entry.rb*
 
-For example, the following specifies two accounts, account_a and account_b.
+For example, the following specifies two accounts, savings and checking.
 Each account is scoped by User (where User is an object with an ID), meaning
 each user can have their own account of each type.
 
@@ -142,22 +142,24 @@ This configuration also specifies that money can be transferred between the two
 ```ruby
 require 'double_entry'
 
-DoubleEntry.accounts = DoubleEntry::Account::Set.new.tap do |accounts|
-  user_scope = lambda do |user_identifier|
-    if user_identifier.is_a?(User)
-      user_identifier.id
-    else
-      user_identifier
+DoubleEntry.configure do |config|
+  config.define_accounts do |accounts|
+    user_scope = lambda do |user_identifier|
+      if user_identifier.is_a?(User)
+        user_identifier.id
+      else
+        user_identifier
+      end
     end
-  end
 
-  accounts << DoubleEntry::Account.new(identifier: :savings,  scope_identifier: user_scope, positive_only: true)
-  accounts << DoubleEntry::Account.new(identifier: :checking, scope_identifier: user_scope)
-end
+    accounts.define(identifier: :savings,  scope_identifier: user_scope, positive_only: true)
+    accounts.define(identifier: :checking, scope_identifier: user_scope)
+  end
 
-DoubleEntry.transfers = DoubleEntry::Transfer::Set.new.tap do |transfers|
-  transfers << DoubleEntry::Transfer.new(from: :checking, to: :savings,  code: :deposit)
-  transfers << DoubleEntry::Transfer.new(from: :savings,  to: :checking, code: :withdraw)
+  config.define_transfers do |transfers|
+    transfers.define(from: :checking, to: :savings,  code: :deposit)
+    transfers.define(from: :savings,  to: :checking, code: :withdraw)
+  end
 end
 ```
 

data/lib/double_entry.rb

@@ -1,32 +1,20 @@
 # encoding: utf-8
-
 require 'active_record'
 require 'active_record/locking_extensions'
-
 require 'active_support/all'
-
 require 'money'
 require 'encapsulate_as_money'
 
 require 'double_entry/version'
 require 'double_entry/configurable'
+require 'double_entry/configuration'
 require 'double_entry/account'
 require 'double_entry/account_balance'
-require 'double_entry/reporting'
-require 'double_entry/aggregate'
-require 'double_entry/aggregate_array'
-require 'double_entry/time_range'
-require 'double_entry/time_range_array'
-require 'double_entry/day_range'
-require 'double_entry/hour_range'
-require 'double_entry/week_range'
-require 'double_entry/month_range'
-require 'double_entry/year_range'
-require 'double_entry/line'
-require 'double_entry/line_aggregate'
-require 'double_entry/line_check'
 require 'double_entry/locking'
 require 'double_entry/transfer'
+require 'double_entry/line'
+require 'double_entry/reporting'
+require 'double_entry/validation'
 
 # Keep track of all the monies!
 #
@@ -44,7 +32,6 @@ module DoubleEntry
   class AccountWouldBeSentNegative < RuntimeError; end
 
   class << self
-    attr_accessor :accounts, :transfers
 
     # Get the particular account instance with the provided identifier and
     # scope.
@@ -60,8 +47,8 @@ module DoubleEntry
     #   configured. It is unknown.
     #
     def account(identifier, options = {})
-      account = @accounts.detect do |current_account|
-        current_account.identifier == identifier and
+      account = configuration.accounts.detect do |current_account|
+        current_account.identifier == identifier &&
           (options[:scope] ? current_account.scoped? : !current_account.scoped?)
       end
 
@@ -108,7 +95,7 @@ module DoubleEntry
     def transfer(amount, options = {})
       raise TransferIsNegative if amount < Money.new(0)
       from, to, code, meta, detail = options[:from], options[:to], options[:code], options[:meta], options[:detail]
-      transfer = @transfers.find(from, to, code)
+      transfer = configuration.transfers.find(from, to, code)
       if transfer
         transfer.process!(amount, from, to, code, meta, detail)
       else
@@ -179,27 +166,6 @@ module DoubleEntry
       end
     end
 
-    # Identify the scopes with the given account identifier holding at least
-    # the provided minimum balance.
-    #
-    # @example Find users with at lease $1,000,000 in their savings accounts
-    #   DoubleEntry.scopes_with_minimum_balance_for_account(
-    #     Money.new(1_000_000_00),
-    #     :savings
-    #   ) # might return user ids: [ 1423, 12232, 34729 ]
-    # @param minimum_balance [Money] Minimum account balance a scope must have
-    #   to be included in the result set.
-    # @param account_identifier [Symbol]
-    # @return [Array<Fixnum>] Scopes
-    def scopes_with_minimum_balance_for_account(minimum_balance, account_identifier)
-      select_values(sanitize_sql_array([<<-SQL, account_identifier, minimum_balance.cents])).map {|scope| scope.to_i }
-        SELECT scope
-          FROM #{AccountBalance.table_name}
-         WHERE account = ?
-           AND balance >= ?
-      SQL
-    end
-
     # Lock accounts in preparation for transfers.
     #
     # This creates a transaction, and uses database-level locking to ensure
@@ -225,20 +191,12 @@ module DoubleEntry
       # make sure we have a test for this refactoring, the test
       # conditions are: i forget... but it's important!
       if line.credit?
-        @transfers.find(line.account, line.partner_account, line.code)
+        configuration.transfers.find(line.account, line.partner_account, line.code)
       else
-        @transfers.find(line.partner_account, line.account, line.code)
+        configuration.transfers.find(line.partner_account, line.account, line.code)
       end.description.call(line)
     end
 
-    def aggregate(function, account, code, options = {})
-      DoubleEntry::Aggregate.new(function, account, code, options).formatted_amount
-    end
-
-    def aggregate_array(function, account, code, options = {})
-      DoubleEntry::AggregateArray.new(function, account, code, options)
-    end
-
     # This is used by the concurrency test script.
     #
     # @api private
@@ -255,16 +213,5 @@ module DoubleEntry
     def table_name_prefix
       'double_entry_'
     end
-
-  private
-
-    delegate :connection, :to => ActiveRecord::Base
-    delegate :select_values, :to => :connection
-
-    def sanitize_sql_array(sql_array)
-      ActiveRecord::Base.send(:sanitize_sql_array, sql_array)
-    end
-
   end
-
 end

data/lib/double_entry/account.rb

@@ -2,8 +2,12 @@
 module DoubleEntry
   class Account
     class Set < Array
+      def define(attributes)
+        self << Account.new(attributes)
+      end
+
       def <<(account)
-        if detect { |a| a.identifier == account.identifier }
+        if any? { |a| a.identifier == account.identifier }
           raise DuplicateAccount.new
         else
           super(account)

data/lib/double_entry/configuration.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+module DoubleEntry
+  include Configurable
+
+  class Configuration
+    attr_accessor :accounts, :transfers
+
+    def initialize #:nodoc:
+      @accounts = Account::Set.new
+      @transfers = Transfer::Set.new
+    end
+
+    def define_accounts
+      yield accounts
+    end
+
+    def define_transfers
+      yield transfers
+    end
+  end
+end

data/lib/double_entry/reporting.rb

@@ -1,7 +1,21 @@
 # encoding: utf-8
+require 'double_entry/reporting/aggregate'
+require 'double_entry/reporting/aggregate_array'
+require 'double_entry/reporting/time_range'
+require 'double_entry/reporting/time_range_array'
+require 'double_entry/reporting/day_range'
+require 'double_entry/reporting/hour_range'
+require 'double_entry/reporting/week_range'
+require 'double_entry/reporting/month_range'
+require 'double_entry/reporting/year_range'
+require 'double_entry/reporting/line_aggregate'
+
 module DoubleEntry
+
+  # @api private
   module Reporting
     include Configurable
+    extend self
 
     class Configuration
       attr_accessor :start_of_business, :first_month_of_financial_year
@@ -12,5 +26,42 @@ module DoubleEntry
       end
     end
 
+    def aggregate(function, account, code, options = {})
+      Aggregate.new(function, account, code, options).formatted_amount
+    end
+
+    def aggregate_array(function, account, code, options = {})
+      AggregateArray.new(function, account, code, options)
+    end
+
+    # Identify the scopes with the given account identifier holding at least
+    # the provided minimum balance.
+    #
+    # @example Find users with at least $1,000,000 in their savings accounts
+    #   DoubleEntry.scopes_with_minimum_balance_for_account(
+    #     Money.new(1_000_000_00),
+    #     :savings
+    #   ) # might return user ids: [ 1423, 12232, 34729 ]
+    # @param minimum_balance [Money] Minimum account balance a scope must have
+    #   to be included in the result set.
+    # @param account_identifier [Symbol]
+    # @return [Array<Fixnum>] Scopes
+    def scopes_with_minimum_balance_for_account(minimum_balance, account_identifier)
+      select_values(sanitize_sql_array([<<-SQL, account_identifier, minimum_balance.cents])).map {|scope| scope.to_i }
+        SELECT scope
+          FROM #{AccountBalance.table_name}
+         WHERE account = ?
+           AND balance >= ?
+      SQL
+    end
+
+  private
+
+    delegate :connection, :to => ActiveRecord::Base
+    delegate :select_values, :to => :connection
+
+    def sanitize_sql_array(sql_array)
+      ActiveRecord::Base.send(:sanitize_sql_array, sql_array)
+    end
   end
 end

data/lib/double_entry/{aggregate.rb → reporting/aggregate.rb}

@@ -1,5 +1,6 @@
 # encoding: utf-8
 module DoubleEntry
+ module Reporting
   class Aggregate
     attr_reader :function, :account, :code, :scope, :range, :options, :filter
 
@@ -51,7 +52,7 @@ module DoubleEntry
     end
 
     def calculate
-      if range.class == DoubleEntry::YearRange
+      if range.class == YearRange
         aggregate = calculate_yearly_aggregate
       else
         aggregate = LineAggregate.aggregate(function, account, code, nil, range, filter)
@@ -78,8 +79,8 @@ module DoubleEntry
         zero = Aggregate.formatted_amount(function, 0)
 
         result = (1..12).inject(zero) do |total, month|
-          total += DoubleEntry.aggregate(function, account, code,
-                                      :range => DoubleEntry::MonthRange.new(:year => range.year, :month => month), :filter => filter)
+          total += Reporting.aggregate(function, account, code,
+                                      :range => MonthRange.new(:year => range.year, :month => month), :filter => filter)
         end
 
         result = result.cents if result.class == Money
@@ -89,10 +90,10 @@ module DoubleEntry
 
     def calculate_yearly_average
       # need this seperate function, because an average of averages is not the correct average
-      sum = DoubleEntry.aggregate(:sum, account, code,
-                               :range => DoubleEntry::YearRange.new(:year => range.year), :filter => filter)
-      count = DoubleEntry.aggregate(:count, account, code,
-                                 :range => DoubleEntry::YearRange.new(:year => range.year), :filter => filter)
+      sum = Reporting.aggregate(:sum, account, code,
+                               :range => YearRange.new(:year => range.year), :filter => filter)
+      count = Reporting.aggregate(:count, account, code,
+                                 :range => YearRange.new(:year => range.year), :filter => filter)
       (count == 0) ? 0 : (sum / count).cents
     end
 
@@ -115,4 +116,5 @@ module DoubleEntry
       }
     end
   end
+ end
 end

data/lib/double_entry/{aggregate_array.rb → reporting/aggregate_array.rb}

@@ -1,5 +1,6 @@
 # encoding: utf-8
 module DoubleEntry
+ module Reporting
   class AggregateArray < Array
     # An AggregateArray is awesome
     # It is useful for making reports
@@ -37,7 +38,7 @@ module DoubleEntry
       # (this includes aggregates for the still-running period)
       all_periods.each do |period|
         unless @aggregates[period.key]
-          @aggregates[period.key] = DoubleEntry.aggregate(function, account, code, :filter => filter, :range => period)
+          @aggregates[period.key] = Reporting.aggregate(function, account, code, :filter => filter, :range => period)
         end
       end
     end
@@ -62,4 +63,5 @@ module DoubleEntry
       TimeRangeArray.make(range_type, start, finish)
     end
   end
+ end
 end

data/lib/double_entry/{day_range.rb → reporting/day_range.rb}

@@ -1,5 +1,6 @@
 # encoding: utf-8
 module DoubleEntry
+ module Reporting
   class DayRange < TimeRange
     attr_reader :year, :week, :day
 
@@ -35,4 +36,5 @@ module DoubleEntry
       start.strftime('%Y, %a %b %d')
     end
   end
+ end
 end

data/lib/double_entry/{hour_range.rb → reporting/hour_range.rb}

@@ -1,5 +1,6 @@
 # encoding: utf-8
 module DoubleEntry
+ module Reporting
   class HourRange < TimeRange
     attr_reader :year, :week, :day, :hour
 
@@ -37,4 +38,5 @@ module DoubleEntry
       "#{start.hour}:00:00 - #{start.hour}:59:59"
     end
   end
+ end
 end

data/lib/double_entry/{line_aggregate.rb → reporting/line_aggregate.rb}

@@ -1,5 +1,6 @@
 # encoding: utf-8
 module DoubleEntry
+ module Reporting
   class LineAggregate < ActiveRecord::Base
     extend EncapsulateAsMoney
 
@@ -15,7 +16,7 @@ module DoubleEntry
     # in named_scopes to bring in data from other tables.
     def self.aggregate_collection(named_scopes)
       if named_scopes
-        collection = Line
+        collection = DoubleEntry::Line
         named_scopes.each do |named_scope|
           if named_scope.is_a?(Hash)
             method_name = named_scope.keys[0]
@@ -26,7 +27,7 @@ module DoubleEntry
         end
         collection
       else
-        Line
+        DoubleEntry::Line
       end
     end
 
@@ -34,4 +35,5 @@ module DoubleEntry
       "#{year}:#{month}:#{week}:#{day}:#{hour}"
     end
   end
+ end
 end

data/lib/double_entry/{month_range.rb → reporting/month_range.rb}

@@ -1,5 +1,6 @@
 # encoding: utf-8
 module DoubleEntry
+ module Reporting
   class MonthRange < TimeRange
 
     class << self
@@ -29,7 +30,7 @@ module DoubleEntry
       end
 
       def earliest_month
-        from_time(DoubleEntry::Reporting.configuration.start_of_business)
+        from_time(Reporting.configuration.start_of_business)
       end
     end
 
@@ -66,7 +67,7 @@ module DoubleEntry
     end
 
     def beginning_of_financial_year
-      first_month_of_financial_year = DoubleEntry::Reporting.configuration.first_month_of_financial_year
+      first_month_of_financial_year = Reporting.configuration.first_month_of_financial_year
       year = (month >= first_month_of_financial_year) ? @year : (@year - 1)
       MonthRange.new(:year => year, :month => first_month_of_financial_year)
     end
@@ -89,4 +90,5 @@ module DoubleEntry
       start.strftime("%Y, %b")
     end
   end
+ end
 end

data/lib/double_entry/{time_range.rb → reporting/time_range.rb}

@@ -1,5 +1,6 @@
 # encoding: utf-8
 module DoubleEntry
+ module Reporting
   class TimeRange
     attr_reader :start, :finish
     attr_reader :year, :month, :week, :day, :hour, :range_type
@@ -25,13 +26,13 @@ module DoubleEntry
     def self.range_from_time_for_period(start_time, period_name)
        case period_name
          when 'month'
-           DoubleEntry::YearRange.from_time(start_time)
+           YearRange.from_time(start_time)
          when 'week'
-            DoubleEntry::YearRange.from_time(start_time)
+            YearRange.from_time(start_time)
          when 'day'
-           DoubleEntry::MonthRange.from_time(start_time)
+           MonthRange.from_time(start_time)
          when 'hour'
-           DoubleEntry::DayRange.from_time(start_time)
+           DayRange.from_time(start_time)
        end
     end
 
@@ -49,7 +50,8 @@ module DoubleEntry
     end
 
     def human_readable_name
-      self.class.name.gsub('DoubleEntry::', '').gsub('Range', '')
+      self.class.name.gsub('DoubleEntry::Reporting::', '').gsub('Range', '')
     end
   end
+ end
 end