rock_books 0.1.0

data/lib/rock_books/cmd_line/main.rb

@@ -0,0 +1,108 @@
+require 'awesome_print'
+require 'optparse'
+require 'pry'
+require 'shellwords'
+
+require_relative '../../rock_books'
+require_relative '../documents/book_set'
+require_relative 'command_line_interface'
+
+module RockBooks
+
+class Main
+
+
+  def options_with_defaults
+    options = OpenStruct.new
+    options.input_dir   = DEFAULT_INPUT_DIR
+    options.output_dir  = DEFAULT_OUTPUT_DIR
+    options.receipt_dir = DEFAULT_RECEIPT_DIR
+    options.do_receipts = true
+    options
+  end
+
+
+  def prepend_environment_options
+    env_opt_string = ENV['ROCKBOOKS_OPTIONS']
+    if env_opt_string
+      args_to_prepend = Shellwords.shellsplit(env_opt_string)
+      ARGV.unshift(args_to_prepend).flatten!
+    end
+  end
+
+
+  # Parses the command line with Ruby's internal 'optparse'.
+  # OptionParser#parse! removes what it processes from ARGV, which simplifies our command parsing.
+  def parse_command_line
+    prepend_environment_options
+    options = options_with_defaults
+
+    OptionParser.new do |parser|
+
+      parser.on('-i', '--input_dir DIR',
+          "Input directory containing source data files, default: '#{DEFAULT_INPUT_DIR}'") do |v|
+        options.input_dir = File.expand_path(v)
+      end
+
+      parser.on('-o', '--output_dir DIR',
+          "Output directory to which report files will be written, default: '#{DEFAULT_OUTPUT_DIR}'") do |v|
+        options.output_dir = File.expand_path(v)
+      end
+
+      parser.on('-r', '--receipt_dir DIR',
+          "Directory root from which to find receipt filespecs, default: '#{DEFAULT_RECEIPT_DIR}'") do |v|
+        options.receipt_dir = File.expand_path(v)
+      end
+
+      parser.on('-s', '--shell', 'Start interactive shell') do |v|
+        options.interactive_mode = true
+      end
+
+      parser.on('-v', '--[no-]verbose', 'Verbose mode') do |v|
+        options.verbose_mode = v
+      end
+
+      parser.on('-y', '--[no-]say', 'Say error messages.') do |v|
+        options.say = v
+      end
+
+      parser.on('', '--[no-]receipts', 'Include report on existing and missing receipts.') do |v|
+        options.do_receipts = v
+      end
+    end.parse!
+
+    if options.verbose_mode
+      puts "Run Options:"
+      ap options.to_h
+    end
+
+    options
+  end
+
+
+  # Arg is a directory containing 'chart_of_accounts.rbd' and '*journal*.rbd' for input,
+  # and reports (*.rpt) will be output to this directory as well.
+  def call
+    begin
+      run_options = parse_command_line
+      CommandLineInterface.new(run_options).call
+    rescue => error
+      $stderr.puts  \
+      <<~HEREDOC
+      #{error.backtrace.join("\n")}
+
+      #{error}
+      HEREDOC
+
+      if run_options.say
+        `say #{error}`
+      end
+
+      exit(-1)
+      binding.pry
+      raise error
+    end
+
+  end
+end
+end

data/lib/rock_books/documents/book_set.rb

@@ -0,0 +1,113 @@
+require 'awesome_print'
+
+require_relative 'chart_of_accounts'
+require_relative 'journal'
+require_relative '../filters/journal_entry_filters'  # for shell mode
+require_relative '../helpers/parse_helper'
+require_relative '../reports/balance_sheet'
+require_relative '../reports/income_statement'
+require_relative '../reports/multidoc_transaction_report'
+require_relative '../reports/receipts_report'
+require_relative '../reports/report_context'
+require_relative '../reports/transaction_report'
+require_relative '../reports/tx_by_account'
+require_relative '../reports/tx_one_account'
+
+module RockBooks
+
+  class BookSet < Struct.new(:run_options, :chart_of_accounts, :journals)
+
+    FILTERS = JournalEntryFilters
+
+
+    def initialize(run_options, chart_of_accounts, journals)
+      super
+    end
+
+
+    def report_context
+      @report_context ||= ReportContext.new(chart_of_accounts, journals, nil, nil, 80)
+    end
+
+
+    def all_reports(filter = nil)
+      context = report_context
+      report_hash = context.journals.each_with_object({}) do |journal, report_hash|
+        report_hash[journal.short_name] = TransactionReport.new(journal, context).call(filter)
+      end
+      report_hash['all_txns_by_date'] = MultidocTransactionReport.new(context).call(filter)
+      report_hash['all_txns_by_amount'] = MultidocTransactionReport.new(context).call(filter, :amount)
+      report_hash['all_txns_by_acct'] = TxByAccount.new(context).call
+      report_hash['balance_sheet'] = BalanceSheet.new(context).call
+      report_hash['income_statement'] = IncomeStatement.new(context).call
+
+      if run_options.do_receipts
+        report_hash['receipts'] = ReceiptsReport.new(context, *missing_and_existing_receipts).call
+      end
+
+      chart_of_accounts.accounts.each do |account|
+        key = 'acct_' + account.code
+        report = TxOneAccount.new(context, account.code).call
+        report_hash[key] = report
+      end
+      report_hash
+    end
+
+
+    def run_command(command)
+      command = command + ' 2>&1'
+      puts command
+      `#{command}`
+    end
+
+
+    def all_reports_to_files(directory = '.', filter = nil)
+      reports = all_reports(filter)
+      reports.each do |short_name, report_text|
+        report_directory = /^acct_/.match(short_name) ? File.join(directory, SINGLE_ACCT_SUBDIR) : directory
+        txt_filespec  = File.join(report_directory, "#{short_name}.txt")
+        html_filespec = File.join(report_directory, "#{short_name}.html")
+        pdf_filespec  = File.join(report_directory, "#{short_name}.pdf")
+        File.write(txt_filespec, report_text)
+        run_command("textutil -convert html -font 'Menlo Regular' #{txt_filespec} -output #{html_filespec}")
+        run_command("cupsfilter #{html_filespec} > #{pdf_filespec}")
+        puts "Created reports in txt, html, and pdf for #{"%-20s" % short_name} at #{File.dirname(txt_filespec)}.\n\n\n"
+      end
+    end
+
+
+    def journal_names
+      journals.map(&:short_name)
+    end
+    alias_method :jnames, :journal_names
+
+
+    # Note: Unfiltered!
+    def all_acct_amounts
+      @all_acct_amounts ||= Journal.acct_amounts_in_documents(journals)
+    end
+
+
+    def all_entries
+      @all_entries ||= Journal.entries_in_documents(journals)
+    end
+
+
+    def receipt_full_filespec(receipt_filespec)
+      File.join(run_options.receipt_dir, receipt_filespec)
+    end
+
+
+    def missing_and_existing_receipts
+      missing = []; existing = []
+      all_entries.each do |entry|
+        entry.receipts.each do |receipt|
+          file_exists = File.file?(receipt_full_filespec(receipt))
+          list = (file_exists ? existing : missing)
+          list << { receipt: receipt, journal: entry.doc_short_name }
+        end
+      end
+      [missing, existing]
+    end
+  end
+end

data/lib/rock_books/documents/chart_of_accounts.rb

@@ -0,0 +1,113 @@
+require_relative '../types/account'
+require_relative '../types/account_type'
+require_relative '../errors/error'
+
+module RockBooks
+class ChartOfAccounts
+
+  attr_reader :doc_type, :title, :accounts, :entity
+
+
+  def self.from_file(file)
+    self.new(File.read(file))
+  end
+
+
+  def initialize(input_string)
+    @accounts = []
+    lines = input_string.split("\n")
+    lines.each { |line| parse_line(line) }
+  end
+
+
+  def parse_line(line)
+    case line.strip
+    when /^@doc_type:/
+      @doc_type = line.split('@doc_type:').last.strip
+    when /^@entity:/
+      @entity ||= line.split('@entity:').last.strip
+    when /^@title:/
+      @title = line.split('@title:').last.strip
+    when /^$/
+      # ignore empty line
+    when /^#/
+      # ignore comment line
+    else
+      # this is an account line in the form: 101 Asset First National City Bank
+      # The regex below gets everything before the first whitespace in token 1, and the rest in token 2.
+      matcher = line.match(/^(\S+)\s+(.*)$/)
+      code = matcher[1]
+      rest = matcher[2]
+
+      matcher = rest.match(/^(\S+)\s+(.*)$/)
+      account_type_token = matcher[1]
+      account_type = AccountType.to_type(account_type_token).symbol
+
+      name = matcher[2]
+
+      accounts << Account.new(code, account_type, name)
+    end
+  end
+
+  def accounts_of_type(type)
+    accounts.select { |account| account.type == type }
+  end
+
+  def account_codes_of_type(type)
+    accounts_of_type(type).map(&:code)
+  end
+
+
+  def include?(candidate_code)
+    accounts.any? { |account| account.code == candidate_code }
+  end
+
+
+  def report_string
+    result = ''
+
+    if title
+      result << title << "\n\n"
+    end
+
+    code_width = @accounts.inject(0) { |width, a| width = [width, a.code.length].max }
+    format_string = "%-#{code_width}s  %-10.10s  %s\n"
+    accounts.each { |a| result << (format_string % [a.code, a.type.to_s, a.name]) }
+
+    result
+  end
+
+
+  def account_for_code(code)
+    accounts.detect { |a| a.code == code }
+  end
+
+
+  def type_for_code(code)
+    found = account_for_code(code)
+    found ? found.type : nil
+  end
+
+  def name_for_code(code)
+    found = account_for_code(code)
+    found ? found.name : nil
+  end
+
+
+  def max_account_code_length
+    @max_account_code_length ||= accounts.map { |a| a.code.length }.max
+  end
+
+
+  def debit_or_credit_for_code(code)
+    type = type_for_code(code)
+    if %i(asset  expense).include?(type)
+      :debit
+    elsif %i(liability  equity  income).include?(type)
+      :credit
+    else
+      raise "Unexpected type #{type} for code #{code}."
+    end
+  end
+end
+end

data/lib/rock_books/documents/journal.rb

@@ -0,0 +1,161 @@
+require 'date'
+require 'json'
+require 'yaml'
+
+require_relative '../errors/account_not_found_error'
+require_relative '../types/acct_amount'
+require_relative 'journal_entry'
+require_relative 'journal_entry_builder'
+require_relative '../reports/reporter'
+
+module RockBooks
+
+# The journal will create journal entries, each of which containing an array of account/amount objects,
+# copying the entry date to them.
+#
+# Warning: Any line beginning with a number will be assumed to be the date of a data line for an entry,
+# so descriptions cannot begin with a number.
+class Journal
+
+  def self.from_file(chart_of_accounts, file)
+    self.new(chart_of_accounts, File.read(file))
+  end
+
+
+  # Returns the entries in the specified documents, sorted by date and document short name,
+  # optionally filtered with the specified filter.
+  def self.entries_in_documents(documents, filter = nil)
+    entries = documents.each_with_object([]) do |document, entries|
+      entries << document.entries
+    end.flatten
+
+    if filter
+      entries = entries.select {|entry| filter.(entry) }
+    end
+
+    entries.sort_by do |entry|
+      [entry.date, entry.doc_short_name]
+    end
+  end
+
+
+
+
+    def self.acct_amounts_in_documents(documents, entries_filter = nil, acct_amounts_filter = nil)
+    entries = entries_in_documents(documents, entries_filter)
+
+    acct_amounts = entries.each_with_object([]) do |entry, acct_amounts|
+      acct_amounts << entry.acct_amounts
+    end.flatten
+
+    if acct_amounts_filter
+      acct_amounts = AcctAmount.filter(acct_amounts, filter)
+    end
+
+    acct_amounts
+  end
+
+
+  class Entry < Struct.new(:date, :amount, :acct_amounts, :description); end
+
+  attr_reader :short_name, :account_code, :chart_of_accounts, :date_prefix, :debit_or_credit, :doc_type, :title, :entries
+
+  # short_name is a name that will appear on reports identifying the journal from which a transaction comes
+  def initialize(chart_of_accounts, input_string, short_name = nil)
+    @chart_of_accounts = chart_of_accounts
+    @short_name = short_name
+    @entries = []
+    @date_prefix = ''
+    @title = ''
+    lines = input_string.split("\n")
+    lines.each { |line| parse_line(line) }
+  end
+
+
+  def parse_line(line)
+    case line.strip
+    when /^@doc_type:/
+      @doc_type = line.split(/^@doc_type:/).last.strip
+    when  /^@account_code:/
+      @account_code = line.split(/^@account_code:/).last.strip
+
+      unless chart_of_accounts.include?(@account_code)
+        raise AccountNotFoundError.new(@account_code)
+      end
+
+      # if debit or credit has not yet been specified, inherit the setting from the account:
+      unless @debit_or_credit
+        @debit_or_credit = chart_of_accounts.debit_or_credit_for_code(@account_code)
+      end
+
+    when /^@title:/
+      @title = line.split(/^@title:/).last.strip
+    when /^@short_name:/
+      @short_name = line.split(/^@short_name:/).last.strip
+    when /^@date_prefix:/
+      @date_prefix = line.split(/^@date_prefix:/).last.strip
+    when /^@debit_or_credit:/
+      data = line.split(/^@debit_or_credit:/).last.strip
+      @debit_or_credit = data.to_sym
+    when /^$/
+      # ignore empty line
+    when /^#/
+      # ignore comment line
+    when /^\d/  # a date/acct/amount line starting with a number
+      entries << JournalEntryBuilder.new(line, self).build
+    else # Text line(s) to be attached to the most recently parsed transaction
+      unless entries.last
+        raise Error.new("Entry for this description cannot be found: #{line}")
+      end
+      entries.last.description << line << "\n"
+
+      if /^Receipt:/.match(line)
+        receipt_spec = line.split(/^Receipt:/).last.strip
+        entries.last.receipts << receipt_spec
+      end
+    end
+  end
+
+
+
+  def acct_amounts
+    entries.each_with_object([]) { |entry, acct_amounts|  acct_amounts << entry.acct_amounts }.flatten
+  end
+
+
+  def totals_by_account
+    acct_amounts.each_with_object(Hash.new(0)) { |aa, totals| totals[aa.code] += aa.amount }
+  end
+
+
+  def total_amount
+    AcctAmount.total_amount(acct_amounts)
+  end
+
+
+  def to_s
+    super.to_s + ': ' + \
+    {
+        account_code: account_code,
+        debit_or_credit: debit_or_credit,
+        title: title
+    }.to_s
+  end
+
+
+  def to_h
+    {
+        title:           title,
+        account_code:    account_code,
+        debit_or_credit: debit_or_credit,
+        doc_type:        doc_type,
+        date_prefix:     date_prefix,
+        entries:         entries
+    }
+  end
+
+
+  def to_json; to_h.to_json; end
+  def to_yaml; to_h.to_yaml; end
+end
+end

data/lib/rock_books/documents/journal_entry.rb

@@ -0,0 +1,73 @@
+require_relative '../types/acct_amount'
+require_relative '../filters/acct_amount_filters'
+
+module RockBooks
+
+class JournalEntry < Struct.new(:date, :acct_amounts, :doc_short_name, :description, :receipts)
+
+
+  def initialize(date, acct_amounts = [], doc_short_name = nil, description = '', receipts = [])
+    super
+  end
+
+
+  def self.entries_acct_amounts(entries)
+    acct_amounts = entries.each_with_object([]) do |entry, acct_amounts|
+      acct_amounts << entry.acct_amounts
+    end
+    acct_amounts.flatten!
+    acct_amounts
+  end
+
+
+  def self.entries_containing_account_code(entries, account_code)
+    entries.select { |entry| entry.contains_account?(account_code) }
+  end
+
+
+  def self.total_for_code(entries, account_code)
+    entries.map { |entry| entry.total_for_code(account_code)}.sum
+  end
+
+
+  def self.sort_entries_by_amount_descending!(entries)
+    entries.sort_by! do |entry|
+      [entry.total_absolute_value, entry.doc_short_name]
+      end
+    entries.reverse!
+  end
+
+
+  def total_for_code(account_code)
+    acct_amounts_with_code(account_code).map(&:amount).sum
+  end
+
+
+  def acct_amounts_with_code(account_code)
+    AcctAmount.filter(acct_amounts, AcctAmountFilters.account_code(account_code))
+  end
+
+
+  def total_amount
+    acct_amounts.inject(0) { |sum, aa| sum + aa.amount }
+  end
+
+
+  # Gets the absolute value of the positive (or negative) amounts in this entry.
+  # This is used to sort by transaction amount, since total of all amounts will always be zero.
+  def total_absolute_value
+    acct_amounts.map(&:amount).select { |n| n.positive? }.sum
+  end
+
+
+  def balanced?
+    total_amount == 0.0
+  end
+
+
+  def contains_account?(account_code)
+    acct_amounts.any? { |acct_amount| acct_amount.code == account_code }
+  end
+end
+
+end