sfos/ledger
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
ledger/main.cc
John Wiegley d7dd02276c further reorganization
2004-07-27 02:23:02 -04:00

906 lines
23 KiB
C++
Raw Blame History

#include "ledger.h"
#include "balance.h"
#include "textual.h"
#include "binary.h"
#include "constraint.h"
#include "item.h"
#include "expr.h"
#include "format.h"
#include <fstream>
#include <cstring>
#include <unistd.h>
#include <ctime>
namespace ledger {
//////////////////////////////////////////////////////////////////////
//
// The command-line balance report
//
static const std::string bal_fmt = "%20T%2_%-n\n";
void show_balances(std::ostream& out,
items_deque& items,
const constraints_t& constraints,
const format_t& format,
const item_t * displayed_parent)
{
for (items_deque::const_iterator i = items.begin();
i != items.end();
i++) {
const item_t * parent = displayed_parent;
bool by_exclusion = false;
std::string name = maximal_account_name(*i, parent);
const bool match = (constraints.show_expanded ||
(! constraints.account_masks.empty() &&
matches(constraints.account_masks, name,
&by_exclusion) &&
(! by_exclusion ||
displayed_parent->parent == NULL)) ||
(constraints.account_masks.empty() &&
displayed_parent->parent == NULL));
if (match && constraints(*i) &&
((*i)->subitems.size() != 1 ||
(*i)->total != (*i)->subitems[0]->total)) {
out << format.report_line(*i, parent);
parent = *i;
}
if (constraints.sort_order)
(*i)->sort(constraints.sort_order);
show_balances(out, (*i)->subitems, constraints, format, parent);
}
}
void balance_report(std::ostream& out,
item_t * top,
const constraints_t& constraints,
const format_t& format)
{
if (constraints.sort_order)
top->sort(constraints.sort_order);
show_balances(out, top->subitems, constraints, format, top);
if (constraints.show_subtotals && top->subitems.size() > 1 && top->total)
std::cout << "--------------------\n"
<< format.report_line(top);
}
//////////////////////////////////////////////////////////////////////
//
// The command-line register report
//
static const std::string reg_fmt
= "%10d %-.20p %/%-.22N %12.66t %12.80T\n";
static bool show_commodities_revalued = false;
static bool show_commodities_revalued_only = false;
static void report_value_change(std::ostream& out,
const std::time_t date,
const balance_pair_t& balance,
const balance_pair_t& prev_balance,
const constraints_t& constraints,
const format_t& format,
const std::string& first_line_format,
const std::string& next_lines_format)
{
static std::time_t prev_date = -1;
if (prev_date == -1) {
prev_date = date;
return;
}
item_t temp;
temp.date = prev_date;
temp.total = prev_balance;
balance_t prev_bal = format.compute_total(&temp);
temp.date = date;
temp.total = balance;
balance_t cur_bal = format.compute_total(&temp);
if (balance_t diff = cur_bal - prev_bal) {
temp.value = diff;
temp.total = balance;
temp.payee = "Commodities revalued";
if (constraints(&temp)) {
format_t copy = format;
copy.format_string = first_line_format;
out << copy.report_line(&temp);
copy.format_string = next_lines_format;
out << copy.report_line(&temp);
// Prevent double-deletion
copy.value_style = NULL;
copy.total_style = NULL;
}
}
prev_date = date;
}
void register_report(std::ostream& out,
item_t * top,
const constraints_t& constraints,
const format_t& format)
{
if (constraints.sort_order)
top->sort(constraints.sort_order);
format_t copy = format;
std::string first_line_format;
std::string next_lines_format;
const char * f = format.format_string.c_str();
if (const char * p = std::strstr(f, "%/")) {
first_line_format = std::string(f, 0, p - f);
next_lines_format = std::string(p + 2);
} else {
first_line_format = format.format_string;
next_lines_format = format.format_string;
}
balance_pair_t balance;
balance_pair_t last_reported;
account_t splits(NULL, "<Total>");
for (items_deque::const_iterator i = top->subitems.begin();
i != top->subitems.end();
i++) {
copy.format_string = first_line_format;
std::string header = copy.report_line(*i, top);
unsigned int header_len = header.length();
copy.format_string = next_lines_format;
bool first = true;
if ((*i)->subitems.size() > 1 && ! constraints.show_expanded) {
item_t summary;
summary.date = (*i)->date;
summary.parent = *i;
summary.account = &splits;
for (items_deque::const_iterator j = (*i)->subitems.begin();
j != (*i)->subitems.end();
j++)
summary.value += (*j)->value;
summary.total = balance + summary.value;
bool show = constraints(&summary);
if (show && show_commodities_revalued)
report_value_change(out, summary.date, balance, last_reported,
constraints, copy, first_line_format,
next_lines_format);
balance += summary.value;
if (show) {
if (! show_commodities_revalued_only)
out << header << copy.report_line(&summary, *i);
if (show_commodities_revalued)
last_reported = balance;
}
} else {
for (items_deque::const_iterator j = (*i)->subitems.begin();
j != (*i)->subitems.end();
j++) {
(*j)->total = balance + (*j)->value;
bool show = constraints(*j);
if (show && first && show_commodities_revalued) {
report_value_change(out, (*i)->date, balance, last_reported,
constraints, copy, first_line_format,
next_lines_format);
if (show_commodities_revalued_only)
first = false;
}
balance += (*j)->value;
if (show) {
if (! show_commodities_revalued_only) {
if (first) {
first = false;
out << header;
} else {
out.width(header_len);
out << " ";
}
out << copy.report_line(*j, *i);
}
if (show_commodities_revalued)
last_reported = balance;
}
}
}
}
if (show_commodities_revalued)
report_value_change(out, constraints.end(), balance, last_reported,
constraints, copy, first_line_format,
next_lines_format);
// To stop these from getting deleted when copy goes out of scope
copy.value_style = NULL;
copy.total_style = NULL;
}
bool add_new_entry(int index, int argc, char **argv, ledger_t * ledger)
{
masks_list regexps;
entry_t added;
entry_t * matching = NULL;
added.state = entry_t::UNCLEARED;
assert(index < argc);
if (! parse_date(argv[index++], &added.date)) {
std::cerr << "Error: Bad entry date: " << argv[index - 1]
<< std::endl;
return false;
}
if (index == argc) {
std::cerr << "Error: Too few arguments to 'entry'." << std::endl;
return false;
}
regexps.push_back(mask_t(argv[index++]));
for (entries_list::reverse_iterator i = ledger->entries.rbegin();
i != ledger->entries.rend();
i++)
if (matches(regexps, (*i)->payee)) {
matching = *i;
break;
}
added.payee = matching ? matching->payee : regexps.front().pattern;
if (index == argc) {
std::cerr << "Error: Too few arguments to 'entry'." << std::endl;
return false;
}
if (argv[index][0] == '-' || std::isdigit(argv[index][0])) {
if (! matching) {
std::cerr << "Error: Missing account name for non-matching entry."
<< std::endl;
return false;
}
transaction_t * m_xact, * xact, * first;
m_xact = matching->transactions.front();
amount_t amt(argv[index++]);
first = xact = new transaction_t(&added, m_xact->account, amt, amt);
if (xact->amount.commodity->symbol.empty()) {
xact->amount.commodity = m_xact->amount.commodity;
xact->cost.commodity = m_xact->amount.commodity;
}
added.add_transaction(xact);
m_xact = matching->transactions.back();
xact = new transaction_t(&added, m_xact->account,
- first->amount, - first->amount);
added.add_transaction(xact);
if ((index + 1) < argc && std::string(argv[index]) == "-from")
if (account_t * acct = ledger->find_account(argv[++index]))
added.transactions.back()->account = acct;
} else {
while (index < argc && std::string(argv[index]) != "-from") {
mask_t acct_regex(argv[index++]);
account_t * acct = NULL;
commodity_t * cmdty = NULL;
if (matching) {
for (transactions_list::iterator x
= matching->transactions.begin();
x != matching->transactions.end();
x++) {
if (acct_regex.match((*x)->account->fullname())) {
acct = (*x)->account;
cmdty = (*x)->amount.commodity;
break;
}
}
}
if (! acct)
acct = ledger->find_account(acct_regex.pattern);
if (! acct) {
std::cerr << "Error: Could not find account name '"
<< acct_regex.pattern << "'." << std::endl;
return false;
}
if (index == argc) {
std::cerr << "Error: Too few arguments to 'entry'." << std::endl;
return false;
}
amount_t amt(argv[index]++);
transaction_t * xact = new transaction_t(&added, acct, amt, amt);
if (! xact->amount.commodity)
xact->amount.commodity = cmdty;
added.add_transaction(xact);
}
if ((index + 1) < argc && std::string(argv[index]) == "-from") {
if (account_t * acct = ledger->find_account(argv[++index])) {
transaction_t * xact = new transaction_t(NULL, acct);
added.add_transaction(xact);
}
} else {
if (! matching) {
std::cerr << "Error: Could not figure out the account to draw from."
<< std::endl;
std::exit(1);
}
transaction_t * xact
= new transaction_t(&added, matching->transactions.back()->account);
added.add_transaction(xact);
}
}
// if (added.finalize())
print_textual_entry(std::cout, &added);
return true;
}
void set_price_conversion(const std::string& setting, ledger_t * ledger)
{
char buf[128];
std::strcpy(buf, setting.c_str());
assert(setting.length() < 128);
char * c = buf;
char * p = std::strchr(buf, '=');
if (! p) {
std::cerr << "Warning: Invalid price setting: " << setting << std::endl;
} else {
*p++ = '\0';
amount_t price;
price.parse(p, ledger);
commodity_t * commodity = ledger->find_commodity(c, true);
commodity->set_conversion(price);
}
}
static long pricing_leeway = 24 * 3600;
static std::string price_db;
static ledger_t * current_ledger = NULL;
static bool cache_dirty = false;
void download_price_quote(commodity_t * commodity,
const std::time_t age,
const amount_t& price,
const std::time_t moment)
{
std::time_t now = std::time(NULL); // the time of the query
if (! (commodity->flags & COMMODITY_STYLE_CONSULTED) &&
std::difftime(now, moment) < pricing_leeway &&
(! price || std::difftime(moment, age) > pricing_leeway)) {
using namespace std;
// Only consult the Internet once for any commodity
commodity->flags |= COMMODITY_STYLE_CONSULTED;
cache_dirty = true;
char buf[256];
buf[0] = '\0';
if (FILE * fp = popen((string("getquote ") +
commodity->symbol).c_str(), "r")) {
if (feof(fp) || ! fgets(buf, 255, fp)) {
fclose(fp);
return;
}
fclose(fp);
}
if (buf[0]) {
char * p = strchr(buf, '\n');
if (p) *p = '\0';
amount_t current;
current.parse(buf, current_ledger);
commodity->add_price(now, current);
if (! price_db.empty()) {
char buf[128];
strftime(buf, 127, "%Y/%m/%d %H:%M:%S", localtime(&now));
ofstream database(price_db.c_str(), ios_base::out | ios_base::app);
database << "P " << buf << " " << commodity->symbol << " "
<< current << endl;
}
}
}
}
} // namespace ledger
static void show_help(std::ostream& out)
{
std::cerr
<< "usage: ledger [options] COMMAND [options] [REGEXPS]" << std::endl
<< std::endl
<< "Basic options:" << std::endl
<< " -h display this help text" << std::endl
<< " -v display version information" << std::endl
<< " -f FILE specify pathname of ledger data file" << std::endl
<< std::endl
<< "Report filtering:" << std::endl
<< " -a REGEX specify an account regex for \"print\"" << std::endl
<< " -b DATE specify a beginning date" << std::endl
<< " -e DATE specify an ending date" << std::endl
<< " -c do not show future entries (same as -e TODAY)" << std::endl
<< " -d DATE specify a date mask ('-d mon', for all mondays)" << std::endl
<< " -C show only cleared transactions and balances" << std::endl
<< " -U show only uncleared transactions and balances" << std::endl
<< " -R do not consider virtual transactions: real only" << std::endl
<< " -l EXPR don't print entries for which EXPR yields 0" << std::endl
<< std::endl
<< "Customizing output:" << std::endl
<< " -n do not calculate parent account totals" << std::endl
<< " -s show sub-accounts in balance, and splits in register" << std::endl
<< " -M print register using monthly sub-totals" << std::endl
<< " -E show accounts that total to zero" << std::endl
<< " -S EXPR sort entry output based on EXPR" << std::endl
<< std::endl
<< "Commodity prices:" << std::endl
<< " -T report commodity totals, not their market value" << std::endl
<< " -B report cost basis of commodities" << std::endl
<< " -V report the market value of commodities" << std::endl
<< " -P FILE sets the price database, for reading/writing price info" << std::endl
<< " -Q download new price information (when needed) from the Internet" << std::endl
<< " (works by running \"getquote SYMBOL\")" << std::endl
<< " -L MINS with -Q, fetch quotes only if data is older than MINS" << std::endl
<< " -p STR specifies a direct commodity conversion: COMM=AMOUNT" << std::endl
<< std::endl
<< "commands:" << std::endl
<< " balance show balance totals" << std::endl
<< " register display a register for ACCOUNT" << std::endl
<< " print print all ledger entries" << std::endl
<< " equity generate equity ledger for all entries" << std::endl
<< " entry output a newly formed entry, based on arguments" << std::endl
<< " price show the last known price for matching commodities" << std::endl;
}
int main(int argc, char * argv[])
{
std::list<std::string> files;
ledger::ledger_t * book = NULL;
ledger::constraints_t constraints;
ledger::format_t format;
std::string sort_order;
std::string value_style = "a";
std::string total_style = "T";
// Initialize some variables based on environment variable settings
if (char * p = std::getenv("PRICE_HIST"))
ledger::price_db = p;
if (char * p = std::getenv("PRICE_EXP"))
ledger::pricing_leeway = std::atol(p) * 60;
// A ledger data file must be specified
bool use_cache = std::getenv("LEDGER") != NULL;
if (use_cache) {
for (int i = 0; i < argc; i++)
if (std::strcmp(argv[i], "-f") == 0) {
use_cache = false;
break;
}
if (use_cache)
if (const char * p = std::getenv("LEDGER_CACHE"))
if (access(p, R_OK) != -1) {
std::ifstream instr(p);
if (! ledger::read_binary_ledger(instr, std::getenv("LEDGER"),
book)) {
delete book;
book = NULL;
}
}
}
if (! book) {
book = new ledger::ledger_t;
ledger::cache_dirty = true;
}
ledger::current_ledger = book;
// Parse the command-line options
int c, index;
while (-1 !=
(c = getopt(argc, argv,
"+a:ABb:Ccd:DEe:F:f:Ghi:L:l:MN:noOP:p:QRS:st:T:UVvWXZ"))) {
switch (char(c)) {
// Basic options
case 'h':
show_help(std::cout);
break;
case 'v':
std::cout
<< "Ledger " << ledger::version
<< ", the command-line accounting tool" << std::endl
<< " Copyright (c) 2003-2004, New Artisans LLC. All rights reserved."
<< std::endl << std::endl
<< "This program is made available under the terms of the BSD Public"
<< std::endl
<< "License. See the LICENSE file included with the distribution for"
<< std::endl
<< "details and disclaimer." << std::endl;
return 0;
case 'f':
files.push_back(optarg);
use_cache = false;
break;
case 'p':
ledger::set_price_conversion(optarg, book);
break;
// Constraint options
case 'a':
constraints.account_masks.push_back(ledger::mask_t(optarg));
break;
case 'b':
constraints.have_beginning = true;
if (! ledger::parse_date(optarg, &constraints.begin_date)) {
std::cerr << "Error: Bad begin date: " << optarg << std::endl;
return 1;
}
break;
case 'e':
constraints.have_ending = true;
if (! ledger::parse_date(optarg, &constraints.end_date)) {
std::cerr << "Error: Bad end date: " << optarg << std::endl;
return 1;
}
break;
case 'c':
constraints.end_date = std::time(NULL);
constraints.have_ending = true;
break;
case 'd':
constraints.have_date_mask = true;
if (! ledger::parse_date_mask(optarg, &constraints.date_mask)) {
std::cerr << "Error: Bad date mask: " << optarg << std::endl;
return 1;
}
break;
case 'C':
constraints.cleared_only = true;
break;
case 'U':
constraints.uncleared_only = true;
break;
case 'R':
constraints.real_only = true;
break;
// Customizing output
case 'F':
format.format_string = optarg;
break;
case 'M':
constraints.period = ledger::PERIOD_MONTHLY;
break;
case 'E':
constraints.show_empty = true;
break;
case 'n':
constraints.show_subtotals = false;
break;
case 's':
constraints.show_expanded = true;
break;
case 'S':
sort_order = optarg;
break;
case 'o':
constraints.show_related = true;
break;
case 'l':
constraints.predicate = ledger::parse_expr(optarg, book);
break;
// Commodity reporting
case 'P':
ledger::price_db = optarg;
break;
case 'L':
ledger::pricing_leeway = std::atol(optarg) * 60;
break;
case 'Q':
ledger::commodity_t::updater = ledger::download_price_quote;
break;
case 't':
value_style = optarg;
break;
case 'T':
total_style = optarg;
break;
case 'O':
value_style = "a";
total_style = "T";
break;
case 'B':
value_style = "c";
total_style = "C";
break;
case 'V':
ledger::show_commodities_revalued = true;
value_style = "v";
total_style = "V";
break;
case 'G':
ledger::show_commodities_revalued =
ledger::show_commodities_revalued_only = true;
value_style = "c";
total_style = "G";
break;
case 'A':
value_style = "a";
total_style = "MT";
break;
case 'D':
value_style = "a";
total_style = "DMT";
break;
case 'Z':
value_style = "a";
total_style = "MDMT";
break;
case 'W':
value_style = "a";
total_style = "MD(MT*(d-b/e-b))";
break;
case 'X':
value_style = "a";
total_style = "a+MD(MT*(d-b/e-b))";
break;
}
}
if (optind == argc) {
show_help(std::cout);
return 1;
}
index = optind;
// Read the ledger file, unless we already read it from the cache
if (! use_cache || ledger::cache_dirty) {
int entry_count = 0;
if (files.empty()) {
if (char * p = std::getenv("LEDGER"))
for (p = std::strtok(p, ":"); p; p = std::strtok(NULL, ":"))
entry_count += parse_ledger_file(p, book);
} else {
for (std::list<std::string>::iterator i = files.begin();
i != files.end(); i++) {
char buf[4096];
char * p = buf;
std::strcpy(p, (*i).c_str());
entry_count += parse_ledger_file(p, book);
}
}
// Read prices from their own ledger file, after all others have
// been read.
if (! ledger::price_db.empty()) {
const char * path = ledger::price_db.c_str();
std::ifstream db(path);
book->sources.push_back(path);
entry_count += ledger::parse_textual_ledger(db, book, book->master);
}
if (entry_count == 0) {
std::cerr << ("Please specify ledger file(s) using -f option "
"or LEDGER environment variable.") << std::endl;
return 1;
}
}
// Read the command word, and handle the "entry" command specially,
// without any other processing.
const std::string command = argv[index++];
if (command == "entry")
return add_new_entry(index, argc, argv, book) ? 0 : 1;
// Interpret the remaining arguments as regular expressions, used
// for refining report results.
for (; index < argc; index++) {
if (std::strcmp(argv[index], "--") == 0) {
index++;
break;
}
constraints.account_masks.push_back(ledger::mask_t(argv[index]));
}
for (; index < argc; index++)
constraints.payee_masks.push_back(ledger::mask_t(argv[index]));
// Copy the constraints to the format object, and compile the value
// and total style strings
if (! sort_order.empty())
constraints.sort_order = ledger::parse_expr(sort_order, book);
format.value_style = ledger::parse_expr(value_style, book);
format.total_style = ledger::parse_expr(total_style, book);
// Now handle the command that was identified above.
if (command == "print") {
#if 0
ledger::item_t * top
= ledger::walk_entries(book->entries.begin(), book->entries.end(),
constraints, format);
ledger::entry_report(std::cout, top, format);
#ifdef DEBUG
delete top;
#endif
#endif
}
else if (command == "equity") {
#if 0
ledger::item_t * top
= ledger::walk_accounts(book->master, constraints);
ledger::entry_report(std::cout, top, constraints, format);
#ifdef DEBUG
delete top;
#endif
#endif
}
else if (constraints.period == ledger::PERIOD_NONE &&
! constraints.sort_order && ! constraints.show_related &&
(command == "balance" || command == "bal")) {
if (format.format_string.empty())
format.format_string = ledger::bal_fmt;
if (ledger::item_t * top
= ledger::walk_accounts(book->master, constraints)) {
ledger::balance_report(std::cout, top, constraints, format);
#ifdef DEBUG
delete top;
#endif
}
}
else if (command == "balance" || command == "bal") {
if (format.format_string.empty())
format.format_string = ledger::bal_fmt;
if (ledger::item_t * list
= ledger::walk_entries(book->entries.begin(),
book->entries.end(), constraints))
if (ledger::item_t * top
= ledger::walk_items(list, book->master, constraints)) {
ledger::balance_report(std::cout, top, constraints, format);
#ifdef DEBUG
delete top;
delete list;
#endif
}
}
else if (command == "register" || command == "reg") {
if (format.format_string.empty())
format.format_string = ledger::reg_fmt;
if (constraints.show_related)
constraints.show_inverted = true;
if (ledger::item_t * top
= ledger::walk_entries(book->entries.begin(),
book->entries.end(), constraints)) {
ledger::register_report(std::cout, top, constraints, format);
#ifdef DEBUG
delete top;
#endif
}
}
else {
std::cerr << "Error: Unrecognized command '" << command << "'."
<< std::endl;
return 1;
}
// Save the cache, if need be
if (use_cache && ledger::cache_dirty)
if (const char * p = std::getenv("LEDGER_CACHE")) {
std::ofstream outstr(p);
assert(std::getenv("LEDGER"));
ledger::write_binary_ledger(outstr, book, std::getenv("LEDGER"));
}
#ifdef DEBUG
delete book;
#endif
return 0;
}
// main.cc ends here.
Reference in a new issue View git blame Copy permalink