borutus 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f0c526c5aff61f0ae1cf18cb178c35f83a21e41115084095c80c7f9a7062e34e
-  data.tar.gz: 3b482a97d3b010795f27ec03ef91015d2b8540c36185d394c2e92648ea297167
+  metadata.gz: 99c7e9b6c1428c39c6419f3899b8274f16529da5c764393c04212b322510ce32
+  data.tar.gz: be8481eb09396b05a8ec1c16333ed98458d76b64af964394a62705e33595ecea
 SHA512:
-  metadata.gz: 1d306a22f425827597905f4bdc519fde1c65830b9d011cebc12191adde8b39c864b1e410ac50ccb8f7c91052e3f90864efef0829b445fcccd944258000285f92
-  data.tar.gz: 44ec323985e18ac5f3b98d3a437da159557559188765366c04f00c31c1b8bafd78953fcd6fce62d4c3d544b7e0448d3fec584c3670d882f33d4ba03d0791f556
+  metadata.gz: fa81c5a98f4dcaa9d94b644bdc6af9e29ba2dd3cc219b68b4dbe69e74de96a65f7b92991173a44b31290c3966a4a3ed10265a4ca9787a88d39ffda15358c7f34
+  data.tar.gz: 6261072d1a25213b31d16a6a9e99b33d4c6279e8b9ca6e271fc410df85771ad45322acef1fa4790a2700e70cfb7134b71916144ff7ac3eac8d1331ad0ebae97a

data/README.md

@@ -45,11 +45,11 @@ The Account class represents accounts in the system. The Account table uses sing
 Your Book of Accounts needs to be created prior to recording any entries. The simplest method is to have a number of `create` methods in your db/seeds.rb file like so:
 
 ```ruby
-Borutus::Asset.create(:name => "Accounts Receivable")
-Borutus::Asset.create(:name => "Cash")
-Borutus::Revenue.create(:name => "Sales Revenue")
-Borutus::Liability.create(:name => "Unearned Revenue")
-Borutus::Liability.create(:name => "Sales Tax Payable")
+Borutus::Asset.create(name: "Accounts Receivable")
+Borutus::Asset.create(name: "Cash")
+Borutus::Revenue.create(name: "Sales Revenue")
+Borutus::Liability.create(name: "Unearned Revenue")
+Borutus::Liability.create(name: "Sales Tax Payable")
 ```
 
 Then simply run `rake db:seed`
@@ -57,7 +57,7 @@ Then simply run `rake db:seed`
 Each account can also be marked as a "Contra Account". A contra account will have its normal balance swapped. For example, to remove equity, a "Drawing" account may be created as a contra equity account as follows:
 
 ```ruby
-Borutus::Equity.create(:name => "Drawing", :contra => true)
+Borutus::Equity.create(name: "Drawing", contra: true)
 ```
 
 At all times the balance of all accounts should conform to the [Accounting
@@ -78,20 +78,19 @@ Recording an Entry
 Let's assume we're accounting on an [Accrual basis](http://en.wikipedia.org/wiki/Accounting_methods#Accrual_basis). We've just taken a customer's order for some widgets, which we've also billed him for. At this point we've actually added a liability to the company until we deliver the goods. To record this entry we'd need two accounts:
 
 ```ruby
->> Borutus::Asset.create(:name => "Cash")
->> Borutus::Liability.create(:name => "Unearned Revenue")
+>> Borutus::Asset.create(name: "Cash")
+>> Borutus::Liability.create(name: "Unearned Revenue")
 ```
 
 Next we'll build the entry we want to record. Borutus uses ActiveRecord conventions to build the transaction and its associated amounts.
 
 ```ruby
 entry = Borutus::Entry.new(
-                :description => "Order placed for widgets",
-                :date => Date.yesterday,
-                :debits => [
-                  {:account_name => "Cash", :amount => 100.00}],
-                :credits => [
-                  {:account_name => "Unearned Revenue", :amount => 100.00}])
+  description: "Order placed for widgets",
+  date: Date.yesterday,
+  debits: [{ account_name: "Cash", amount: 100.00 }],
+  credits: [{ account_name: "Unearned Revenue", amount: 100.00 }]
+)
 ```
 
 Entries must specify a description, as well as at least one credit and debit amount. Specifying the date is optional; by default, the current date will be assigned to the entry before the record is saved. `debits` and `credits` must specify an array of hashes, with an amount value as well as an account, either by providing a `Borutus::Account` to `account` or by passing in an `account_name` string.
@@ -110,21 +109,22 @@ Recording an Entry with multiple accounts
 Often times a single entry requires more than one type of account. A classic example would be a entry in which a tax is charged. We'll assume that we have not yet received payment for the order, so we'll need an "Accounts Receivable" Asset:
 
 ```ruby
->> Borutus::Asset.create(:name => "Accounts Receivable")
->> Borutus::Revenue.create(:name => "Sales Revenue")
->> Borutus::Liability.create(:name => "Sales Tax Payable")
+>> Borutus::Asset.create(name: "Accounts Receivable")
+>> Borutus::Revenue.create(name: "Sales Revenue")
+>> Borutus::Liability.create(name: "Sales Tax Payable")
 ```
 
 And here's the entry:
 
 ```ruby
 entry = Borutus::Entry.build(
-                :description => "Sold some widgets",
-                :debits => [
-                  {:account_name => "Accounts Receivable", :amount => 50}],
-                :credits => [
-                  {:account_name => "Sales Revenue", :amount => 45},
-                  {:account_name => "Sales Tax Payable", :amount => 5}])
+  description: "Sold some widgets",
+  debits: [{ account_name:  "Accounts Receivable", :amount:  50}],
+  credits: [
+    { account_name: "Sales Revenue", amount: 45},
+    { account_name: "Sales Tax Payable", amount: 5}
+  ]
+)
 entry.save
 ```
 
@@ -143,13 +143,13 @@ Let's assume we're using the same entry from the last example
 
 ```ruby
 entry = Borutus::Entry.new(
-                :description => "Sold some widgets",
-                :commercial_document => invoice,
-                :debits => [
-                  {:account_name => "Accounts Receivable", :amount => invoice.total_amount}],
-                :credits => [
-                  {:account_name => "Sales Revenue", :amount => invoice.sales_amount},
-                  {:account_name => "Sales Tax Payable", :amount => invoice.tax_amount}])
+  description: "Sold some widgets",
+  commercial_document: invoice,
+  debits: [
+    { account_name:  "Accounts Receivable", amount:  invoice.total_amount}],
+  credits: [
+    { account_name:  "Sales Revenue", amount:  invoice.sales_amount},
+    { account_name:  "Sales Tax Payable", amount:  invoice.tax_amount}])
 entry.save
 ```
 
@@ -170,7 +170,7 @@ The balance can also be calculated within a specified date range. Dates can be s
 
 ```ruby
 >> cash = Borutus::Asset.find_by_name("Cash")
->> cash.balance(:from_date => "2014-01-01", :to_date => Date.today)
+>> cash.balance(from_date: "2014-01-01", to_date: Date.today)
 => #<BigDecimal:103259bb8,'0.2E4',4(12)>
 ```
 
@@ -187,7 +187,7 @@ Each subclass of accounts can report on the total balance of all the accounts of
 Again, a date range can be given
 
 ```ruby
->> Borutus::Asset.balance(:from_date => "2014-01-01", :to_date => Date.today)
+>> Borutus::Asset.balance(from_date: "2014-01-01", to_date: Date.today)
 => #<BigDecimal:103259bb8,'0.2E4',4(12)>
 ```
 
@@ -211,38 +211,36 @@ For complex entries, you should always ensure that you are balancing your accoun
 For example, let's assume the owner of a business wants to withdraw cash. First we'll assume that we have an asset account for "Cash" which the funds will be drawn from. We'll then need an Equity account to record where the funds are going, however, in this case, we can't simply create a regular Equity account. The "Cash" account must be credited for the decrease in its balance since it's an Asset. Likewise, Equity accounts are typically credited when there is an increase in their balance. Equity is considered an owner's rights to Assets in the business. In this case however, we are not simply increasing the owner's rights to assets within the business; we are actually removing capital from the business altogether. Hence both sides of our accounting equation will see a decrease. In order to accomplish this, we need to create a Contra-Equity account we'll call "Drawings". Since Equity accounts normally have credit balances, a Contra-Equity account will have a debit balance, which is what we need for our entry.
 
 ```ruby
->> Borutus::Equity.create(:name => "Drawing", :contra => true)
->> Borutus::Asset.create(:name => "Cash")
+>> Borutus::Equity.create(name: "Drawing", contra: true)
+>> Borutus::Asset.create(name: "Cash")
 ```
 
 We would then create the following entry:
 
 ```ruby
 entry = Borutus::Entry.new(
-                :description => "Owner withdrawing cash",
-                :debits => [
-                  {:account_name => "Drawing", :amount => 1000}],
-                :credits => [
-                  {:account_name => "Cash", :amount => 1000}])
+  description:  "Owner withdrawing cash",
+  debits: [{ account_name: "Drawing", amount: 1000}],
+  credits: [{ account_name: "Cash", amount: 1000}],
+)
 entry.save
 ```
 
 To make the example clearer, imagine instead that the owner decides to invest his money into the business in exchange for some type of equity security. In this case we might have the following accounts:
 
 ```ruby
->> Borutus::Equity.create(:name => "Common Stock")
->> Borutus::Asset.create(:name => "Cash")
+>> Borutus::Equity.create(name: "Common Stock")
+>> Borutus::Asset.create(name: "Cash")
 ```
 
 And out entry would be:
 
 ```ruby
 entry = Borutus::Entry.new(
-                :description => "Owner investing cash",
-                :debits => [
-                  {:account_name => "Cash", :amount => 1000}],
-                :credits => [
-                  {:account_name => "Common Stock", :amount => 1000}])
+  description: "Owner investing cash",
+  debits: [{ account_name: "Cash", amount: 1000}],
+  credits: [{ account_name: "Common Stock", amount: 1000}]
+)
 entry.save
 ```
 
@@ -252,17 +250,16 @@ Equity, keeping everything balanced.
 Money & Currency Support
 ========================
 
-Borutus aims to be agnostic about the values used for amounts. All fields are maintained as BigDecimal values, with `:precision => 20, :scale => 10`, which means that any currency can be safely stored in the tables.
+Borutus aims to be agnostic about the values used for amounts. All fields are maintained as BigDecimal values, with `:precision:  20, :scale:  10`, which means that any currency can be safely stored in the tables.
 
 Borutus is also compatible with the [Money](https://github.com/RubyMoney/money) gem. With Money versions greater than 6.0, the `money.amount` will returns a BigDecimal which you can use with borutus as follows:
 
 ```ruby
 entry = Borutus::Entry.build(
-                :description => "Order placed for widgets",
-                :debits => [
-                  {:account_name => "Cash", :amount => money.amount}],
-                :credits => [
-                  {:account_name => "Unearned Revenue", :amount => money.amount}])
+  description:  "Order placed for widgets",
+  debits: [{ account_name: "Cash", amount: money.amount}],
+  credits: [{ account_name: "Unearned Revenue", amount: money.amount}]
+)
 ```
 
 Multitenancy Support
@@ -295,15 +292,14 @@ end
 
 
 ```ruby
-debit_account = Borutus::Account.where(:name => "Cash", :tenant => my_tenant).last
-credit_account = Borutus::Account.where(:name => "Unearned Revenue", :tenant => my_tenant).last
+debit_account = Borutus::Account.where(name: "Cash", tenant: my_tenant).last
+credit_account = Borutus::Account.where(name: "Unearned Revenue", tenant: my_tenant).last
 entry = Borutus::Entry.new(
-                :description => "Order placed for widgets",
-                :date => Date.yesterday,
-                :debits => [
-                  {:account => debit_account, :amount => 100.00}],
-                :credits => [
-                  {:account => credit_account, :amount => 100.00}])
+  description:  "Order placed for widgets",
+  date:  Date.yesterday,
+  debits: [{ account: debit_account, amount: 100.00}],
+  credits: [{ account: credit_account, amount: 100.00}]
+)
 ```
 
 Reporting Views
@@ -316,7 +312,7 @@ These views and controllers are read-only for reporting purposes. It is assumed
 Routing is supplied via an engine mount point. Borutus can be mounted on a subpath in your existing Rails 3 app by adding the following to your routes.rb:
 
 ```ruby
-mount Borutus::Engine => "/borutus", :as => "borutus"
+mount Borutus::Engine => "/borutus", as: "borutus"
 ```
 
 *NOTE: The `Borutus::ApplicationController` does not currently support authentication. If you enable routing, the views will be publicly available on your mount point. Authentication can be added by overriding the controller.*
@@ -326,7 +322,11 @@ mount Borutus::Engine => "/borutus", :as => "borutus"
 Testing
 =======
 
-Run `docker-compose up pg`, this will create a local postgresql database. Then create a DB name `borutus_fixture_test`, you can do this via `createdb --username=postgres --host=localhost --port=5432 --template=template0 borutus_fixture_test`
+Run `docker-compose up pg`, this will create a local postgresql database. Then create a DB name `borutus_fixture_test`, you can do this via:
+
+```bash
+createdb --username=postgres --host=localhost --port=5432 --template=template0 borutus_fixture_test
+```
 
 [Rspec](http://rspec.info/) tests are provided. Run `bundle install` then `bundle exec rspec spec`.
 
@@ -339,11 +339,9 @@ Many thanks to all our contributors! Check them all at:
 
 https://github.com/bloom-solutions/borutus/graphs/contributors
 
-
 Reference
 =========
 
 For a complete reference on Accounting principles, we recommend the following textbook
 
 [http://amzn.com/0324662963](http://amzn.com/0324662963)
-

data/app/models/borutus/account.rb

@@ -1,5 +1,6 @@
 module Borutus
-  # The Account class represents accounts in the system. Each account must be subclassed as one of the following types:
+  # The Account class represents accounts in the system. Each account must be
+  # subclassed as one of the following types:
   #
   #   TYPE        | NORMAL BALANCE    | DESCRIPTION
   #   --------------------------------------------------------------------------
@@ -7,74 +8,73 @@ module Borutus
   #   Liability   | Credit            | Debts owed to outsiders
   #   Equity      | Credit            | Owners rights to the Assets
   #   Revenue     | Credit            | Increases in owners equity
-  #   Expense     | Debit             | Assets or services consumed in the generation of revenue
+  #   Expense     | Debit             | Assets or services consumed in the
+  #                                     generation of revenue
   #
-  # Each account can also be marked as a "Contra Account". A contra account will have it's
-  # normal balance swapped. For example, to remove equity, a "Drawing" account may be created
+  # Each account can also be marked as a "Contra Account". A contra account
+  # will have it's normal balance swapped. For example, to remove equity, a
+  # "Drawing" account may be created
   # as a contra equity account as follows:
   #
-  #   Borutus::Equity.create(:name => "Drawing", contra => true)
+  #   Borutus::Equity.create(name: "Drawing", contra: true)
   #
-  # At all times the balance of all accounts should conform to the "accounting equation"
-  #   Borutus::Assets = Liabilties + Owner's Equity
+  # At all times the balance of all accounts should conform to the
+  # "accounting equation" Borutus::Assets = Liabilties + Owner's Equity
   #
-  # Each sublclass account acts as it's own ledger. See the individual subclasses for a
-  # description.
+  # Each sublclass account acts as it's own ledger. See the individual
+  # subclasses for a description.
   #
   # @abstract
-  #   An account must be a subclass to be saved to the database. The Account class
-  #   has a singleton method {trial_balance} to calculate the balance on all Accounts.
+  #   An account must be a subclass to be saved to the database. The Account
+  #   class has a singleton method {trial_balance} to calculate the balance
+  #   on all Accounts.
   #
   # @see http://en.wikipedia.org/wiki/Accounting_equation Accounting Equation
-  # @see http://en.wikipedia.org/wiki/Debits_and_credits Debits, Credits, and Contra Accounts
+  # @see http://en.wikipedia.org/wiki/Debits_and_credits Debits, Credits, and
+  # Contra Accounts
   #
   # @author Michael Bulat
   class Account < ActiveRecord::Base
+
     class_attribute :normal_credit_balance
 
     has_many :amounts
-    has_many :credit_amounts, :extend => AmountsExtension, :class_name => 'Borutus::CreditAmount'
-    has_many :debit_amounts, :extend => AmountsExtension, :class_name => 'Borutus::DebitAmount'
+    has_many(:credit_amounts, {
+      extend: AmountsExtension,
+      class_name: "Borutus::CreditAmount",
+    })
+    has_many(:debit_amounts, {
+      extend: AmountsExtension,
+      class_name: "Borutus::DebitAmount",
+    })
     has_many :entries, through: :amounts, source: :entry do
       def with_running_balance
         account = proxy_association.owner
-        credit_amounts = account.credit_amounts
-        debit_amounts = account.debit_amounts
-
-        credit_table = credit_amounts.joins(:entry).select(
-          :id,
-          :entry_id,
-          %{ SUM("borutus_amounts".amount) AS amount }
-        ).group(:entry_id, :id)
-
-        debit_table = debit_amounts.joins(:entry).select(
-          :id,
-          :entry_id,
-          %{ SUM("borutus_amounts".amount) AS amount }
-        ).group(:entry_id, :id)
-
-        sum_statement = if account.normal_credit_balance
-                          %{ COALESCE("credit_table"."amount", 0) - COALESCE("debit_table"."amount", 0) }
-                        else
-                          %{ COALESCE("debit_table"."amount", 0) - COALESCE("credit_table"."amount", 0) }
-                        end
-
-        joins(%{
-          LEFT OUTER JOIN (#{credit_table.to_sql}) AS "credit_table" ON "credit_table".entry_id = "borutus_entries".id
-          LEFT OUTER JOIN (#{debit_table.to_sql}) AS "debit_table" ON "debit_table".entry_id = "borutus_entries".id
-        }).select(%{
-          "borutus_entries".*,
-          SUM(#{sum_statement}) OVER(ORDER BY "borutus_entries"."created_at") AS balance,
-          #{sum_statement} AS change_amount
-        }).group(:id, %{ "debit_table".amount, "credit_table".amount })
+        result = Accounts::BuildRunningBalanceQuery.execute(account: account)
+
+        joins(result.joins_statement)
+          .select(result.select_statement)
+          .group(result.group_statement)
           .order(created_at: :asc)
       end
     end
-    has_many :credit_entries, :through => :credit_amounts, :source => :entry, :class_name => 'Borutus::Entry'
-    has_many :debit_entries, :through => :debit_amounts, :source => :entry, :class_name => 'Borutus::Entry'
+    has_many(:credit_entries, {
+      through: :credit_amounts,
+      source: :entry,
+      class_name: "Borutus::Entry",
+    })
+    has_many(:debit_entries, {
+      through: :debit_amounts,
+      source: :entry,
+      class_name: "Borutus::Entry",
+    })
 
     validates_presence_of :type
 
+    scope :with_amounts, -> do
+      where("borutus_amounts_count > 0")
+    end
+
     def self.types
       [
         ::Borutus::Asset,
@@ -94,14 +94,17 @@ module Borutus
     # The balance of the account. This instance method is intended for use only
     # on instances of account subclasses.
     #
-    # If the account has a normal credit balance, the debits are subtracted from the credits
-    # unless this is a contra account, in which case credits are substracted from debits.
+    # If the account has a normal credit balance, the debits are subtracted
+    # from the credits unless this is a contra account, in which case credits
+    # are substracted from debits.
     #
     # For a normal debit balance, the credits are subtracted from the debits
-    # unless this is a contra account, in which case debits are subtracted from credits.
+    # unless this is a contra account, in which case 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
+    # 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})
@@ -112,25 +115,26 @@ module Borutus
     #   => #<BigDecimal:103259bb8,'0.2E4',4(12)>
     #
     # @return [BigDecimal] The decimal value balance
-    def balance(options={})
+    def balance(options = {})
       if self.class == Borutus::Account
-        raise(NoMethodError, "undefined method 'balance'")
+        raise NoMethodError, "undefined method 'balance'"
+      end
+
+      if normal_credit_balance ^ contra
+        credits_balance(options) - debits_balance(options)
       else
-        if self.normal_credit_balance ^ contra
-          credits_balance(options) - debits_balance(options)
-        else
-          debits_balance(options) - credits_balance(options)
-        end
+        debits_balance(options) - credits_balance(options)
       end
     end
 
     # The credit balance for the account.
     #
-    # 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
+    # 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.credits_balance({:from_date => "2000-01-01", :to_date => Date.today})
+    #   >> asset.credits_balance({from_date: "2000-01-01", to_date: Date.today})
     #   => #<BigDecimal:103259bb8,'0.1E4',4(12)>
     #
     # @example
@@ -138,17 +142,18 @@ module Borutus
     #   => #<BigDecimal:103259bb8,'0.1E4',4(12)>
     #
     # @return [BigDecimal] The decimal value credit balance
-    def credits_balance(options={})
+    def credits_balance(options = {})
       credit_amounts.balance(options)
     end
 
     # The debit balance for the account.
     #
-    # 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
+    # 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.debits_balance({:from_date => "2000-01-01", :to_date => Date.today})
+    #   >> asset.debits_balance({ from_date: "2000-01-01", to_date: Date.today})
     #   => #<BigDecimal:103259bb8,'0.1E4',4(12)>
     #
     # @example
@@ -156,7 +161,7 @@ module Borutus
     #   => #<BigDecimal:103259bb8,'0.3E4',4(12)>
     #
     # @return [BigDecimal] The decimal value credit balance
-    def debits_balance(options={})
+    def debits_balance(options = {})
       debit_amounts.balance(options)
     end
 
@@ -165,11 +170,12 @@ module Borutus
     #
     # 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
+    # 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
-    #   >> Borutus::Liability.balance({:from_date => "2000-01-01", :to_date => Date.today})
+    #   >> Borutus::Liability.balance({from_date: "2000-01-01", to_date: Date.today})
     #   => #<BigDecimal:103259bb8,'0.1E4',4(12)>
     #
     # @example
@@ -177,25 +183,25 @@ module Borutus
     #   => #<BigDecimal:1030fcc98,'0.82875E5',8(20)>
     #
     # @return [BigDecimal] The decimal value balance
-    def self.balance(options={})
-      if self.new.class == Borutus::Account
+    def self.balance(options = {})
+      if new.class == Borutus::Account
         raise(NoMethodError, "undefined method 'balance'")
-      else
-        accounts_balance = BigDecimal.new('0')
-        accounts = self.all
-        accounts.each do |account|
-          if account.contra
-            accounts_balance -= account.balance(options)
-          else
-            accounts_balance += account.balance(options)
-          end
+      end
+
+      accounts_balance = BigDecimal("0")
+      accounts = all
+      accounts.each do |account|
+        if account.contra
+          accounts_balance -= account.balance(options)
+        else
+          accounts_balance += account.balance(options)
         end
-        accounts_balance
       end
+      accounts_balance
     end
 
-    # The trial balance of all accounts in the system. This should always equal zero,
-    # otherwise there is an error in the system.
+    # The trial balance of all accounts in the system. This should always
+    # equal zero, otherwise there is an error in the system.
     #
     # @example
     #   >> Account.trial_balance.to_i
@@ -203,11 +209,16 @@ module Borutus
     #
     # @return [BigDecimal] The decimal value balance of all accounts
     def self.trial_balance
-      if self.new.class == Borutus::Account
-        Borutus::Asset.balance - (Borutus::Liability.balance + Borutus::Equity.balance + Borutus::Revenue.balance - Borutus::Expense.balance)
-      else
-        raise(NoMethodError, "undefined method 'trial_balance'")
+      if new.class != Borutus::Account
+        raise NoMethodError, "undefined method 'trial_balance'"
       end
+
+      Borutus::Asset.balance - (
+        Borutus::Liability.balance +
+        Borutus::Equity.balance +
+        Borutus::Revenue.balance -
+        Borutus::Expense.balance
+      )
     end
 
   end