With -n, the first argument is parsed as a string containing
subarguments. Otherwise, each argument is parsed as a separate
argument.
In short, the -n mode mimicks what happens when the query expr after "="
is parsed for automated expressions. The non -n mode mimicks what
happens at the command line for users.
If you have a typed metadata key which contains an amount, you can use
--inject=KEY to inject a posting with that amount wherever a match
occurs. There are two main forms of usage:
2010-06-18 Sample
; Key:: $100
Expenses:Food $100.00
Assets:Checking
The command would be:
ledger reg --inject=Key
In the above, transactional form, a posting under the account "Key" will
be injected before the first posting reported for this transaction.
It's amount will be $100. This only happens once for the whole
transaction.
It is also possible to associate the key with a posting:
2010-06-18 Sample
Expenses:Food $100.00
; Key:: $100
Assets:Checking
Now the injected posting is generated whenever that particular post is
reported.
If a posting has the metadata field "Payee" set to a string, that will
be used as the payee name for that posting. This affects the register
report, the payees report, and the --by-payee option.
This is useful because sometimes I send, say, 4 checks at a time to my
bank. So on my bank statement, this is all just one amount:
2010-06-17 Sample
Assets:Bank $400.00
Income:Check1 $-100.00
Income:Check2 $-100.00
Income:Check3 $-100.00
Income:Check4 $-100.00
Though it's important that the Assets:Bank posting be a single posting
of $400 value, I'd like for income reports to show whom each check came
from. Now I can say:
2010-06-17 Sample
Assets:Bank $400.00
Income:Check1 $-100.00 ; Payee: Person One
Income:Check2 $-100.00 ; Payee: Person Two
Income:Check3 $-100.00 ; Payee: Person Three
Income:Check4 $-100.00 ; Payee: Person Four
When I report this, it appears as:
10-Jun-17 Sample Assets:Bank $400.00 $400.00
Person One Income:Check1 $-100.00 $300.00
Person Two Income:Check2 $-100.00 $200.00
Person Three Income:Check3 $-100.00 $100.00
Person Four Income:Check4 $-100.00 0
This shows that they are all in the same transaction (which is why the
date is not repeated), but they have different payees.
Thus, an expression can know if the context in which it's being
evaluated requires a string, and if so, determine it's output
accordingly. For example:
account ; returns the full name of the posting's account
account.total ; here the context is SCOPE, so account is an obj
These can occur in many places:
; Within an automated transaction, the assert is evaluated every time
; a posting is matched, with the expression context set to the
; matching posting.
= /Food/
assert account("Expenses:Food").total >= $100
2010-06-12 Sample
Expenses:Food $100
Assets:Checking
; At file scope, the expression is evaluated with "global" scope.
assert account("Expenses:Food").total == $100
; At the top of a transction, the assertion's scope is the
; transaction. After a posting, the scope is that posting. Note
; however that account totals are only adjusted after successful
; parsing of a transaction, which means that all the assertions below
; are true, even though it appears as though the middle posting should
; affect the total immediately (which is not the case).
2010-06-12 Sample 2
assert account("Expenses:Food").total == $100
Expenses:Food $50
assert account("Expenses:Food").total == $100
Assets:Checking
assert account("Expenses:Food").total == $100
For example, consider the following automated transaction:
= /Food/
; Next Date:: date + 10
(Expenses:Tax) 1.00
; Next Date:: date + 20
This will add a metadata field named 'Next Date' to the _matching
posting_, with a value that is 10 days later than that posting. It will
also generate a new posting for that transaction, whose amount is the
same as the matching posting. Further, it will add a 'Next Date'
metadata tag to the _generated posting_ whose value is 20 days later
than the date of the matching posting.
For example, just the word "account" returns the name of the current
posting's account, but account("Expenses:Food") returns the actual
account object, so that it's total may be accessed.
