double_entry 0.10.0 → 0.10.1

data/lib/double_entry/balance_calculator.rb

@@ -24,10 +24,10 @@ module DoubleEntry
       else
         # all other lookups can be performed with running balances
         result = lines.
-          from(lines_table_name(options)).
-          order('id DESC').
-          limit(1).
-          pluck(:balance)
+                 from(lines_table_name(options)).
+                 order('id DESC').
+                 limit(1).
+                 pluck(:balance)
         result.empty? ? Money.zero(account.currency) : Money.new(result.first, account.currency)
       end
     end
@@ -94,6 +94,5 @@ module DoubleEntry
         lines
       end
     end
-
   end
 end

data/lib/double_entry/configurable.rb

@@ -1,6 +1,5 @@
 # encoding: utf-8
 module DoubleEntry
-
   # Make configuring a module or a class simple.
   #
   #   class MyClass
@@ -48,5 +47,4 @@ module DoubleEntry
       end
     end
   end
-
 end

data/lib/double_entry/configuration.rb

@@ -3,7 +3,6 @@ module DoubleEntry
   include Configurable
 
   class Configuration
-
     delegate(
       :accounts,
       :accounts=,
@@ -11,7 +10,7 @@ module DoubleEntry
       :scope_identifier_max_length=,
       :account_identifier_max_length,
       :account_identifier_max_length=,
-      :to => "DoubleEntry::Account",
+      :to => 'DoubleEntry::Account',
     )
 
     delegate(
@@ -19,7 +18,7 @@ module DoubleEntry
       :transfers=,
       :code_max_length,
       :code_max_length=,
-      :to => "DoubleEntry::Transfer",
+      :to => 'DoubleEntry::Transfer',
     )
 
     def define_accounts

data/lib/double_entry/errors.rb

@@ -11,6 +11,6 @@ module DoubleEntry
   class AccountWouldBeSentNegative < RuntimeError; end
   class AccountWouldBeSentPositiveError < RuntimeError; end
   class MismatchedCurrencies < RuntimeError; end
-  class MissingAccountError < RuntimeError; end;
-  class AccountScopeMismatchError < RuntimeError; end;
+  class MissingAccountError < RuntimeError; end
+  class AccountScopeMismatchError < RuntimeError; end
 end

data/lib/double_entry/line.rb

@@ -1,7 +1,6 @@
 # encoding: utf-8
 
 module DoubleEntry
-
   # This is the table to end all tables!
   #
   # Every financial transaction gets two entries in here: one for the source
@@ -56,7 +55,6 @@ module DoubleEntry
   # by account, or account and code, over a particular period.
   #
   class Line < ActiveRecord::Base
-
     belongs_to :detail, :polymorphic => true
 
     def amount
@@ -94,11 +92,11 @@ module DoubleEntry
       self[:code].try(:to_sym)
     end
 
-    def account=(_account)
-      self[:account] = _account.identifier.to_s
-      self.scope = _account.scope_identity
-      raise "Missing Account" unless account
-      _account
+    def account=(account)
+      self[:account] = account.identifier.to_s
+      self.scope = account.scope_identity
+      fail 'Missing Account' unless self.account
+      account
     end
 
     def account
@@ -109,11 +107,11 @@ module DoubleEntry
       account.currency if self[:account]
     end
 
-    def partner_account=(_partner_account)
-      self[:partner_account] = _partner_account.identifier.to_s
-      self.partner_scope = _partner_account.scope_identity
-      raise "Missing Partner Account" unless partner_account
-      _partner_account
+    def partner_account=(partner_account)
+      self[:partner_account] = partner_account.identifier.to_s
+      self.partner_scope = partner_account.scope_identity
+      fail 'Missing Partner Account' unless self.partner_account
+      partner_account
     end
 
     def partner_account
@@ -149,16 +147,15 @@ module DoubleEntry
       SQL
     end
 
-    private
+  private
 
     def check_balance_will_remain_valid
       if account.positive_only && balance < Money.zero
-        raise AccountWouldBeSentNegative.new(account)
+        fail AccountWouldBeSentNegative, account
       end
       if account.negative_only && balance > Money.zero
-        raise AccountWouldBeSentPositiveError.new(account)
+        fail AccountWouldBeSentPositiveError, account
       end
     end
   end
-
 end

data/lib/double_entry/locking.rb

@@ -1,6 +1,5 @@
 # encoding: utf-8
 module DoubleEntry
-
   # Lock financial accounts to ensure consistency.
   #
   # In order to ensure financial transactions always keep track of balances
@@ -51,7 +50,7 @@ module DoubleEntry
     end
 
     class Lock
-      @@locks = Hash.new
+      @@locks = {}
 
       def initialize(accounts)
         # Make sure we always lock in the same order, to avoid deadlocks.
@@ -65,9 +64,7 @@ module DoubleEntry
 
         unless lock_and_call(&block)
           create_missing_account_balances
-          unless lock_and_call(&block)
-            raise LockDisaster
-          end
+          fail LockDisaster unless lock_and_call(&block)
         end
       end
 
@@ -78,7 +75,9 @@ module DoubleEntry
 
       def ensure_locked!
         @accounts.each do |account|
-          raise LockNotHeld.new(account) unless have_lock?(account)
+          unless lock?(account)
+            fail LockNotHeld, "No lock held for account: #{account.identifier}, scope #{account.scope}"
+          end
         end
       end
 
@@ -88,7 +87,7 @@ module DoubleEntry
         locks[account]
       end
 
-      private
+    private
 
       def locks
         @@locks[Thread.current.object_id]
@@ -103,19 +102,18 @@ module DoubleEntry
       end
 
       # Return true if there's a lock on the given account.
-      def have_lock?(account)
-        in_a_locked_transaction? && locks.has_key?(account)
+      def lock?(account)
+        in_a_locked_transaction? && locks.key?(account)
       end
 
       # Raise an exception unless we're outside any transactions.
       def ensure_outermost_transaction!
         minimum_transaction_level = Locking.configuration.running_inside_transactional_fixtures ? 1 : 0
         unless AccountBalance.connection.open_transactions <= minimum_transaction_level
-          raise LockMustBeOutermostTransaction
+          fail LockMustBeOutermostTransaction
         end
       end
 
-
       # Start a transaction, grab locks on the given accounts, then call the block
       # from within the transaction.
       #
@@ -144,12 +142,12 @@ module DoubleEntry
       # If one or more account balance records don't exist, set
       # accounts_with_balances to the corresponding accounts, and return false.
       def grab_locks
-        account_balances = @accounts.map {|account| AccountBalance.find_by_account(account, :lock => true) }
+        account_balances = @accounts.map { |account| AccountBalance.find_by_account(account, :lock => true) }
 
         if account_balances.any?(&:nil?)
-          @accounts_without_balances = @accounts.zip(account_balances).
-            select  {|account, account_balance| account_balance.nil? }.
-            collect {|account, account_balance| account }
+          @accounts_without_balances =  @accounts.zip(account_balances).
+                                        select { |_account, account_balance| account_balance.nil? }.
+                                        collect { |account, _account_balance| account }
           false
         else
           self.locks = Hash[*@accounts.zip(account_balances).flatten]
@@ -174,9 +172,6 @@ module DoubleEntry
 
     # Raised when attempting a transfer on an account that's not locked.
     class LockNotHeld < RuntimeError
-      def initialize(account)
-        super "No lock held for account: #{account.identifier}, scope #{account.scope}"
-      end
     end
 
     # Raised if things go horribly, horribly wrong. This should never happen.

data/lib/double_entry/reporting.rb

@@ -11,7 +11,6 @@ require 'double_entry/reporting/line_aggregate'
 require 'double_entry/reporting/time_range_array'
 
 module DoubleEntry
-
   # @api private
   module Reporting
     include Configurable
@@ -131,11 +130,11 @@ module DoubleEntry
     #   ) # might return the user ids: [ 1423, 12232, 34729 ]
     # @param [Money] minimum_balance Minimum account balance a scope must have
     #   to be included in the result set.
-    # @param [Symbol] account_identifier 
+    # @param [Symbol] account_identifier
     # @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_values(sanitize_sql_array([<<-SQL, account_identifier, minimum_balance.cents])).map(&:to_i)
         SELECT scope
           FROM #{AccountBalance.table_name}
          WHERE account = ?

data/lib/double_entry/reporting/aggregate.rb

@@ -1,112 +1,114 @@
 # encoding: utf-8
 module DoubleEntry
- module Reporting
-  class Aggregate
-    attr_reader :function, :account, :code, :range, :options, :filter, :currency
+  module Reporting
+    class Aggregate
+      attr_reader :function, :account, :code, :range, :options, :filter, :currency
 
-    def initialize(function, account, code, options)
-      @function = function.to_s
-      raise AggregateFunctionNotSupported unless %w[sum count average].include?(@function)
+      def initialize(function, account, code, options)
+        @function = function.to_s
+        fail AggregateFunctionNotSupported unless %w(sum count average).include?(@function)
 
-      @account = account
-      @code = code ? code.to_s : nil
-      @options = options
-      @range = options[:range]
-      @filter = options[:filter]
-      @currency = DoubleEntry::Account.currency(account)
-    end
+        @account = account
+        @code = code ? code.to_s : nil
+        @options = options
+        @range = options[:range]
+        @filter = options[:filter]
+        @currency = DoubleEntry::Account.currency(account)
+      end
 
-    def amount(force_recalculation = false)
-      if force_recalculation
-        clear_old_aggregates
-        calculate
-      else
-        retrieve || calculate
+      def amount(force_recalculation = false)
+        if force_recalculation
+          clear_old_aggregates
+          calculate
+        else
+          retrieve || calculate
+        end
       end
-    end
 
-    def formatted_amount(amount = amount)
-      amount ||= 0
-      if function == "count"
-        amount
-      else
-        Money.new(amount, currency)
+      def formatted_amount(value = amount())
+        value ||= 0
+        if function == 'count'
+          value
+        else
+          Money.new(value, currency)
+        end
       end
-    end
 
     private
 
-    def retrieve
-      aggregate = LineAggregate.where(field_hash).first
-      aggregate.amount if aggregate
-    end
-
-    def clear_old_aggregates
-      LineAggregate.delete_all(field_hash)
-    end
-
-    def calculate
-      if range.class == YearRange
-        aggregate = calculate_yearly_aggregate
-      else
-        aggregate = LineAggregate.aggregate(function, account, code, range, filter)
+      def retrieve
+        aggregate = LineAggregate.where(field_hash).first
+        aggregate.amount if aggregate
       end
 
-      if range_is_complete?
-        fields = field_hash
-        fields[:amount] = aggregate || 0
-        LineAggregate.create! fields
+      def clear_old_aggregates
+        LineAggregate.delete_all(field_hash)
       end
 
-      aggregate
-    end
+      def calculate
+        if range.class == YearRange
+          aggregate = calculate_yearly_aggregate
+        else
+          aggregate = LineAggregate.aggregate(function, account, code, range, filter)
+        end
 
-    def calculate_yearly_aggregate
-      # We calculate yearly aggregates by combining monthly aggregates
-      # otherwise they will get excruciatingly slow to calculate
-      # as the year progresses.  (I am thinking mainly of the 'current' year.)
-      # Combining monthly aggregates will mean that the figure will be partially memoized
-      if function == "average"
-        calculate_yearly_average
-      else
-        zero = formatted_amount(0)
-        result = (1..12).inject(zero) do |total, month|
-          total += Reporting.aggregate(
-            function, account, code,
-            :range => MonthRange.new(:year => range.year, :month => month),
-            :filter => filter,
-          )
+        if range_is_complete?
+          fields = field_hash
+          fields[:amount] = aggregate || 0
+          LineAggregate.create! fields
         end
-        result.is_a?(Money) ? result.cents : result
+
+        aggregate
       end
-    end
 
-    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 = Reporting.aggregate(:sum, account, code, :range => year_range, :filter => filter)
-      count = Reporting.aggregate(:count, account, code, :range => year_range, :filter => filter)
-      (count == 0) ? 0 : (sum / count).cents
-    end
+      def calculate_yearly_aggregate
+        # We calculate yearly aggregates by combining monthly aggregates
+        # otherwise they will get excruciatingly slow to calculate
+        # as the year progresses.  (I am thinking mainly of the 'current' year.)
+        # Combining monthly aggregates will mean that the figure will be partially memoized
+        if function == 'average'
+          calculate_yearly_average
+        else
+          zero = formatted_amount(0)
+          result = (1..12).inject(zero) do |total, month|
+            total + Reporting.aggregate(
+              function,
+              account,
+              code,
+              :range => MonthRange.new(:year => range.year, :month => month),
+              :filter => filter,
+            )
+          end
+          result.is_a?(Money) ? result.cents : result
+        end
+      end
 
-    def range_is_complete?
-      Time.now > range.finish
-    end
+      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 = Reporting.aggregate(:sum, account, code, :range => year_range, :filter => filter)
+        count = Reporting.aggregate(:count, account, code, :range => year_range, :filter => filter)
+        (count == 0) ? 0 : (sum / count).cents
+      end
 
-    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
-      }
+      def range_is_complete?
+        Time.now > range.finish
+      end
+
+      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,
+        }
+      end
     end
   end
- end
 end