plutus 0.11.0 → 0.16

data/app/models/plutus/amount.rb

@@ -12,22 +12,13 @@ module Plutus
     validates_presence_of :type, :amount, :entry, :account
     # attr_accessible :account, :account_name, :amount, :entry
 
+    delegate :name, to: :account, prefix: true, allow_nil: true
+
     # Assign an account by name
     def account_name=(name)
       self.account = Account.find_by_name!(name)
     end
 
     protected
-
-    # Support constructing amounts with account = "name" syntax
-    def account_with_name_lookup=(v)
-      if v.kind_of?(String)
-        ActiveSupport::Deprecation.warn('Plutus was given an :account String (use account_name instead)', caller)
-        self.account_name = v
-      else
-        self.account_without_name_lookup = v
-      end
-    end
-    alias_method_chain :account=, :name_lookup
   end
 end

data/app/models/plutus/amounts_extension.rb

@@ -2,13 +2,38 @@ module Plutus
   # Association extension for has_many :amounts relations. Internal.
   module AmountsExtension
     # Returns a sum of the referenced Amount objects.
-    def balance
-      balance = BigDecimal.new('0')
+    #
+    # Takes a hash specifying :from_date and :to_date for calculating balances during periods.
+    # :from_date and :to_date may be strings of the form "yyyy-mm-dd" or Ruby Date objects
+    #
+    # This runs the summation in the database, so it only works on persisted records.
+    #
+    # @example
+    #   credit_amounts.balance({:from_date => "2000-01-01", :to_date => Date.today})
+    #   => #<BigDecimal:103259bb8,'0.2E4',4(12)>
+    #
+    # @return [BigDecimal] The decimal value balance
+    def balance(hash={})
+      if hash[:from_date] && hash[:to_date]
+        from_date = hash[:from_date].kind_of?(Date) ? hash[:from_date] : Date.parse(hash[:from_date])
+        to_date = hash[:to_date].kind_of?(Date) ? hash[:to_date] : Date.parse(hash[:to_date])
+        includes(:entry).where('plutus_entries.date' => from_date..to_date).sum(:amount)
+      else
+        sum(:amount)
+      end
+    end
+
+    # Returns a sum of the referenced Amount objects.
+    #
+    # This is used primarly in the validation step in Plutus::Entry
+    # in order to ensure that the debit and credits are canceling out.
+    #
+    # Since this does not use the database for sumation, it may be used on non-persisted records.
+    def balance_for_new_record
+      balance = BigDecimal('0')
       each do |amount_record|
-        if amount_record.amount
-          balance += amount_record.amount
-        else
-          balance = nil
+        if amount_record.amount && !amount_record.marked_for_destruction?
+          balance += amount_record.amount # unless amount_record.marked_for_destruction?
         end
       end
       return balance

data/app/models/plutus/asset.rb

@@ -7,24 +7,29 @@ module Plutus
   # @see http://en.wikipedia.org/wiki/Asset Assets
   #
   # @author Michael Bulat
-  class Asset < Account
+  class Asset < Plutus::Account
+
+    self.normal_credit_balance = false
 
     # The balance of the account.
     #
     # Assets have normal debit balances, so the credits are subtracted from the debits
     # unless this is a contra account, in which debits are subtracted from credits
     #
+    # Takes an optional hash specifying :from_date and :to_date for calculating balances during periods.
+    # :from_date and :to_date may be strings of the form "yyyy-mm-dd" or Ruby Date objects
+    #
+    # @example
+    #   >> asset.balance({:from_date => "2000-01-01", :to_date => Date.today})
+    #   => #<BigDecimal:103259bb8,'0.1E4',4(12)>
+    #
     # @example
     #   >> asset.balance
     #   => #<BigDecimal:103259bb8,'0.2E4',4(12)>
     #
     # @return [BigDecimal] The decimal value balance
-    def balance
-      unless contra
-        debits_balance - credits_balance
-      else
-        credits_balance - debits_balance
-      end
+    def balance(options={})
+      super(options)
     end
 
     # This class method is used to return
@@ -32,22 +37,20 @@ module Plutus
     #
     # Contra accounts are automatically subtracted from the balance.
     #
+    # Takes an optional hash specifying :from_date and :to_date for calculating balances during periods.
+    # :from_date and :to_date may be strings of the form "yyyy-mm-dd" or Ruby Date objects
+    #
+    # @example
+    #   >> Plutus::Asset.balance({:from_date => "2000-01-01", :to_date => Date.today})
+    #   => #<BigDecimal:103259bb8,'0.1E4',4(12)>
+    #
     # @example
     #   >> Plutus::Asset.balance
     #   => #<BigDecimal:1030fcc98,'0.82875E5',8(20)>
     #
     # @return [BigDecimal] The decimal value balance
-    def self.balance
-      accounts_balance = BigDecimal.new('0')
-      accounts = self.all
-      accounts.each do |asset|
-        unless asset.contra
-          accounts_balance += asset.balance
-        else
-          accounts_balance -= asset.balance
-        end
-      end
-      accounts_balance
+    def self.balance(options={})
+      super(options)
     end
   end
 end

data/app/models/plutus/entry.rb

@@ -22,7 +22,14 @@ module Plutus
   #
   # @author Michael Bulat
   class Entry < ActiveRecord::Base
-    belongs_to :commercial_document, :polymorphic => true
+    before_save :default_date
+
+    if ActiveRecord::VERSION::MAJOR > 4
+      belongs_to :commercial_document, :polymorphic => true, optional: true
+    else
+      belongs_to :commercial_document, :polymorphic => true
+    end
+
     has_many :credit_amounts, :extend => AmountsExtension, :class_name => 'Plutus::CreditAmount', :inverse_of => :entry
     has_many :debit_amounts, :extend => AmountsExtension, :class_name => 'Plutus::DebitAmount', :inverse_of => :entry
     has_many :credit_accounts, :through => :credit_amounts, :source => :account, :class_name => 'Plutus::Account'
@@ -34,7 +41,7 @@ module Plutus
     validate :amounts_cancel?
 
     # Support construction using 'credits' and 'debits' keys
-    accepts_nested_attributes_for :credit_amounts, :debit_amounts
+    accepts_nested_attributes_for :credit_amounts, :debit_amounts, allow_destroy: true
     alias_method :credits=, :credit_amounts_attributes=
     alias_method :debits=, :debit_amounts_attributes=
     # attr_accessible :credits, :debits
@@ -50,6 +57,11 @@ module Plutus
     end
 
     private
+      def default_date
+        todays_date = ActiveRecord::Base.default_timezone == :utc ? Time.now.utc : Time.now
+        self.date ||= todays_date
+      end
+
       def has_credit_amounts?
         errors[:base] << "Entry must have at least one credit amount" if self.credit_amounts.blank?
       end
@@ -59,7 +71,7 @@ module Plutus
       end
 
       def amounts_cancel?
-        errors[:base] << "The credit and debit amounts are not equal" if credit_amounts.balance != debit_amounts.balance
+        errors[:base] << "The credit and debit amounts are not equal" if credit_amounts.balance_for_new_record != debit_amounts.balance_for_new_record
       end
   end
 end

data/app/models/plutus/equity.rb

@@ -7,24 +7,29 @@ module Plutus
   # @see http://en.wikipedia.org/wiki/Equity_(finance) Equity
   #
   # @author Michael Bulat
-  class Equity < Account
+  class Equity < Plutus::Account
+
+    self.normal_credit_balance = true
 
     # The balance of the account.
     #
     # Equity accounts have normal credit balances, so the debits are subtracted from the credits
     # unless this is a contra account, in which credits are subtracted from debits
     #
+    # Takes an optional hash specifying :from_date and :to_date for calculating balances during periods.
+    # :from_date and :to_date may be strings of the form "yyyy-mm-dd" or Ruby Date objects
+    #
+    # @example
+    #   >> equity.balance({:from_date => "2000-01-01", :to_date => Date.today})
+    #   => #<BigDecimal:103259bb8,'0.1E4',4(12)>
+    #
     # @example
-    #   >> asset.balance
+    #   >> equity.balance
     #   => #<BigDecimal:103259bb8,'0.2E4',4(12)>
     #
     # @return [BigDecimal] The decimal value balance
-    def balance
-      unless contra
-        credits_balance - debits_balance
-      else
-        debits_balance - credits_balance
-      end
+    def balance(options={})
+      super
     end
 
     # This class method is used to return
@@ -32,22 +37,20 @@ module Plutus
     #
     # Contra accounts are automatically subtracted from the balance.
     #
+    # Takes an optional hash specifying :from_date and :to_date for calculating balances during periods.
+    # :from_date and :to_date may be strings of the form "yyyy-mm-dd" or Ruby Date objects
+    #
+    # @example
+    #   >> Plutus::Equity.balance({:from_date => "2000-01-01", :to_date => Date.today})
+    #   => #<BigDecimal:103259bb8,'0.1E4',4(12)>
+    #
     # @example
     #   >> Plutus::Equity.balance
     #   => #<BigDecimal:1030fcc98,'0.82875E5',8(20)>
     #
     # @return [BigDecimal] The decimal value balance
-    def self.balance
-      accounts_balance = BigDecimal.new('0')
-      accounts = self.all
-      accounts.each do |equity|
-        unless equity.contra
-          accounts_balance += equity.balance
-        else
-          accounts_balance -= equity.balance
-        end
-      end
-      accounts_balance
+    def self.balance(options={})
+      super
     end
   end
 end

data/app/models/plutus/expense.rb

@@ -7,24 +7,29 @@ module Plutus
   # @see http://en.wikipedia.org/wiki/Expense Expenses
   #
   # @author Michael Bulat
-  class Expense < Account
+  class Expense < Plutus::Account
+
+    self.normal_credit_balance = false
 
     # The balance of the account.
     #
     # Expenses have normal debit balances, so the credits are subtracted from the debits
     # unless this is a contra account, in which debits are subtracted from credits
     #
+    # Takes an optional hash specifying :from_date and :to_date for calculating balances during periods.
+    # :from_date and :to_date may be strings of the form "yyyy-mm-dd" or Ruby Date objects
+    #
+    # @example
+    #   >> expense.balance({:from_date => "2000-01-01", :to_date => Date.today})
+    #   => #<BigDecimal:103259bb8,'0.1E4',4(12)>
+    #
     # @example
     #   >> expense.balance
     #   => #<BigDecimal:103259bb8,'0.2E4',4(12)>
     #
     # @return [BigDecimal] The decimal value balance
-    def balance
-      unless contra
-        debits_balance - credits_balance
-      else
-        credits_balance - debits_balance
-      end
+    def balance(options={})
+      super
     end
 
     # This class method is used to return
@@ -32,22 +37,20 @@ module Plutus
     #
     # Contra accounts are automatically subtracted from the balance.
     #
+    # Takes an optional hash specifying :from_date and :to_date for calculating balances during periods.
+    # :from_date and :to_date may be strings of the form "yyyy-mm-dd" or Ruby Date objects
+    #
+    # @example
+    #   >> Plutus::Expense.balance({:from_date => "2000-01-01", :to_date => Date.today})
+    #   => #<BigDecimal:103259bb8,'0.1E4',4(12)>
+    #
     # @example
     #   >> Plutus::Expense.balance
     #   => #<BigDecimal:1030fcc98,'0.82875E5',8(20)>
     #
     # @return [BigDecimal] The decimal value balance
-    def self.balance
-      accounts_balance = BigDecimal.new('0')
-      accounts = self.all
-      accounts.each do |expense|
-        unless expense.contra
-          accounts_balance += expense.balance
-        else
-          accounts_balance -= expense.balance
-        end
-      end
-      accounts_balance
+    def self.balance(options={})
+      super
     end
   end
 end

data/app/models/plutus/liability.rb

@@ -7,42 +7,50 @@ module Plutus
   # @see http://en.wikipedia.org/wiki/Liability_(financial_accounting) Liability
   #
   # @author Michael Bulat
-  class Liability < Account
+  class Liability < Plutus::Account
+
+    self.normal_credit_balance = true
 
     # The balance of the account.
     #
     # Liability accounts have normal credit balances, so the debits are subtracted from the credits
     # unless this is a contra account, in which credits are subtracted from debits
     #
+    # Takes an optional hash specifying :from_date and :to_date for calculating balances during periods.
+    # :from_date and :to_date may be strings of the form "yyyy-mm-dd" or Ruby Date objects
+    #
+    # @example
+    #   >> liability.balance({:from_date => "2000-01-01", :to_date => Date.today})
+    #   => #<BigDecimal:103259bb8,'0.1E4',4(12)>
+    #
     # @example
     #   >> liability.balance
     #   => #<BigDecimal:103259bb8,'0.2E4',4(12)>
     #
     # @return [BigDecimal] The decimal value balance
-    def balance
-      unless contra
-        credits_balance - debits_balance
-      else
-        debits_balance - credits_balance
-      end
+    def balance(options={})
+      super
     end
 
-    # Balance of all Liability accounts
+    # This class method is used to return
+    # the balance of all Liability accounts.
+    #
+    # Contra accounts are automatically subtracted from the balance.
+    #
+    # Takes an optional hash specifying :from_date and :to_date for calculating balances during periods.
+    # :from_date and :to_date may be strings of the form "yyyy-mm-dd" or Ruby Date objects
+    #
+    # @example
+    #   >> Plutus::Liability.balance({:from_date => "2000-01-01", :to_date => Date.today})
+    #   => #<BigDecimal:103259bb8,'0.1E4',4(12)>
     #
     # @example
     #   >> Plutus::Liability.balance
     #   => #<BigDecimal:1030fcc98,'0.82875E5',8(20)>
-    def self.balance
-      accounts_balance = BigDecimal.new('0')
-      accounts = self.all
-      accounts.each do |liability|
-        unless liability.contra
-          accounts_balance += liability.balance
-        else
-          accounts_balance -= liability.balance
-        end
-      end
-      accounts_balance
+    #
+    # @return [BigDecimal] The decimal value balance
+    def self.balance(options={})
+      super
     end
   end
 end

data/app/models/plutus/revenue.rb

@@ -7,24 +7,29 @@ module Plutus
   # @see http://en.wikipedia.org/wiki/Revenue Revenue
   #
   # @author Michael Bulat
-  class Revenue < Account
+  class Revenue < Plutus::Account
+
+    self.normal_credit_balance = true
 
     # The balance of the account.
     #
     # Revenue accounts have normal credit balances, so the debits are subtracted from the credits
     # unless this is a contra account, in which credits are subtracted from debits
     #
+    # Takes an optional hash specifying :from_date and :to_date for calculating balances during periods.
+    # :from_date and :to_date may be strings of the form "yyyy-mm-dd" or Ruby Date objects
+    #
+    # @example
+    #   >> revenue.balance({:from_date => "2000-01-01", :to_date => Date.today})
+    #   => #<BigDecimal:103259bb8,'0.1E4',4(12)>
+    #
     # @example
-    #   >> asset.balance
+    #   >> revenue.balance
     #   => #<BigDecimal:103259bb8,'0.2E4',4(12)>
     #
     # @return [BigDecimal] The decimal value balance
-    def balance
-      unless contra
-        credits_balance - debits_balance
-      else
-        debits_balance - credits_balance
-      end
+    def balance(options={})
+      super
     end
 
     # This class method is used to return
@@ -32,22 +37,20 @@ module Plutus
     #
     # Contra accounts are automatically subtracted from the balance.
     #
+    # Takes an optional hash specifying :from_date and :to_date for calculating balances during periods.
+    # :from_date and :to_date may be strings of the form "yyyy-mm-dd" or Ruby Date objects
+    #
+    # @example
+    #   >> Plutus::Revenue.balance({:from_date => "2000-01-01", :to_date => Date.today})
+    #   => #<BigDecimal:103259bb8,'0.1E4',4(12)>
+    #
     # @example
     #   >> Plutus::Revenue.balance
     #   => #<BigDecimal:1030fcc98,'0.82875E5',8(20)>
     #
     # @return [BigDecimal] The decimal value balance
-    def self.balance
-      accounts_balance = BigDecimal.new('0')
-      accounts = self.all
-      accounts.each do |revenue|
-        unless revenue.contra
-          accounts_balance += revenue.balance
-        else
-          accounts_balance -= revenue.balance
-        end
-      end
-      accounts_balance
+    def self.balance(options={})
+      super
     end
   end
 end