double_entry 1.0.1 → 2.0.0.beta5

data/lib/double_entry/account.rb

@@ -1,93 +1,86 @@
 # encoding: utf-8
+require 'forwardable'
+
 module DoubleEntry
   class Account
     class << self
-      attr_writer :accounts, :scope_identifier_max_length, :account_identifier_max_length
+      attr_accessor :scope_identifier_max_length, :account_identifier_max_length
+      attr_writer :accounts
 
       # @api private
       def accounts
         @accounts ||= Set.new
       end
 
-      # @api private
-      def scope_identifier_max_length
-        @scope_identifier_max_length ||= 23
-      end
-
-      # @api private
-      def account_identifier_max_length
-        @account_identifier_max_length ||= 31
-      end
-
       # @api private
       def account(identifier, options = {})
-        account = accounts.find(identifier, options[:scope].present?)
-        Instance.new(:account => account, :scope => options[:scope])
+        account = accounts.find(identifier, (options[:scope].present? || options[:scope_identity].present?))
+        Instance.new(account: account, scope: options[:scope], scope_identity: options[:scope_identity])
       end
 
       # @api private
       def currency(identifier)
-        accounts.detect { |a| a.identifier == identifier }.try(:currency)
+        accounts.find_without_scope(identifier).try(:currency)
       end
     end
 
     # @api private
-    class Set < Array
+    class Set
+      extend Forwardable
+
+      delegate [:each, :map] => :all
+
       def define(attributes)
-        self << Account.new(attributes)
+        Account.new(attributes).tap do |account|
+          if find_without_scope(account.identifier)
+            fail DuplicateAccount
+          else
+            backing_collection[account.identifier] = account
+          end
+        end
       end
 
       def find(identifier, scoped)
-        found_account = detect do |account|
-          account.identifier == identifier && account.scoped? == scoped
-        end
-        fail UnknownAccount, "account: #{identifier} scoped?: #{scoped}" unless found_account
-        found_account
-      end
+        found_account = find_without_scope(identifier)
 
-      def <<(account)
-        if any? { |a| a.identifier == account.identifier }
-          fail DuplicateAccount
+        if found_account && found_account.scoped? == scoped
+          found_account
         else
-          super
+          fail UnknownAccount, "account: #{identifier} scoped?: #{scoped}"
         end
       end
 
-      def active_record_scope_identifier(active_record_class)
-        ActiveRecordScopeFactory.new(active_record_class).scope_identifier
+      def find_without_scope(identifier)
+        backing_collection[identifier]
       end
-    end
 
-    class ActiveRecordScopeFactory
-      def initialize(active_record_class)
-        @active_record_class = active_record_class
+      def all
+        backing_collection.values
       end
 
-      def scope_identifier
-        lambda do |value|
-          case value
-          when @active_record_class
-            value.id
-          when String, Fixnum
-            value
-          else
-            fail AccountScopeMismatchError, "Expected instance of `#{@active_record_class}`, received instance of `#{value.class}`"
-          end
-        end
+    private
+
+      def backing_collection
+        @backing_collection ||= Hash.new
       end
     end
 
     class Instance
       attr_reader :account, :scope
-      delegate :identifier, :scope_identifier, :scoped?, :positive_only, :negative_only, :currency, :to => :account
+      delegate :identifier, :scope_identifier, :scoped?, :positive_only, :negative_only, :currency, to: :account
 
       def initialize(args)
         @account = args[:account]
         @scope = args[:scope]
+        @scope_identity = args[:scope_identity]
         ensure_scope_is_valid
       end
 
       def scope_identity
+        @scope_identity || call_scope_identifier
+      end
+
+      def call_scope_identifier
         scope_identifier.call(scope).to_s if scoped?
       end
 
@@ -138,7 +131,7 @@ module DoubleEntry
 
       def ensure_scope_is_valid
         identity = scope_identity
-        if identity && identity.length > Account.scope_identifier_max_length
+        if identity && Account.scope_identifier_max_length && identity.length > Account.scope_identifier_max_length
           fail ScopeIdentifierTooLongError,
                "scope identifier '#{identity}' is too long. Please limit it to #{Account.scope_identifier_max_length} characters."
         end
@@ -153,7 +146,7 @@ module DoubleEntry
       @positive_only = args[:positive_only]
       @negative_only = args[:negative_only]
       @currency = args[:currency] || Money.default_currency
-      if identifier.length > Account.account_identifier_max_length
+      if Account.account_identifier_max_length && identifier.length > Account.account_identifier_max_length
         fail AccountIdentifierTooLongError,
              "account identifier '#{identifier}' is too long. Please limit it to #{Account.account_identifier_max_length} characters."
       end

data/lib/double_entry/account_balance.rb

@@ -8,7 +8,7 @@ module DoubleEntry
   #
   # Account balances are created on demand when transfers occur.
   class AccountBalance < ActiveRecord::Base
-    delegate :currency, :to => :account
+    delegate :currency, to: :account
 
     def balance
       self[:balance] && Money.new(self[:balance], currency)
@@ -25,13 +25,30 @@ module DoubleEntry
     end
 
     def account
-      DoubleEntry.account(self[:account].to_sym, :scope => self[:scope])
+      DoubleEntry.account(self[:account].to_sym, scope_identity: self[:scope])
     end
 
     def self.find_by_account(account, options = {})
-      scope = where(:scope => account.scope_identity, :account => account.identifier.to_s)
+      scope = where(scope: account.scope_identity, account: account.identifier.to_s)
       scope = scope.lock(true) if options[:lock]
       scope.first
     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::AccountBalance.scopes_with_minimum_balance_for_account(
+    #     1_000_000.dollars,
+    #     :savings,
+    #   ) # 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
+    # @return [Array<String>] Scopes
+    #
+    def self.scopes_with_minimum_balance_for_account(minimum_balance, account_identifier)
+      where(account: account_identifier).where('balance >= ?', minimum_balance.fractional).pluck(:scope)
+    end
   end
 end

data/lib/double_entry/balance_calculator.rb

@@ -79,18 +79,18 @@ module DoubleEntry
     # @api private
     class RelationBuilder
       attr_reader :options
-      delegate :account, :scope, :scope?, :from, :to, :between?, :at, :at?, :codes, :code?, :to => :options
+      delegate :account, :scope, :scope?, :from, :to, :between?, :at, :at?, :codes, :code?, to: :options
 
       def initialize(options)
         @options = options
       end
 
       def build
-        lines = Line.where(:account => account)
+        lines = Line.where(account: account)
         lines = lines.where('created_at <= ?', at) if at?
-        lines = lines.where(:created_at => from..to) if between?
-        lines = lines.where(:code => codes) if code?
-        lines = lines.where(:scope => scope) if scope?
+        lines = lines.where(created_at: from..to) if between?
+        lines = lines.where(code: codes) if code?
+        lines = lines.where(scope: scope) if scope?
         lines
       end
     end

data/lib/double_entry/configurable.rb

@@ -41,6 +41,7 @@ module DoubleEntry
       def configuration
         @configuration ||= self::Configuration.new
       end
+      alias config configuration
 
       def configure
         yield(configuration)

data/lib/double_entry/configuration.rb

@@ -3,6 +3,12 @@ module DoubleEntry
   include Configurable
 
   class Configuration
+    attr_accessor :json_metadata
+
+    def initialize
+      @json_metadata = false
+    end
+
     delegate(
       :accounts,
       :accounts=,
@@ -10,7 +16,7 @@ module DoubleEntry
       :scope_identifier_max_length=,
       :account_identifier_max_length,
       :account_identifier_max_length=,
-      :to => 'DoubleEntry::Account',
+      to: 'DoubleEntry::Account',
     )
 
     delegate(
@@ -18,7 +24,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

@@ -1,16 +1,16 @@
 # encoding: utf-8
 module DoubleEntry
-  class UnknownAccount < RuntimeError; end
-  class AccountIdentifierTooLongError < RuntimeError; end
-  class ScopeIdentifierTooLongError < RuntimeError; end
-  class TransferNotAllowed < RuntimeError; end
-  class TransferIsNegative < RuntimeError; end
-  class TransferCodeTooLongError < RuntimeError; end
-  class DuplicateAccount < RuntimeError; end
-  class DuplicateTransfer < RuntimeError; end
-  class AccountWouldBeSentNegative < RuntimeError; end
-  class AccountWouldBeSentPositiveError < RuntimeError; end
-  class MismatchedCurrencies < RuntimeError; end
-  class MissingAccountError < RuntimeError; end
-  class AccountScopeMismatchError < RuntimeError; end
+  class DoubleEntryError < RuntimeError; end
+  class UnknownAccount < DoubleEntryError; end
+  class AccountIdentifierTooLongError < DoubleEntryError; end
+  class ScopeIdentifierTooLongError < DoubleEntryError; end
+  class TransferNotAllowed < DoubleEntryError; end
+  class TransferIsNegative < DoubleEntryError; end
+  class TransferCodeTooLongError < DoubleEntryError; end
+  class DuplicateAccount < DoubleEntryError; end
+  class DuplicateTransfer < DoubleEntryError; end
+  class AccountWouldBeSentNegative < DoubleEntryError; end
+  class AccountWouldBeSentPositiveError < DoubleEntryError; end
+  class MismatchedCurrencies < DoubleEntryError; end
+  class MissingAccountError < DoubleEntryError; end
 end

data/lib/double_entry/line.rb

@@ -55,8 +55,9 @@ module DoubleEntry
   # by account, or account and code, over a particular period.
   #
   class Line < ActiveRecord::Base
-    belongs_to :detail, :polymorphic => true
-    has_many :metadata, :class_name => 'DoubleEntry::LineMetadata'
+    belongs_to :detail, polymorphic: true, required: false
+    has_many :metadata, class_name: 'DoubleEntry::LineMetadata' unless -> { DoubleEntry.config.json_metadata }
+    scope :with_id_greater_than, ->(id) { where('id > ?', id) }
 
     def amount
       self[:amount] && Money.new(self[:amount], currency)
@@ -74,12 +75,12 @@ module DoubleEntry
       self[:balance] = (money && money.fractional)
     end
 
-    def save(*)
+    def save(**)
       check_balance_will_remain_valid
       super
     end
 
-    def save!(*)
+    def save!(**)
       check_balance_will_remain_valid
       super
     end
@@ -101,7 +102,7 @@ module DoubleEntry
     end
 
     def account
-      DoubleEntry.account(self[:account].to_sym, :scope => scope)
+      DoubleEntry.account(self[:account].to_sym, scope_identity: scope)
     end
 
     def currency
@@ -116,7 +117,7 @@ module DoubleEntry
     end
 
     def partner_account
-      DoubleEntry.account(self[:partner_account].to_sym, :scope => partner_scope)
+      DoubleEntry.account(self[:partner_account].to_sym, scope_identity: partner_scope)
     end
 
     def partner

data/lib/double_entry/locking.rb

@@ -32,14 +32,14 @@ module DoubleEntry
     #
     # The transaction must be the outermost transaction to ensure data integrity. A
     # LockMustBeOutermostTransaction will be raised if it isn't.
-    def self.lock_accounts(*accounts)
+    def self.lock_accounts(*accounts, &block)
       lock = Lock.new(accounts)
 
       if lock.in_a_locked_transaction?
         lock.ensure_locked!
-        yield
+        block.call
       else
-        lock.perform_lock(&Proc.new)
+        lock.perform_lock(&block)
       end
 
     rescue ActiveRecord::StatementInvalid => exception
@@ -149,7 +149,7 @@ 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).
@@ -168,7 +168,7 @@ module DoubleEntry
           # Get the initial balance from the lines table.
           balance = account.balance
           # Try to create the balance record, but ignore it if someone else has done it in the meantime.
-          AccountBalance.create_ignoring_duplicates!(:account => account, :balance => balance)
+          AccountBalance.create_ignoring_duplicates!(account: account, balance: balance)
         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
@@ -84,12 +88,12 @@ module DoubleEntry
         fail MismatchedCurrencies, "Mismatched currency (#{to_account.currency} <> #{from_account.currency})"
       end
       Locking.lock_accounts(from_account, to_account) do
-        credit, debit = create_lines(amount, code, detail, from_account, to_account)
-        create_line_metadata(credit, debit, metadata) if metadata
+        credit, debit = create_lines(amount, code, detail, from_account, to_account, metadata)
+        create_line_metadata(credit, debit, metadata) if metadata && !DoubleEntry.config.json_metadata
       end
     end
 
-    def create_lines(amount, code, detail, from_account, to_account)
+    def create_lines(amount, code, detail, from_account, to_account, metadata)
       credit, debit = Line.new, Line.new
 
       credit_balance = Locking.balance_for_locked_account(from_account)
@@ -103,6 +107,7 @@ module DoubleEntry
       credit.code, debit.code       = code, code
       credit.detail, debit.detail   = detail, detail
       credit.balance, debit.balance = credit_balance.balance, debit_balance.balance
+      credit.metadata, debit.metadata = metadata, metadata if DoubleEntry.config.json_metadata
 
       credit.partner_account, debit.partner_account = to_account, from_account
 
@@ -115,8 +120,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