rock_books 0.6.1 → 0.10.0

data/lib/rock_books/documents/journal.rb

@@ -7,7 +7,7 @@ require_relative '../types/acct_amount'
 require_relative '../types/journal_entry_context'
 require_relative 'journal_entry'
 require_relative 'journal_entry_builder'
-require_relative '../reports/reporter'
+require_relative '../reports/helpers/text_report_helper'
 
 module RockBooks
 
@@ -45,9 +45,7 @@ class Journal
   end
 
 
-
-
-    def self.acct_amounts_in_documents(documents, entries_filter = nil, acct_amounts_filter = nil)
+  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|
@@ -67,12 +65,10 @@ class Journal
   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_lines, short_name = nil)
+  def initialize(chart_of_accounts, input_lines)
     @chart_of_accounts = chart_of_accounts
-    @short_name = short_name
     @entries = []
     @date_prefix = ''
-    @title = ''
     input_lines.each_with_index do |line, linenum|
       context = JournalEntryContext.new(self, linenum + 1, line)
       parse_line(context)
@@ -131,7 +127,6 @@ class Journal
   end
 
 
-
   def acct_amounts
     entries.each_with_object([]) { |entry, acct_amounts|  acct_amounts << entry.acct_amounts }.flatten
   end

data/lib/rock_books/documents/journal_entry.rb

@@ -32,12 +32,17 @@ class JournalEntry < Struct.new(:date, :acct_amounts, :doc_short_name, :descript
 
   def self.sort_entries_by_amount_descending!(entries)
     entries.sort_by! do |entry|
-      [entry.total_absolute_value, entry.doc_short_name]
+      [-entry.total_absolute_value, entry.doc_short_name]
       end
-    entries.reverse!
   end
 
 
+  def self.sort_entries_by_date!(entries)
+    entries.sort_by! { |entry| [entry.date, entry.doc_short_name] }
+  end
+
+
+
   def total_for_code(account_code)
     acct_amounts_with_code(account_code).map(&:amount).sum
   end

data/lib/rock_books/documents/journal_entry_builder.rb

@@ -14,6 +14,10 @@ class JournalEntryBuilder < Struct.new(:journal_entry_context)
   def chart_of_accounts; journal_entry_context.chart_of_accounts;  end
 
 
+  # A "token" in this context means an account name and account amount pair, e.g. "pnc.checking 1234.56".
+  # @param tokens the account name/amount pairs found in the source text
+  # @date transaction date
+  # @return array of AcctAmount instances
   def acct_amounts_from_tokens(tokens, date)
     acct_amounts = []
 

data/lib/rock_books/helpers/book_set_loader.rb

@@ -7,6 +7,7 @@ module RockBooks
 
     module_function
 
+    # @return a hash whose keys are the filespecs and values are the document types
     def get_files_with_types(directory)
       files = Dir[File.join(directory, '*.txt')]
       files.each_with_object({}) do |filespec, files_with_types|
@@ -42,7 +43,7 @@ module RockBooks
 
     # Uses all *.txt 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.
+    # To exclude a file, make the extension something other than .txt.
     def load(run_options)
 
       files_with_types = get_files_with_types(run_options.input_dir)
@@ -54,9 +55,8 @@ module RockBooks
       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) }
+      journals = journal_files.map { |filespec| Journal.from_file(chart_of_accounts, filespec) }
       BookSet.new(run_options, chart_of_accounts, journals)
     end
-
   end
 end

data/lib/rock_books/reports/balance_sheet.rb

@@ -1,6 +1,5 @@
-require_relative '../filters/journal_entry_filters'
-require_relative '../documents/journal'
-require_relative 'report_context'
+require_relative 'helpers/erb_helper'
+require_relative 'helpers/text_report_helper'
 
 module RockBooks
 
@@ -9,52 +8,19 @@ module RockBooks
 # in order to calculate the correct balances, so we ignore the global $filter.
 class BalanceSheet
 
-  include Reporter
+  include TextReportHelper
+  include ErbHelper
 
-  attr_accessor :context
+  attr_accessor :context, :data
 
-  def initialize(report_context)
+  def initialize(report_context, data)
     @context = report_context
+    @data = data
   end
 
 
-  def end_date
-    context.chart_of_accounts.end_date
+  def generate
+    ErbHelper.render_hashes('text/balance_sheet.txt.erb', data, template_presentation_context)
   end
-
-
-  def generate_header
-    lines = [banner_line]
-    lines << center(context.entity || 'Unspecified Entity')
-    lines << center("Balance Sheet for Period Ending #{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/book_set_reporter.rb

@@ -1,104 +1,153 @@
 require_relative '../documents/book_set'
 
 require_relative 'balance_sheet'
+require_relative 'data/bs_is_data'
+require_relative 'data/receipts_report_data'
 require_relative 'income_statement'
-require_relative 'multidoc_transaction_report'
+require_relative 'index_html_page'
+require_relative 'multidoc_txn_report'
 require_relative 'receipts_report'
 require_relative 'report_context'
-require_relative 'transaction_report'
-require_relative 'tx_by_account'
+require_relative 'journal_report'
+require_relative 'multidoc_txn_by_account_report'
 require_relative 'tx_one_account'
+require_relative 'helpers/erb_helper'
+require_relative 'helpers/text_report_helper'
+require_relative 'helpers/receipts_hyperlink_converter'
+
+require 'prawn'
+require 'tty-progressbar'
 
 module RockBooks
 class BookSetReporter
 
   extend Forwardable
 
-  attr_reader :book_set, :output_dir, :filter, :context
+  attr_reader :book_set, :context, :filter, :output_dir, :progress_bar
 
   def_delegator :book_set, :all_entries
   def_delegator :book_set, :journals
   def_delegator :book_set, :chart_of_accounts
   def_delegator :book_set, :run_options
 
+  FONT_FILESPEC = File.absolute_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'assets', 'fonts', 'JetBrainsMono-Medium.ttf'))
+
 
   def initialize(book_set, output_dir, filter = nil)
     @book_set = book_set
     @output_dir = output_dir
     @filter = filter
     @context = ReportContext.new(book_set.chart_of_accounts, book_set.journals, 80)
+    @progress_bar = TTY::ProgressBar.new("[:bar] :caption", total: report_count + 10)
   end
 
 
-  def call
-    check_prequisite_executables
-    reports = all_reports(filter)
+  def generate
     create_directories
     create_index_html
-    write_reports(reports)
+
+    do_statements
+    do_journals
+    do_transaction_reports
+    do_single_account_reports
+    do_receipts_report
+    progress_bar.advance(caption: 'Finished generating reports.')
+    progress_bar.finish
   end
 
 
-  # All methods after this point are private.
+  def report_count
+    bal_sheet_income_statement = 2
+    journal_count = journals.size
+    txn_report_count = 3
+    single_account_count = chart_of_accounts.accounts.size
+    receipt_report_count = 1
+    bal_sheet_income_statement + journal_count + txn_report_count + single_account_count + receipt_report_count
+  end
 
-  private def all_reports(filter = nil)
 
-    report_hash = journals.each_with_object({}) do |journal, report_hash|
-      key = journal.short_name.to_sym
-      report_hash[key] = TransactionReport.new(journal, context).call(filter)
-    end
+  def get_all_report_data
+    reports = {}
 
-    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
+    reports[:bs_is] = BsIsData.new(context)
 
-    if run_options.do_receipts
-      report_hash[:receipts] = ReceiptsReport.new(context, *missing_existing_unused_receipts).call
+    reports[:journals] = journals.each_with_object({}) do |journal, journals|
+      journals[journal.short_name] = JournalData.new(journal, context, filter).fetch
     end
 
-    chart_of_accounts.accounts.each do |account|
-      key = ('acct_' + account.code).to_sym
-      report = TxOneAccount.new(context, account.code).call
-      report_hash[key] = report
+    reports[:txn_reports] = {
+      by_account: MultidocTxnByAccountData.new(context).fetch,
+      by_date: MultidocTxnReportData.new(context, :date, filter).fetch,
+      by_amount: MultidocTxnReportData.new(context, :amount, filter).fetch
+    }
+
+    reports[:single_accounts] = chart_of_accounts.accounts.each_with_object({}) do |account, single_accts|
+      single_accts[account.code.to_sym] = TxOneAccountData.new(context, account.code).fetch
     end
 
-    report_hash
+    reports[:receipts] = ReceiptsReportData.new(book_set.all_entries, run_options.receipt_dir).fetch
+    reports
   end
 
+  # All methods after this point are private.
 
-  private def run_command(command)
-    puts "\n----\nRunning command: #{command}"
-    stdout, stderr, status = Open3.capture3(command)
-    puts "Status was #{status}."
-    unless stdout.size == 0
-      puts "\nStdout was:\n\n#{stdout}"
-    end
-    unless stderr.size == 0
-      puts "\nStderr was:\n\n#{stderr}"
+  private def do_statements
+    bs_is_data = BsIsData.new(context)
+
+    bal_sheet_text_report = BalanceSheet.new(context, bs_is_data.bal_sheet_data).generate
+    write_report(:balance_sheet, bal_sheet_text_report)
+
+    inc_stat_text_report = IncomeStatement.new(context, bs_is_data.inc_stat_data).generate
+    write_report(:income_statement, inc_stat_text_report)
+  end
+
+
+  private def do_journals
+    journals.each do |journal|
+      report_data = JournalData.new(journal, context, filter).fetch
+      text_report = JournalReport.new(report_data, context, filter).generate
+      write_report(journal.short_name, text_report)
     end
-    puts
-    stdout
   end
 
 
-  private def executable_exists?(name)
-    `which #{name}`
-    $?.success?
+  private def do_transaction_reports
+
+    do_date_or_amount_report = ->(sort_field, short_name) do
+      data = MultidocTxnReportData.new(context, sort_field, filter).fetch
+      text_report = MultidocTransactionReport.new(data, context).generate
+      write_report(short_name, text_report)
+    end
+
+    do_acct_report = -> do
+      data = MultidocTxnByAccountData.new(context).fetch
+      text_report = MultidocTransactionByAccountReport.new(data, context).generate
+      write_report(:all_txns_by_acct, text_report)
+    end
+
+    do_date_or_amount_report.(:date,   :all_txns_by_date)
+    do_date_or_amount_report.(:amount, :all_txns_by_amount)
+    do_acct_report.()
   end
 
 
-  private def check_prequisite_executables
-    raise "Report generation is not currently supported in Windows." if OS.windows?
-    required_exes = OS.mac? ? %w(textutil cupsfilter) : %w(txt2html wkhtmltopdf)
-    missing_exes = required_exes.reject { |exe| executable_exists?(exe) }
-    if missing_exes.any?
-      raise "Missing required report generation executable(s): #{missing_exes.join(', ')}. Please install them with your system's package manager."
+  private def do_single_account_reports
+    chart_of_accounts.accounts.each do |account|
+      short_name = ('acct_' + account.code).to_sym
+      data = TxOneAccountData.new(context, account.code).fetch
+      text_report = TxOneAccount.new(data, context).generate
+      write_report(short_name, text_report)
     end
   end
 
 
+  private def do_receipts_report
+    data = ReceiptsReportData.new(book_set.all_entries, run_options.receipt_dir).fetch
+    text_report = ReceiptsReport.new(context, data).generate
+    write_report(:receipts, text_report)
+  end
+
+
   private def create_directories
     %w(txt pdf html).each do |format|
       dir = File.join(output_dir, format, SINGLE_ACCT_SUBDIR)
@@ -118,83 +167,66 @@ class BookSetReporter
   end
 
 
-  private def create_index_html
-    filespec = build_filespec(output_dir, 'index', 'html')
-    File.write(filespec, index_html_content)
-    puts "Created index.html"
+  private def report_metadata(doc_short_name)
+    {
+        RBCreator:      "RockBooks v#{VERSION} (#{PROJECT_URL})",
+        RBEntity:       context.entity,
+        RBCreated:      Time.now.to_s,
+        RBDocumentCode: doc_short_name.to_s,
+    }
   end
 
 
-  private def write_reports(reports)
+  private def prawn_create_document(pdf_filespec, report_text, doc_short_name)
+    Prawn::Document.generate(pdf_filespec, info: report_metadata(doc_short_name)) do
+      font(FONT_FILESPEC, size: 10)
 
-    reports.each do |short_name, report_text|
-      txt_filespec = build_filespec(output_dir, short_name, 'txt')
-      html_filespec = build_filespec(output_dir, short_name, 'html')
-      pdf_filespec = build_filespec(output_dir, short_name, 'pdf')
-
-      File.write(txt_filespec, report_text)
+      utf8_nonbreaking_space = "\uC2A0"
+      unicode_nonbreaking_space = "\u00A0"
+      text(report_text.gsub(' ', unicode_nonbreaking_space))
+    end
+  end
 
-      # Mac OS
-      textutil = ->(font_size) do
-        run_command("textutil -convert html -font 'Courier New Bold' -fontsize #{font_size} #{txt_filespec} -output #{html_filespec}")
-      end
-      cupsfilter = -> { run_command("cupsfilter #{txt_filespec} > #{pdf_filespec}") }
 
-      # Linux
-      txt2html = -> { run_command("txt2html --preformat_trigger_lines 0 #{txt_filespec} > #{html_filespec}") }
-      html2pdf = -> { run_command("wkhtmltopdf #{html_filespec} #{pdf_filespec}") }
+  private def html_metadata_comment(doc_short_name)
+    "\n" + report_metadata(doc_short_name).ai(plain: true) + "\n"
+  end
 
-      # Use smaller size for the PDF but larger size for the web pages:
-      if OS.mac?
-        textutil.(11)
-        cupsfilter.()
-        textutil.(14)
-      else
-        txt2html.()
-        html2pdf.()
-      end
 
-      hyperlinkized_text, replacements_made = HtmlHelper.convert_receipts_to_hyperlinks(File.read(html_filespec))
-      if replacements_made
-        File.write(html_filespec, hyperlinkized_text)
-      end
+  private def write_report(short_name, text_report)
 
-      puts "Created reports in txt, html, and pdf for #{"%-20s" % short_name} at #{File.dirname(txt_filespec)}.\n\n\n"
-    end
-  end
+    txt_filespec = build_filespec(output_dir, short_name, 'txt')
+    html_filespec = build_filespec(output_dir, short_name, 'html')
+    pdf_filespec = build_filespec(output_dir, short_name, 'pdf')
 
+    create_text_report = -> { File.write(txt_filespec, text_report) }
 
-  private def receipt_full_filespec(receipt_filespec)
-    File.join(run_options.receipt_dir, receipt_filespec)
-  end
+    create_pdf_report = -> { prawn_create_document(pdf_filespec, text_report, short_name) }
 
+    create_html_report = -> do
+      data = {
+          report_body: text_report,
+          title: "#{short_name} Report -- RockBooks",
+          metadata_comment: html_metadata_comment(short_name)
+      }
+      html_raw_report = ErbHelper.render_hashes("html/report_page.html.erb", data, {})
+      html_report = ReceiptsHyperlinkConverter.convert(html_raw_report, html_filespec)
+      File.write(html_filespec, html_report)
+    end
 
-  private def missing_existing_unused_receipts
-    missing = []
-    existing = []
-    unused = Dir['receipts/**/*'].select { |s| File.file?(s) }.sort # Remove files as they are found
-    unused.map! { |s| "./" +  s }  # Prepend './' to match the data
+    create_text_report.()
+    create_pdf_report.()
+    create_html_report.()
 
-    all_entries.each do |entry|
-      entry.receipts.each do |receipt|
-        filespec = receipt_full_filespec(receipt)
-        unused.delete(filespec)
-        file_exists = File.file?(filespec)
-        list = (file_exists ? existing : missing)
-        list << { receipt: receipt, journal: entry.doc_short_name }
-      end
-    end
-    [missing, existing, unused]
+    progress_bar.advance(caption: "Generating report: #{short_name}")
   end
 
 
-  private def index_html_content
-    erb_filespec = File.join(File.dirname(__FILE__), 'index.html.erb')
-    erb = ERB.new(File.read(erb_filespec))
-    erb.result_with_hash(
-        journals: journals,
-        chart_of_accounts: chart_of_accounts,
-        run_options: run_options)
+  private def create_index_html
+    progress_bar.advance(caption: 'Generating index.html')
+    filespec = build_filespec(output_dir, 'index', 'html')
+    content = IndexHtmlPage.new(context, html_metadata_comment('index.html'), run_options).generate
+    File.write(filespec, content)
   end
 end
 end