double_entry 1.0.1 → 2.0.0.beta1

data/double_entry.gemspec

@@ -1,4 +1,4 @@
-# encoding: utf-8
+
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
@@ -7,67 +7,39 @@ require 'double_entry/version'
 Gem::Specification.new do |gem|
   gem.name                  = 'double_entry'
   gem.version               = DoubleEntry::VERSION
-  gem.authors               = ['Anthony Sellitti', 'Keith Pitt', 'Martin Jagusch', 'Martin Spickermann', 'Mark Turnley', 'Orien Madgwick', 'Pete Yandall', 'Stephanie Staub', 'Giancarlo Salamanca']
-  gem.email                 = ['anthony.sellitti@envato.com', 'me@keithpitt.com', '_@mj.io', 'spickemann@gmail.com', 'mark@envato.com', '_@orien.io', 'pete@envato.com', 'staub.steph@gmail.com', 'giancarlo@salamanca.net.au']
+  gem.authors               = ['Envato']
+  gem.email                 = ['rubygems@envato.com']
   gem.summary               = 'Tools to build your double entry financial ledger'
   gem.homepage              = 'https://github.com/envato/double_entry'
 
-  gem.files                 = `git ls-files`.split($/)
-  gem.executables           = gem.files.grep(%r{bin/}).map { |f| File.basename(f) }
-  gem.test_files            = gem.files.grep(%r{^(test|spec|features)/})
-  gem.require_paths         = ['lib']
-
-  gem.post_install_message = <<-'POSTINSTALLMESSAGE'
-Please note the following changes in DoubleEntry:
- - New table `double_entry_line_metadata` has been introduced and is *required* for
-   aggregate reporting filtering to work. Existing applications must manually manage
-   this change via a migration similar to the following:
-
-    class CreateDoubleEntryLineMetadata < ActiveRecord::Migration
-      def self.up
-        create_table "#{DoubleEntry.table_name_prefix}line_metadata", :force => true do |t|
-          t.integer    "line_id",               :null => false
-          t.string     "key",     :limit => 48, :null => false
-          t.string     "value",   :limit => 64, :null => false
-          t.timestamps                          :null => false
-        end
-
-        add_index "#{DoubleEntry.table_name_prefix}line_metadata",
-                  ["line_id", "key", "value"],
-                  :name => "lines_meta_line_id_key_value_idx"
-      end
+  gem.metadata = {
+    'bug_tracker_uri'   => 'https://github.com/envato/double_entry/issues',
+    'changelog_uri'     => 'https://github.com/envato/double_entry/blob/master/CHANGELOG.md',
+    'documentation_uri' => 'https://www.rubydoc.info/github/envato/double_entry/',
+    'source_code_uri'   => 'https://github.com/envato/double_entry',
+  }
 
-      def self.down
-        drop_table "#{DoubleEntry.table_name_prefix}line_metadata"
-      end
-    end
-
-  Please ensure that you update your database accordingly.
-POSTINSTALLMESSAGE
+  gem.files                 = `git ls-files -z`.split("\x0").select do |f|
+    f.match(%r{^(?:double_entry.gemspec|README|LICENSE|CHANGELOG|lib/)})
+  end
+  gem.require_paths         = ['lib']
+  gem.required_ruby_version = '>= 2.2.0'
 
-  gem.add_dependency 'money',                 '>= 6.0.0'
   gem.add_dependency 'activerecord',          '>= 3.2.0'
   gem.add_dependency 'activesupport',         '>= 3.2.0'
+  gem.add_dependency 'money',                 '>= 6.0.0'
   gem.add_dependency 'railties',              '>= 3.2.0'
 
-  gem.add_development_dependency 'rake'
   gem.add_development_dependency 'mysql2'
   gem.add_development_dependency 'pg'
+  gem.add_development_dependency 'rake'
   gem.add_development_dependency 'sqlite3'
 
-  gem.add_development_dependency 'rspec'
-  gem.add_development_dependency 'rspec-its'
-  gem.add_development_dependency 'rspec-instafail'
   gem.add_development_dependency 'database_cleaner'
+  gem.add_development_dependency 'factory_bot'
   gem.add_development_dependency 'generator_spec'
-  gem.add_development_dependency 'machinist'
-  gem.add_development_dependency 'timecop'
-  gem.add_development_dependency 'test-unit'
-
-  gem.add_development_dependency 'pry'
-  gem.add_development_dependency 'pry-doc'
-  gem.add_development_dependency 'pry-byebug'         if RUBY_VERSION >= '2.0.0'
-  gem.add_development_dependency 'pry-stack_explorer'
-  gem.add_development_dependency 'awesome_print'
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'rspec-its'
   gem.add_development_dependency 'ruby-prof'
+  gem.add_development_dependency 'timecop'
 end

data/lib/active_record/locking_extensions.rb

@@ -18,7 +18,7 @@ module ActiveRecord
       yield
     rescue ActiveRecord::StatementInvalid => exception
       if exception.message =~ /deadlock/i || exception.message =~ /database is locked/i
-        ActiveSupport::Notifications.publish('deadlock_restart.active_record', :exception => exception)
+        ActiveSupport::Notifications.publish('deadlock_restart.double_entry', :exception => exception)
 
         raise ActiveRecord::RestartTransaction
       else
@@ -46,7 +46,7 @@ module ActiveRecord
       yield
     rescue ActiveRecord::StatementInvalid, ActiveRecord::RecordNotUnique => exception
       if  exception.message =~ /duplicate/i || exception.message =~ /ConstraintException/
-        ActiveSupport::Notifications.publish('duplicate_ignore.active_record', :exception => exception)
+        ActiveSupport::Notifications.publish('duplicate_ignore.double_entry', :exception => exception)
 
         # Just ignore it...someone else has already created the record.
       else
@@ -63,7 +63,7 @@ module ActiveRecord
       if exception.message =~ /deadlock/i || exception.message =~ /database is locked/i
         # Somebody else is in the midst of creating the record. We'd better
         # retry, so we ensure they're done before we move on.
-        ActiveSupport::Notifications.publish('deadlock_retry.active_record', :exception => exception)
+        ActiveSupport::Notifications.publish('deadlock_retry.double_entry', :exception => exception)
 
         retry
       else

data/lib/active_record/locking_extensions/log_subscriber.rb

@@ -26,4 +26,4 @@ module ActiveRecord
   end
 end
 
-ActiveRecord::LockingExtensions::LogSubscriber.attach_to :active_record
+ActiveRecord::LockingExtensions::LogSubscriber.attach_to :double_entry

data/lib/double_entry/account.rb

@@ -1,79 +1,67 @@
 # 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
 
@@ -84,10 +72,15 @@ module DoubleEntry
       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

@@ -25,7 +25,7 @@ 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 = {})
@@ -33,5 +33,22 @@ module DoubleEntry
       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/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

@@ -57,6 +57,7 @@ module DoubleEntry
   class Line < ActiveRecord::Base
     belongs_to :detail, :polymorphic => true
     has_many :metadata, :class_name => 'DoubleEntry::LineMetadata'
+    scope :with_id_greater_than, ->(id) { where('id > ?', id) }
 
     def amount
       self[:amount] && Money.new(self[:amount], currency)
@@ -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/reporting.rb

@@ -9,6 +9,7 @@ require 'double_entry/reporting/month_range'
 require 'double_entry/reporting/year_range'
 require 'double_entry/reporting/line_aggregate'
 require 'double_entry/reporting/line_aggregate_filter'
+require 'double_entry/reporting/line_metadata_filter'
 require 'double_entry/reporting/time_range_array'
 
 module DoubleEntry
@@ -62,9 +63,12 @@ module DoubleEntry
     # @param [Symbol] code The application specific code for the type of
     #   transfer to perform an aggregate calculation on. As specified in the
     #   transfer configuration.
-    # @param [DoubleEntry::Reporting::TimeRange] Only include transfers in the
-    #   given time range in the calculation.
-    # @option options :filter [Array<Hash<Symbol,Hash<Symbol,Object>>>]
+    # @param [DoubleEntry::Reporting::TimeRange] range Only include transfers in
+    #   the given time range in the calculation.
+    # @param [Symbol] partner_account The symbol identifying the partner account
+    #   to perform the aggregate calculatoin on.  As specified in the account
+    #   configuration.
+    # @param [Array<Hash<Symbol,Hash<Symbol,Object>>>] filter
     #   An array of custom filter to apply before performing the aggregate
     #   calculation. Filters can be either scope filters, where the name must be
     #   specified, or they can be metadata filters, where the key/value pair to
@@ -73,13 +77,14 @@ module DoubleEntry
     #   class, as the example above shows. Scope filters may also take a list of
     #   arguments to pass into the monkey patched scope, and, if provided, must
     #   be contained within an array.
-    # @return [Money, Fixnum] Returns a Money object for :sum and :average
-    #   calculations, or a Fixnum for :count calculations.
+    # @return [Money, Integer] Returns a Money object for :sum and :average
+    #   calculations, or a Integer for :count calculations.
     # @raise [Reporting::AggregateFunctionNotSupported] The provided function
     #   is not supported.
     #
-    def aggregate(function, account, code, range, options = {})
-      Aggregate.formatted_amount(function, account, code, range, options)
+    def aggregate(function:, account:, code:, range:, partner_account: nil, filter: nil)
+      Aggregate.formatted_amount(function: function, account: account, code: code, range: range,
+                                 partner_account: partner_account, filter: filter)
     end
 
     # Perform an aggregate calculation on a set of transfers for an account
@@ -104,54 +109,37 @@ module DoubleEntry
     # @param [Symbol] code The application specific code for the type of
     #   transfer to perform an aggregate calculation on. As specified in the
     #   transfer configuration.
-    # @option options :filter [Array<Symbol>, Array<Hash<Symbol, Object>>]
+    # @param [Symbol] partner_account The symbol identifying the partner account
+    #   to perform the aggregative calculation on.  As specified in the account
+    #   configuration.
+    # @param [Array<Symbol>, Array<Hash<Symbol, Object>>] filter
     #   A custom filter to apply before performing the aggregate calculation.
     #   Currently, filters must be monkey patched as scopes into the
     #   DoubleEntry::Line class in order to be used as filters, as the example
     #   shows. If the filter requires a parameter, it must be given in a Hash,
     #   otherwise pass an array with the symbol names for the defined scopes.
-    # @option options :range_type [String] The type of time range to return data
-    #   for.  For example, specifying 'month' will return an array of the resulting
+    # @param [String] range_type The type of time range to return data
+    #   for. For example, specifying 'month' will return an array of the resulting
     #   aggregate calculation for each month.
     #   Valid range_types are 'hour', 'day', 'week', 'month', and 'year'
-    # @option options :start [String] The start date for the time range to perform
+    # @param [String] start The start date for the time range to perform
     #   calculations in.  The default start date is the start_of_business (can
     #   be specified in configuration).
     #   The format of the string must be as follows: 'YYYY-mm-dd'
-    # @option options :finish [String] The finish (or end) date for the time range
+    # @param [String] finish The finish (or end) date for the time range
     #   to perform calculations in.  The default finish date is the current date.
     #   The format of the string must be as follows: 'YYYY-mm-dd'
-    # @return [Array<Money, Fixnum>] Returns an array of Money objects for :sum
-    #   and :average calculations, or an array of Fixnum for :count calculations.
+    # @return [Array<Money, Integer>] Returns an array of Money objects for :sum
+    #   and :average calculations, or an array of Integer for :count calculations.
     #   The array is indexed by the range_type.  For example, if range_type is
     #   specified as 'month', each index in the array will represent a month.
     # @raise [Reporting::AggregateFunctionNotSupported] The provided function
     #   is not supported.
     #
-    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::Reporting.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<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(&:to_i)
-        SELECT scope
-          FROM #{AccountBalance.table_name}
-         WHERE account = ?
-           AND balance >= ?
-      SQL
+    def aggregate_array(function:, account:, code:, partner_account: nil, filter: nil,
+                        range_type: nil, start: nil, finish: nil)
+      AggregateArray.new(function: function, account: account, code: code, partner_account: partner_account,
+                         filter: filter, range_type: range_type, start: start, finish: finish)
     end
 
     # This is used by the concurrency test script.