rock_books 0.6.0 → 0.9.0

data/lib/rock_books/reports/book_set_reporter.rb

@@ -1,26 +1,36 @@
 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'
 
 module RockBooks
 class BookSetReporter
 
   extend Forwardable
 
-  attr_reader :book_set, :output_dir, :filter, :context
+  attr_reader :book_set, :context, :filter, :output_dir
 
   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
@@ -30,72 +40,74 @@ class BookSetReporter
   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
   end
 
 
   # All methods after this point are private.
 
-  private def all_reports(filter = nil)
+  private def do_statements
+    bs_is_data = BsIsData.new(context)
 
-    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
+    bal_sheet_text_report = BalanceSheet.new(context, bs_is_data.bal_sheet_data).generate
+    write_report(:balance_sheet, bal_sheet_text_report)
 
-    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
+    inc_stat_text_report = IncomeStatement.new(context, bs_is_data.inc_stat_data).generate
+    write_report(:income_statement, inc_stat_text_report)
+  end
 
-    if run_options.do_receipts
-      report_hash[:receipts] = ReceiptsReport.new(context, *missing_existing_unused_receipts).call
-    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
+  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
-
-    report_hash
   end
 
 
-  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}"
+  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
-    unless stderr.size == 0
-      puts "\nStderr was:\n\n#{stderr}"
+
+    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
-    puts
-    stdout
+
+    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 executable_exists?(name)
-    `which #{name}`
-    $?.success?
+  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 check_prequisite_executables
-    raise "Report generation is not currently supported in Windows." if OS.windows?
-    required_exes = OS.mac? ? %w(textutil cupsfilter) : %w(txt2html cupsfilter)
-    missing_exes = required_exes.reject { |exe| executable_exists?(exe) }
-    if missing_exes.any?
-      raise "Missing required report generation executable(s): #{missing_exes.join(', ')}"
-    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
 
 
@@ -118,84 +130,89 @@ 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')
+      utf8_nonbreaking_space = "\uC2A0"
+      unicode_nonbreaking_space = "\u00A0"
+      text(report_text.gsub(' ', unicode_nonbreaking_space))
+    end
+  end
 
-      File.write(txt_filespec, report_text)
 
-      # Linux & Mac OS
-      cupsfilter = -> { run_command("cupsfilter #{txt_filespec} > #{pdf_filespec}") }
+  private def html_metadata_comment(doc_short_name)
+    "\n" + report_metadata(doc_short_name).ai(plain: true) + "\n"
+  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
 
-      # Linux
-      txt2html = -> { run_command("txt2html --preformat_trigger_lines 0 #{txt_filespec} > #{html_filespec}") }
-
-      # Use smaller size for the PDF but larger size for the web pages:
-      if OS.mac?
-        textutil.(11)
-        cupsfilter.()
-        textutil.(14)
-      else
-        txt2html.()
-        cupsfilter.()
-      end
+  private def write_report(short_name, text_report)
 
-      hyperlinkized_text, replacements_made = HtmlHelper.convert_receipts_to_hyperlinks(File.read(html_filespec))
-      if replacements_made
-        File.write(html_filespec, hyperlinkized_text)
-      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')
 
-      puts "Created reports in txt, html, and pdf for #{"%-20s" % short_name} at #{File.dirname(txt_filespec)}.\n\n\n"
+    create_text_report = -> { File.write(txt_filespec, text_report) }
+
+    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
-  end
 
+    create_text_report.()
+    create_pdf_report.()
+    create_html_report.()
 
-  private def receipt_full_filespec(receipt_filespec)
-    File.join(run_options.receipt_dir, receipt_filespec)
+    puts "Created text, PDF, and HTML reports for #{short_name}."
   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
+    missing_receipts = []
+    existing_receipts = []
+    receipt_full_filespec = ->(receipt_filespec) { File.join(run_options.receipt_dir, receipt_filespec) }
+
+    # We will start out putting all filespecs in the unused array, and delete them as they are found in the transactions.
+    unused_receipt_filespecs = Dir['receipts/**/*'].select { |s| File.file?(s) } \
+        .sort \
+        .map { |s| "./" +  s }  # Prepend './' to match the data
 
     all_entries.each do |entry|
       entry.receipts.each do |receipt|
-        filespec = receipt_full_filespec(receipt)
-        unused.delete(filespec)
+        filespec = receipt_full_filespec.(receipt)
+        unused_receipt_filespecs.delete(filespec)
         file_exists = File.file?(filespec)
-        list = (file_exists ? existing : missing)
+        list = (file_exists ? existing_receipts : missing_receipts)
         list << { receipt: receipt, journal: entry.doc_short_name }
       end
     end
-    [missing, existing, unused]
+    [missing_receipts, existing_receipts, unused_receipt_filespecs]
   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
+    filespec = build_filespec(output_dir, 'index', 'html')
+    content = IndexHtmlPage.new(context, html_metadata_comment('index.html'), run_options).generate
+    File.write(filespec, content)
+    puts "Created index.html"
   end
 end
 end

data/lib/rock_books/reports/data/bs_is_data.rb

@@ -0,0 +1,61 @@
+require_relative 'bs_is_section_data'
+require_relative '../../filters/journal_entry_filters'
+require_relative '../../documents/journal'
+require_relative '../report_context'
+
+module RockBooks
+
+class BsIsData
+
+    attr_reader :journals_acct_totals, :context, :start_date, :end_date, :totals
+
+    def initialize(context)
+      @context = context
+      @start_date = context.chart_of_accounts.start_date
+      @end_date = context.chart_of_accounts.end_date
+      filter = JournalEntryFilters.date_on_or_before(end_date)
+      acct_amounts = Journal.acct_amounts_in_documents(context.journals, filter)
+      @journals_acct_totals = AcctAmount.aggregate_amounts_by_account(acct_amounts)
+    end
+
+
+    def section_data(type)
+      BsIsSectionData.new(type, context, journals_acct_totals).fetch
+    end
+
+
+    def bal_sheet_data
+      {
+          end_date:    end_date,
+          entity:      context.entity,
+          sections: {
+            asset:       section_data(:asset),
+            liability:   section_data(:liability),
+            equity:      section_data(:equity),
+          },
+          grand_total: journals_acct_totals.values.sum.round(2)
+      }
+    end
+
+
+    def inc_stat_data
+      income_section_data = section_data(:income)
+      expense_section_data = section_data(:expense)
+      net_income = (income_section_data[:acct_totals].values.sum.round(2) -
+          expense_section_data[:acct_totals].values.sum.round(2)
+          ).round(2)
+
+      {
+          start_date: start_date,
+          end_date:   end_date,
+          entity:     context.entity,
+          sections: {
+            income:     income_section_data,
+            expense:    expense_section_data,
+          },
+          net_income: net_income
+      }
+    end
+
+end
+end

data/lib/rock_books/reports/data/bs_is_section_data.rb

@@ -0,0 +1,30 @@
+module RockBooks
+
+BsIsSectionData = Struct.new(:type, :context, :journals_acct_totals)
+class BsIsSectionData
+
+  def fetch
+    {
+      acct_totals: totals,
+      total: totals.map(&:last).sum.round(2)
+    }
+  end
+
+  private def totals
+    @totals ||= calc_section_acct_totals
+  end
+
+  private def calc_section_acct_totals
+    codes  = context.chart_of_accounts.account_codes_of_type(type)
+    totals = journals_acct_totals.select { |code, _amount| codes.include?(code) }
+    need_to_reverse_sign = %i{liability equity income}.include?(type)
+    if need_to_reverse_sign
+      totals.keys.each do |code|
+        totals[code] = -totals[code] unless totals[code] == 0.0
+      end
+    end
+    totals
+  end
+
+end
+end

data/lib/rock_books/reports/data/journal_data.rb

@@ -0,0 +1,38 @@
+require_relative '../../types/acct_amount'
+
+module RockBooks
+class JournalData
+
+  attr_reader :journal, :context, :filter
+
+  def initialize(journal, report_context, filter = nil)
+    @journal = journal
+    @context = report_context
+    @filter = filter
+  end
+
+  def entries
+    return @entries if @entries
+    @entries = journal.entries
+    @entries = @entries.select { |entry| filter.(entry) } if filter
+    @entries
+  end
+
+  def fetch
+    totals = AcctAmount.aggregate_amounts_by_account(JournalEntry.entries_acct_amounts(entries))
+    {
+      code: journal.account_code,
+      name: journal.chart_of_accounts.name_for_code(journal.account_code),
+      title: journal.title,
+      short_name: journal.short_name,
+      debit_or_credit: journal.debit_or_credit,
+      start_date: context.chart_of_accounts.start_date,
+      end_date: context.chart_of_accounts.end_date,
+      entries: entries,
+      totals: totals,
+      grand_total: totals.values.sum.round(2),
+      max_acct_code_len: context.chart_of_accounts.max_account_code_length
+    }
+  end
+end
+end

data/lib/rock_books/reports/data/multidoc_txn_by_account_data.rb

@@ -0,0 +1,40 @@
+module RockBooks
+class MultidocTxnByAccountData
+
+  include TextReportHelper
+
+  attr_reader :context, :account_code
+
+
+  def initialize(report_context)
+    @context = report_context
+  end
+
+
+  def fetch
+    all_journal_entries = Journal.entries_in_documents(context.journals)
+    totals = AcctAmount.aggregate_amounts_by_account(JournalEntry.entries_acct_amounts(all_journal_entries))
+    {
+      journals: context.journals,
+      entries: all_journal_entries,
+      totals: totals,
+      grand_total: totals.values.sum.round(2),
+      acct_sections: fetch_acct_sections(all_journal_entries),
+    }
+  end
+
+
+  private def fetch_acct_sections(all_journal_entries)
+    context.chart_of_accounts.accounts.map do |account|
+      code = account.code
+      acct_entries = JournalEntry.entries_containing_account_code(all_journal_entries, code)
+      total = JournalEntry.total_for_code(acct_entries, code)
+      {
+        code: code,
+        entries: acct_entries,
+        total: total
+      }
+    end
+  end
+end
+end