rock_books 0.1.0

data/lib/rock_books/documents/journal_entry_builder.rb

@@ -0,0 +1,148 @@
+require_relative '../types/acct_amount'
+require_relative 'chart_of_accounts'
+require_relative 'journal'
+
+module RockBooks
+class JournalEntryBuilder < Struct.new(:line, :journal)
+
+  def acct_amounts_from_tokens(tokens, date, chart_of_accounts)
+    acct_amounts = []
+
+    tokens[0..-1].each_slice(2).each do |(account_code, amount)|
+      begin
+        acct_amount = AcctAmount.create_with_chart_validation(date, account_code, amount, chart_of_accounts)
+      rescue AccountNotFoundError => error
+        error.document_name = journal.short_name
+        error.line = line
+        raise
+      end
+
+      acct_amounts << acct_amount
+    end
+
+    acct_amounts
+  end
+
+
+  def validate_acct_amount_token_array_size(tokens)
+    if tokens.size.odd?
+      raise Error.new("Incorrect sequence of account codes and amounts: #{tokens}")
+    end
+  end
+
+
+  def convert_amounts_to_floats(tokens)
+    (1...tokens.size).step(2) do |amount_index|
+      tokens[amount_index] = Float(tokens[amount_index])
+    end
+  end
+
+
+  def general_journal?
+    journal.doc_type == 'general_journal'
+  end
+
+
+  # For regular journal only, not general journal.
+  # This converts the entered signs to the correct debit/credit signs.
+  def convert_signs_for_debit_credit(tokens)
+
+    # Adjust the sign of the amount for the main journal account (e.g. the checking account or credit card account)
+    # e.g. If it's a checking account, it is an asset, a debit account, and the transaction total
+    # will represent a credit to that checking account.
+    adjust_sign_for_main_account = ->(amount) do
+      (journal.debit_or_credit == :debit) ? -amount : amount
+    end
+
+    adjust_sign_for_other_accounts = ->(amount) do
+      - adjust_sign_for_main_account.(amount)
+    end
+
+    tokens[1] = adjust_sign_for_main_account.(tokens[1])
+    (3...tokens.size).step(2) do |amount_index|
+      tokens[amount_index] = adjust_sign_for_other_accounts.(tokens[amount_index])
+    end
+  end
+
+
+  # Returns an array of AcctAmount instances for the array of tokens.
+  #
+  # The following applies only to regular (not general) journals:
+  #
+  # this token array will start with the transaction's total amount
+  # and be followed by account/amount pairs.
+  #
+  # Examples, assuming a line:
+  # 2018-05-20  5.79  701  1.23  702  4.56
+  #
+  # and the journal account is '101', 'D' 'My Checking Account',
+  # the following AcctAmoutns will be created:
+  # [AcctAmount code: '101', amount: -5.79, AcctAmount code: '701', 1.23, AcctAmount code: '702', 4.56, ]
+  #
+  # shortcut: if there is only 1 account (that is, it is not a split entry), give it the total amount
+  # ['5.79', '701'] --> [AcctAmount code: '101', amount: -5.79, AcctAmount code: '701', 5.79]
+  #
+  # If the account is a credit account, the signs will be reversed.
+  def build_acct_amount_array(date, tokens)
+
+    unless general_journal?
+      if journal.account_code.nil?
+        raise Error.new("An '@account_code: ' line has not yet been specified in this journal." )
+      end
+
+      # Prepend the array with the document account code so that total amount will be associated with it.
+      tokens.unshift(journal.account_code)
+
+      # For convenience in regular journals, when there is no split,
+      # we permit the user to omit the amount after the
+      # account code, since we know it will be equal to the total amount.
+      # We add it here, because we *will* need to include it in the data.
+      if tokens.size == 3
+        tokens << tokens[1]  # copy the total amount to the sole account's amount
+      end
+    end
+
+    validate_acct_amount_token_array_size(tokens)
+
+    # Tokens in the odd numbered positions are dollar amounts that need to be converted from string to float.
+    begin
+      convert_amounts_to_floats(tokens)
+    rescue ArgumentError
+      raise Error.new("Float conversion or other parse error for #{date}, #{tokens}.")
+    end
+
+    unless general_journal?
+      # As a convenience, all normal journal amounts are entered as positive numbers.
+      # This code negates the amounts as necessary so that debits are + and credits are -.
+      # In general journals, the debit and credit amounts must be entered correctly already.
+      convert_signs_for_debit_credit(tokens)
+    end
+
+    acct_amounts_from_tokens(tokens, date, journal.chart_of_accounts)
+  end
+
+
+  def build
+    # this is an account line in the form: yyyy-mm-dd 101 blah blah blah
+    tokens = line.split
+    acct_amount_tokens = tokens[1..-1]
+    date_string = journal.date_prefix + tokens[0]
+    raise_error = -> do
+      raise Error.new("In journal '#{journal.short_name}', date string was '#{date_string}'" +
+          " but should be a valid date in the form YYYY-MM-DD.")
+    end
+
+    raise_error.() if date_string.length != 10
+
+    begin
+      date = Date.iso8601(date_string)
+    rescue ArgumentError
+      raise_error.()
+    end
+
+    acct_amounts = build_acct_amount_array(date, acct_amount_tokens)
+    JournalEntry.new(date, acct_amounts, journal.short_name)
+  end
+
+end
+end

data/lib/rock_books/errors/account_not_found_error.rb

@@ -0,0 +1,20 @@
+module RockBooks
+class AccountNotFoundError < RuntimeError
+
+  attr_accessor :bad_account_code, :document_name, :line
+
+  def initialize(bad_account_code, document_name = nil, line = nil)
+    self.bad_account_code = bad_account_code
+    super(to_s)
+  end
+
+
+  def to_s
+    s = "Account code not found in chart of accounts: #{bad_account_code}"
+    if document_name && line
+      s << ", document: #{document_name}, line: #{line}"
+    end
+    s
+  end
+end
+end

data/lib/rock_books/errors/error.rb

@@ -0,0 +1,10 @@
+# This error class is intended to differentiate errors from this library from other errors
+# when this code is included in external code.
+# In addition, more specific error classes in this library can subclass this one.
+
+module RockBooks
+
+class Error < RuntimeError
+end
+
+end

data/lib/rock_books/filters/acct_amount_filters.rb

@@ -0,0 +1,12 @@
+module RockBooks
+module AcctAmountFilters
+
+  module_function
+
+  def account_code(code)
+    ->(acct_amount) { acct_amount.code == code }
+  end
+
+
+end
+end

data/lib/rock_books/filters/journal_entry_filters.rb

@@ -0,0 +1,84 @@
+require 'date'
+
+module RockBooks
+module JournalEntryFilters
+
+  module_function
+
+
+  # Dates can be provided as a Ruby Date object, or as a string that will be converted to date (yyyy-mm-dd).
+  def to_date(string_or_date_object)
+    if string_or_date_object.is_a?(String)
+      Date.iso8601(string_or_date_object)
+    else
+      string_or_date_object
+    end
+  end
+
+
+  def null_filter
+    ->(entry) { true }
+  end
+
+
+  def year(target_year)
+    ->(entry) { entry.date.year == target_year }
+  end
+
+
+  def month(target_year, target_month)
+    ->(entry) do
+      entry.date.year == target_year && entry.date.month == target_month
+    end
+  end
+
+
+  def day(target_year, target_month, target_day)
+    ->(entry) do
+      entry.date.year == target_year && entry.date.month == target_month && entry.date.day == target_day
+    end
+  end
+
+
+  def account_code_filter(account_code)
+    ->(entry) do
+      entry.acct_amounts.map(&:code).detect { |code| code == account_code }
+    end
+  end
+
+
+  def date_on_or_after(date)
+    ->(entry) { entry.date >= to_date(date) }
+
+  end
+
+
+  def date_on_or_before(date)
+    date = to_date(date)
+    ->(entry) { entry.date <= date }
+  end
+
+
+  def date_in_range(start_date, end_date)
+    start_date = to_date(start_date)
+    end_date = to_date(end_date)
+    ->(entry) { entry.date >= start_date && entry.date <= end_date }
+  end
+
+
+  def all(*filters)
+    ->(entry) { filters.all? { |filter| filter.(entry) } }
+  end
+
+
+  def any(*filters)
+    ->(entry) { filters.any? { |filter| filter.(entry) } }
+  end
+
+
+  def none(*filters)
+    ->(entry) { filters.none? { |filter| filter.(entry) } }
+  end
+end
+end
+

data/lib/rock_books/helpers/book_set_loader.rb

@@ -0,0 +1,62 @@
+require_relative '../documents/book_set'
+
+module RockBooks
+
+  # Entry point is `load` method. Loads files in a directory to instantiate a BookSet.
+  module BookSetLoader
+
+    module_function
+
+    def get_files_with_types(directory)
+      files = Dir[File.join(directory, '*.rbt')]
+      files.each_with_object({}) do |filespec, files_with_types|
+        files_with_types[filespec] = ParseHelper.find_document_type_in_file(filespec)
+      end
+    end
+
+
+    def validate_chart_account_count(chart_of_account_files)
+      size = chart_of_account_files.size
+
+      if size == 0
+        raise Error.new("Chart of accounts file not found in input directory.\n" +
+                            " Does it have a '@doc_type: chart_of_accounts' line?")
+      elsif size > 1
+        raise Error.new("Expected only 1 chart of accounts file but found: #{chart_of_account_files}.")
+      end
+    end
+
+
+    def validate_journal_file_count(journal_files)
+      if journal_files.size == 0
+        raise Error.new("No journal files found in directory #{directory}. " +
+                            "A journal file must contain the line '@doc_type: journal'")
+      end
+    end
+
+
+    def select_files_of_type(files_with_types, target_doc_type_regex)
+      files_with_types.select { |filespec, doc_type| target_doc_type_regex === doc_type }.keys
+    end
+
+
+    # Uses all *.rbt files in the specified directory; uses @doc_type to determine which
+    # is the chart of accounts and which are journals.
+    # To exclude a file, make the extension other than .rdt.
+    def load(run_options)
+
+      files_with_types = get_files_with_types(run_options.input_dir)
+
+      chart_of_account_files = select_files_of_type(files_with_types, 'chart_of_accounts')
+      validate_chart_account_count(chart_of_account_files)
+
+      journal_files = select_files_of_type(files_with_types, /journal/) # include 'journal' and 'general_journal'
+      validate_journal_file_count(journal_files)
+
+      chart_of_accounts = ChartOfAccounts.from_file(chart_of_account_files.first)
+      journals = journal_files.map { |fs| Journal.from_file(chart_of_accounts, fs) }
+      BookSet.new(run_options, chart_of_accounts, journals)
+    end
+
+  end
+end

data/lib/rock_books/helpers/parse_helper.rb

@@ -0,0 +1,22 @@
+module RockBooks
+
+  module ParseHelper
+
+    module_function
+
+
+    def find_document_type(document_lines)
+      doc_type_line = document_lines.detect { |line| /^@doc_type: /.match(line) }
+      if doc_type_line.nil?
+        nil
+      else
+        doc_type_line.split(/^@doc_type: /).last.strip
+      end
+    end
+
+
+    def find_document_type_in_file(filespec)
+      find_document_type(File.readlines(filespec))
+    end
+  end
+end

data/lib/rock_books/reports/balance_sheet.rb

@@ -0,0 +1,60 @@
+require_relative '../filters/journal_entry_filters'
+require_relative '../documents/journal'
+require_relative 'report_context'
+
+module RockBooks
+
+# Reports the balance sheet as of the specified date.
+# Unlike other reports, we need to process transactions from the beginning of time
+# in order to calculate the correct balances, so we ignore the global $filter.
+class BalanceSheet
+
+  include Reporter
+
+  attr_accessor :context
+
+  def initialize(report_context)
+    @context = report_context
+  end
+
+
+  def end_date
+    context.end_date || Time.new.to_date
+  end
+
+
+  def generate_header
+    lines = [banner_line]
+    lines << center(context.entity || 'Unspecified Entity')
+    lines << center("Balance Sheet -- #{end_date}")
+    lines << banner_line
+    lines << ''
+    lines << ''
+    lines << ''
+    lines.join("\n")
+  end
+
+
+ def generate_report
+    filter = RockBooks::JournalEntryFilters.date_on_or_before(end_date)
+    acct_amounts = Journal.acct_amounts_in_documents(context.journals, filter)
+    totals = AcctAmount.aggregate_amounts_by_account(acct_amounts)
+    output = generate_header
+
+    asset_output,  asset_total  = generate_account_type_section('Assets',      totals, :asset,     false)
+    liab_output,   liab_total   = generate_account_type_section('Liabilities', totals, :liability, true)
+    equity_output, equity_total = generate_account_type_section('Equity',      totals, :equity,    true)
+
+    output << [asset_output, liab_output, equity_output].join("\n\n")
+
+    grand_total = asset_total - (liab_total + equity_total)
+
+    output << "\n#{"%12.2f    Assets - (Liabilities + Equity)" % grand_total}\n============\n"
+    output
+  end
+
+  alias_method :to_s, :generate_report
+  alias_method :call, :generate_report
+
+end
+end

data/lib/rock_books/reports/income_statement.rb

@@ -0,0 +1,63 @@
+require_relative '../documents/journal'
+require_relative 'report_context'
+
+module RockBooks
+
+
+  class IncomeStatement
+
+  include Reporter
+
+  attr_accessor :context
+
+
+  def initialize(report_context)
+    @context = report_context
+  end
+
+
+  def start_date
+    context.start_date || Date.new(1900, 1, 1)
+  end
+
+
+  def end_date
+    context.end_date || Date.new(2100, 1, 1)
+  end
+
+
+  def generate_header
+    lines = [banner_line]
+    lines << center(context.entity || 'Unspecified Entity')
+    lines << "#{center("Income Statement -- #{start_date} to #{end_date}")}"
+    lines << banner_line
+    lines << ''
+    lines << ''
+    lines << ''
+    lines.join("\n")
+  end
+
+
+  def generate_report
+    filter = RockBooks::JournalEntryFilters.date_in_range(start_date, end_date)
+    acct_amounts = Journal.acct_amounts_in_documents(context.journals, filter)
+    totals = AcctAmount.aggregate_amounts_by_account(acct_amounts)
+    totals.each { |aa| aa[1] = -aa[1] } # income statement shows credits as positive, debits as negative
+    output = generate_header
+
+    income_output,  income_total  = generate_account_type_section('Income',   totals, :income,  true)
+    expense_output, expense_total = generate_account_type_section('Expenses', totals, :expense, false)
+
+    grand_total = income_total - expense_total
+
+    output << [income_output, expense_output].join("\n\n")
+    output << "\n#{"%12.2f    Net Income" % grand_total}\n============\n"
+    output
+  end
+
+alias_method :to_s, :generate_report
+alias_method :call, :generate_report
+
+
+end
+end

data/lib/rock_books/reports/multidoc_transaction_report.rb

@@ -0,0 +1,66 @@
+require_relative '../documents/journal'
+require_relative 'reporter'
+require_relative 'report_context'
+
+module RockBooks
+
+class MultidocTransactionReport
+
+  include Reporter
+
+  attr_accessor :context
+
+  SORT_BY_VALID_OPTIONS = %i(date_and_account  amount)
+
+  def initialize(report_context)
+    @context = report_context
+  end
+
+
+  def generate_header(sort_by)
+    lines = [banner_line]
+    lines << center(context.entity || 'Unspecified Entity')
+    lines << center('Multi Document Transaction Report')
+    lines << center('Sorted by Amount Descending') if sort_by == :amount
+    lines << ''
+    lines << center('Source Documents:')
+    lines << ''
+    context.journals.each do |document|
+      short_name = SHORT_NAME_FORMAT_STRING % document.short_name
+      lines << center("#{short_name} -- #{document.title}")
+    end
+    lines << banner_line
+    lines << ''
+    lines << '   Date     Document           Amount      Account'
+    lines << '   ----     --------           ------      -------'
+    lines.join("\n") << "\n\n"
+  end
+
+
+  def generate_report(filter = nil, sort_by = :date_and_account)
+    unless SORT_BY_VALID_OPTIONS.include?(sort_by)
+      raise Error.new("sort_by option '#{sort_by}' not in valid choices of #{SORT_BY_VALID_OPTIONS}.")
+    end
+
+    entries = Journal.entries_in_documents(context.journals, filter)
+
+    if sort_by == :amount
+      JournalEntry.sort_entries_by_amount_descending!(entries)
+    end
+
+    sio = StringIO.new
+    sio << generate_header(sort_by)
+    entries.each { |entry| sio << format_multidoc_entry(entry) << "\n" }
+
+    totals = AcctAmount.aggregate_amounts_by_account(JournalEntry.entries_acct_amounts(entries))
+    sio << generate_and_format_totals('Totals', totals)
+
+    sio << "\n"
+    sio.string
+  end
+
+
+  alias_method :to_s, :generate_report
+  alias_method :call, :generate_report
+end
+end

data/lib/rock_books/reports/receipts_report.rb

@@ -0,0 +1,57 @@
+require_relative 'report_context'
+
+
+module RockBooks
+class ReceiptsReport
+
+  include Reporter
+
+  attr_reader :context, :missing, :existing
+
+
+  def initialize(report_context, missing, existing)
+    @context = report_context
+    @missing = missing
+    @existing = existing
+  end
+
+
+  def generate_header
+    lines = [banner_line]
+    lines << center(context.entity || 'Unspecified Entity')
+    lines << "#{center("Receipts Report")}"
+    lines << banner_line
+    lines << ''
+    lines << ''
+    lines << ''
+    lines.join("\n")
+  end
+
+
+  def receipt_info_line(info)
+    "%-16.16s  %s\n" % [info[:journal], info[:receipt]]
+  end
+
+
+  def column_headings
+    format_string = "%-16.16s  %s\n"
+    (format_string % ['Journal', 'Receipt Filespec']) << (format_string % %w(------- ----------------)) << "\n"
+  end
+
+
+  def generate_report
+    output = generate_header
+
+    output << "Missing Receipts:\n\n" << column_headings
+    missing.each { |info| output << receipt_info_line(info) }
+
+    output << "\n\n\nExisting Receipts:\n\n" << column_headings
+    existing.each { |info| output << receipt_info_line(info) }
+
+    output
+  end
+
+  alias_method :to_s, :generate_report
+  alias_method :call, :generate_report
+end
+end

data/lib/rock_books/reports/report_context.rb

@@ -0,0 +1,15 @@
+module RockBooks
+
+class ReportContext < Struct.new(
+    :chart_of_accounts,
+    :journals,
+    :start_date,
+    :end_date,
+    :page_width)
+
+  def entity
+    chart_of_accounts.entity
+  end
+end
+
+end