sfos/ledger
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
ledger/main.cc
John Wiegley 3273be3dcc restore sorting of register reports
2004-07-31 02:36:20 -04:00

989 lines
25 KiB
C++
Raw Blame History

#include "ledger.h"
#include "balance.h"
#include "error.h"
#include "textual.h"
#include "binary.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";
unsigned int show_balances(std::ostream& out,
items_deque& items,
const node_t * predicate,
const node_t * sort_order,
const format_t& format,
const bool show_expanded,
const item_t * displayed_parent)
{
unsigned int headlines = 0;
value_predicate pred_obj(predicate);
for (items_deque::const_iterator i = items.begin();
i != items.end();
i++) {
const item_t * parent = displayed_parent;
if (pred_obj(*i) &&
((*i)->subitems.size() != 1 ||
(*i)->total != (*i)->subitems[0]->total)) {
format.format_elements(out, *i, parent);
parent = *i;
if (! displayed_parent->parent)
headlines++;
}
if (sort_order)
(*i)->sort(sort_order);
if (show_expanded)
headlines += show_balances(out, (*i)->subitems, predicate,
sort_order, format, true, parent);
}
return headlines;
}
void balance_report(std::ostream& out,
item_t * top,
const node_t * predicate,
const node_t * sort_order,
const format_t& format,
const bool show_expanded,
const bool show_subtotals)
{
if (sort_order)
top->sort(sort_order);
unsigned int headlines = show_balances(out, top->subitems, predicate,
sort_order, format, show_expanded,
top);
if (show_subtotals && headlines > 1 && top->total) {
std::cout << "--------------------\n";
format.format_elements(std::cout, top);
}
}
//////////////////////////////////////////////////////////////////////
//
// The command-line register report
//
static const std::string reg_fmt
= "%10d %-.20p %-.22N %12.66t %12.80T\n%/%22_ %-.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 node_t * predicate,
const format_t& first_line_format,
const format_t& 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_t::compute_total(&temp);
temp.date = date;
temp.total = balance;
balance_t cur_bal = format_t::compute_total(&temp);
if (balance_t diff = cur_bal - prev_bal) {
temp.value = diff;
temp.total = balance;
temp.payee = "Commodities revalued";
if (value_predicate(predicate)(&temp)) {
first_line_format.format_elements(out, &temp);
next_lines_format.format_elements(out, &temp);
}
}
prev_date = date;
}
void register_report(std::ostream& out,
item_t * top,
const node_t * predicate,
const node_t * sort_order,
const format_t& first_line_format,
const format_t& next_lines_format,
const bool show_expanded)
{
if (sort_order)
top->sort(sort_order);
balance_pair_t balance;
balance_pair_t last_reported;
account_t splits(NULL, "<Total>");
value_predicate pred_obj(predicate);
for (items_deque::const_iterator i = top->subitems.begin();
i != top->subitems.end();
i++) {
bool first = true;
if ((*i)->subitems.size() > 1 && ! 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 = pred_obj(&summary);
if (show && show_commodities_revalued)
report_value_change(out, summary.date, balance, last_reported,
predicate, first_line_format, next_lines_format);
balance += summary.value;
if (show) {
if (! show_commodities_revalued_only)
first_line_format.format_elements(out, *i, top);
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 = pred_obj(*j);
if (show && first && show_commodities_revalued) {
report_value_change(out, (*i)->date, balance, last_reported,
predicate, 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;
first_line_format.format_elements(out, *j, *i);
} else {
next_lines_format.format_elements(out, *j, *i);
}
}
if (show_commodities_revalued)
last_reported = balance;
}
}
}
}
if (show_commodities_revalued)
report_value_change(out, -1, balance, last_reported, predicate,
first_line_format, next_lines_format);
}
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)
{
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);
commodity_t * commodity = commodity_t::find_commodity(c, true);
commodity->set_conversion(price);
}
}
static long pricing_leeway = 24 * 3600;
static std::string price_db;
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);
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;
std::string predicate_string;
ledger::node_t * predicate = NULL;
std::string format_string;
std::string sort_string;
ledger::node_t * sort_order = NULL;
std::string value_expr = "a";
std::string total_expr = "T";
ledger::ledger_t * journal = new ledger::ledger_t;
bool show_subtotals = true;
bool show_expanded = false;
bool show_related = false;
bool show_inverted = false;
#ifdef DEBUG
bool debug = false;
#endif
// 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;
}
ledger::cache_dirty = true;
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"),
journal)) {
// We need to throw away what we've read, and create a new
// ledger
delete journal;
journal = new ledger::ledger_t;
} else {
ledger::cache_dirty = false;
}
}
}
// Parse the command-line options
int c, index;
while (-1 !=
(c = getopt(argc, argv,
"+ABb:Ccd:DEe:F:f:Ghi:L:l:MnoOP:p:QRS:st:T:UVvWXZz"))) {
switch (char(c)) {
// Basic options
case 'h':
show_help(std::cout);
break;
#ifdef DEBUG
case 'z':
debug = 1;
break;
#endif
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);
break;
case 'b':
if (! predicate_string.empty())
predicate_string += "&";
predicate_string += "(d>=[";
predicate_string += optarg;
predicate_string += "])";
break;
case 'e':
if (! predicate_string.empty())
predicate_string += "&";
predicate_string += "(d<[";
predicate_string += optarg;
predicate_string += "])";
break;
case 'c': {
if (! predicate_string.empty())
predicate_string += "&";
predicate_string += "(d<";
std::ostringstream now;
now << std::time(NULL);
predicate_string += now.str();
predicate_string += ")";
break;
}
case 'C':
if (! predicate_string.empty())
predicate_string += "&";
predicate_string += "X";
break;
case 'U':
if (! predicate_string.empty())
predicate_string += "&";
predicate_string += "!X";
break;
case 'R':
if (! predicate_string.empty())
predicate_string += "&";
predicate_string += "R";
break;
// Customizing output
case 'F':
format_string = optarg;
break;
#if 0
case 'E':
show_empty = true;
break;
#endif
case 'n':
show_subtotals = false;
break;
case 's':
show_expanded = true;
break;
case 'S':
sort_string = optarg;
break;
case 'o':
show_related = true;
break;
case 'l':
if (! predicate_string.empty())
predicate_string += "&";
predicate_string += "(";
predicate_string += optarg;
predicate_string += ")";
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_expr = optarg;
break;
case 'T':
total_expr = optarg;
break;
case 'O':
value_expr = "a";
total_expr = "T";
break;
case 'B':
value_expr = "c";
total_expr = "C";
break;
case 'V':
ledger::show_commodities_revalued = true;
value_expr = "v";
total_expr = "V";
break;
case 'G':
ledger::show_commodities_revalued =
ledger::show_commodities_revalued_only = true;
value_expr = "c";
total_expr = "G";
break;
case 'A':
value_expr = "a";
total_expr = "MT";
break;
case 'D':
value_expr = "a";
total_expr = "DMT";
break;
case 'Z':
value_expr = "a";
total_expr = "MDMT";
break;
#if 0
case 'W':
value_expr = "a";
total_expr = "MD(MT*(d-b/e-b))";
break;
case 'X':
value_expr = "a";
total_expr = "a+MD(MT*(d-b/e-b))";
break;
#endif
default:
assert(0);
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;
try {
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, journal);
} 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, journal);
}
}
// 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);
journal->sources.push_back(path);
entry_count += ledger::parse_textual_ledger(db, journal, journal->master);
}
}
catch (ledger::error& err) {
std::cerr << "Fatal: " << err.what() << std::endl;
return 1;
}
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, journal) ? 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;
}
show_expanded = true;
if (! predicate_string.empty())
predicate_string += "&";
if (argv[index][0] == '-') {
predicate_string += "(!/";
predicate_string += argv[index] + 1;
} else {
predicate_string += "(/";
predicate_string += argv[index];
}
predicate_string += "/)";
}
for (; index < argc; index++) {
show_expanded = true;
if (! predicate_string.empty())
predicate_string += "&";
if (argv[index][0] == '-') {
predicate_string += "(!//";
predicate_string += argv[index] + 1;
} else {
predicate_string += "(//";
predicate_string += argv[index];
}
predicate_string += "/)";
}
// Compile the predicate
if (! predicate_string.empty()) {
#ifdef DEBUG
if (debug)
std::cerr << "predicate = " << predicate_string << std::endl;
#endif
predicate = ledger::parse_expr(predicate_string);
}
// Compile the sorting string
if (! sort_string.empty())
sort_order = ledger::parse_expr(sort_string);
// Setup the meaning of %t and %T encountered in format strings
ledger::format_t::value_expr = ledger::parse_expr(value_expr);
ledger::format_t::total_expr = ledger::parse_expr(total_expr);
// Now handle the command that was identified above.
if (command == "print") {
#if 0
if (ledger::item_t * top
= ledger::walk_entries(journal->entries.begin(),
journal->entries.end(), predicate,
show_related, show_inverted)) {
ledger::format_t * format = new ledger::format_t(format_string);
ledger::entry_report(std::cout, top, *format);
#ifdef DEBUG
delete top;
delete format;
#endif
}
#endif
}
else if (command == "equity") {
#if 0
if (ledger::item_t * top
= ledger::walk_accounts(journal->master, predicate, show_subtotals)) {
ledger::format_t * format = new ledger::format_t(format_string);
ledger::entry_report(std::cout, top, predicate, *format);
#ifdef DEBUG
delete top;
delete format;
#endif
}
#endif
}
else if (! sort_order && ! show_related &&
(command == "balance" || command == "bal")) {
if (ledger::item_t * top
= ledger::walk_accounts(journal->master, predicate, show_subtotals)) {
ledger::format_t * format
= new ledger::format_t(format_string.empty() ?
ledger::bal_fmt : format_string);
ledger::balance_report(std::cout, top, predicate, sort_order, *format,
show_expanded, show_subtotals);
#ifdef DEBUG
delete format;
delete top;
#endif
}
}
else if (command == "balance" || command == "bal") {
if (ledger::item_t * list
= ledger::walk_entries(journal->entries.begin(),
journal->entries.end(), predicate,
show_related, show_inverted))
if (ledger::item_t * top
= ledger::walk_items(list, journal->master, predicate,
show_subtotals)) {
ledger::format_t * format
= new ledger::format_t(format_string.empty() ?
ledger::bal_fmt : format_string);
ledger::balance_report(std::cout, top, predicate, sort_order, *format,
show_expanded, show_subtotals);
#ifdef DEBUG
delete format;
delete top;
delete list;
#endif
}
}
else if (command == "register" || command == "reg") {
if (show_related)
show_inverted = true;
if (ledger::item_t * top
= ledger::walk_entries(journal->entries.begin(),
journal->entries.end(), predicate,
show_related, show_inverted)) {
std::string first_line_format;
std::string next_lines_format;
const char * f = (format_string.empty() ?
ledger::reg_fmt.c_str() : 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_string;
next_lines_format = format_string;
}
ledger::format_t * format = new ledger::format_t(first_line_format);
ledger::format_t * nformat = new ledger::format_t(next_lines_format);
ledger::register_report(std::cout, top, predicate, sort_order,
*format, *nformat, show_expanded);
#ifdef DEBUG
delete nformat;
delete format;
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, journal, std::getenv("LEDGER"));
}
#ifdef DEBUG
delete journal;
if (predicate)
delete predicate;
if (sort_order)
delete sort_order;
if (ledger::format_t::value_expr)
delete ledger::format_t::value_expr;
if (ledger::format_t::total_expr)
delete ledger::format_t::total_expr;
// jww (2004-07-30): This should be moved into some kind of
// "ledger::shutdown" function.
for (ledger::commodities_map::iterator i
= ledger::commodity_t::commodities.begin();
i != ledger::commodity_t::commodities.end();
i++)
delete (*i).second;
#endif
return 0;
}
// main.cc ends here.
Reference in a new issue View git blame Copy permalink