{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE Rank2Types #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TupleSections #-}
module Hledger.Data.Journal (
JournalParser,
ErroringJournalParser,
addPriceDirective,
addTransactionModifier,
addPeriodicTransaction,
addTransaction,
journalInferMarketPricesFromTransactions,
journalApplyCommodityStyles,
commodityStylesFromAmounts,
journalCommodityStyles,
journalToCost,
journalAddInferredEquityPostings,
journalAddPricesFromEquity,
journalReverse,
journalSetLastReadTime,
journalRenumberAccountDeclarations,
journalPivot,
filterJournalTransactions,
filterJournalPostings,
filterJournalRelatedPostings,
filterJournalAmounts,
filterTransactionAmounts,
filterTransactionPostings,
filterTransactionPostingsExtra,
filterTransactionRelatedPostings,
filterPostingAmount,
journalMapTransactions,
journalMapPostings,
journalMapPostingAmounts,
journalAccountNamesUsed,
journalAccountNamesImplied,
journalAccountNamesDeclared,
journalAccountNamesDeclaredOrUsed,
journalAccountNamesDeclaredOrImplied,
journalLeafAccountNamesDeclared,
journalAccountNames,
journalLeafAccountNames,
journalAccountNameTree,
journalAccountTags,
journalInheritedAccountTags,
journalPayeesDeclared,
journalPayeesUsed,
journalPayeesDeclaredOrUsed,
journalCommoditiesDeclared,
journalCommodities,
journalDateSpan,
journalDateSpanBothDates,
journalStartDate,
journalEndDate,
journalLastDay,
journalDescriptions,
journalFilePath,
journalFilePaths,
journalTransactionAt,
journalNextTransaction,
journalPrevTransaction,
journalPostings,
journalTransactionsSimilarTo,
journalAccountType,
journalAccountTypes,
journalAddAccountTypes,
journalPostingsAddAccountTags,
journalConversionAccount,
canonicalStyleFrom,
nulljournal,
journalConcat,
journalNumberTransactions,
journalNumberAndTieTransactions,
journalUntieTransactions,
journalModifyTransactions,
journalApplyAliases,
dbgJournalAcctDeclOrder,
samplejournal,
samplejournalMaybeExplicit,
tests_Journal
)
where
import Control.Applicative ((<|>))
import Control.Monad.Except (ExceptT(..))
import Control.Monad.State.Strict (StateT)
import Data.Char (toUpper, isDigit)
import Data.Default (Default(..))
import Data.Foldable (toList)
import Data.List ((\\), find, foldl', sortBy, union, intercalate)
import Data.List.Extra (nubSort)
import qualified Data.Map.Strict as M
import Data.Maybe (catMaybes, fromMaybe, mapMaybe, maybeToList)
import qualified Data.Set as S
import Data.Text (Text)
import qualified Data.Text as T
import Safe (headMay, headDef, maximumMay, minimumMay)
import Data.Time.Calendar (Day, addDays, fromGregorian)
import Data.Time.Clock.POSIX (POSIXTime)
import Data.Tree (Tree(..), flatten)
import Text.Printf (printf)
import Text.Megaparsec (ParsecT)
import Text.Megaparsec.Custom (FinalParseError)
import Hledger.Utils
import Hledger.Data.Types
import Hledger.Data.AccountName
import Hledger.Data.Amount
import Hledger.Data.Posting
import Hledger.Data.Transaction
import Hledger.Data.TransactionModifier
import Hledger.Data.Valuation
import Hledger.Query
import System.FilePath (takeFileName)
type JournalParser m a = StateT Journal (ParsecT HledgerParseErrorData Text m) a
type ErroringJournalParser m a =
StateT Journal (ParsecT HledgerParseErrorData Text (ExceptT FinalParseError m)) a
instance Show Journal where
show :: Journal -> RegexError
show Journal
j
| Int
debugLevel forall a. Ord a => a -> a -> Bool
< Int
3 = forall r. PrintfType r => RegexError -> r
printf RegexError
"Journal %s with %d transactions, %d accounts"
(Journal -> RegexError
journalFilePath Journal
j)
(forall (t :: * -> *) a. Foldable t => t a -> Int
length forall a b. (a -> b) -> a -> b
$ Journal -> [Transaction]
jtxns Journal
j)
(forall (t :: * -> *) a. Foldable t => t a -> Int
length [TagName]
accounts)
| Int
debugLevel forall a. Ord a => a -> a -> Bool
< Int
6 = forall r. PrintfType r => RegexError -> r
printf RegexError
"Journal %s with %d transactions, %d accounts: %s"
(Journal -> RegexError
journalFilePath Journal
j)
(forall (t :: * -> *) a. Foldable t => t a -> Int
length forall a b. (a -> b) -> a -> b
$ Journal -> [Transaction]
jtxns Journal
j)
(forall (t :: * -> *) a. Foldable t => t a -> Int
length [TagName]
accounts)
(forall a. Show a => a -> RegexError
show [TagName]
accounts)
| Bool
otherwise = forall r. PrintfType r => RegexError -> r
printf RegexError
"Journal %s with %d transactions, %d accounts: %s, commodity styles: %s"
(Journal -> RegexError
journalFilePath Journal
j)
(forall (t :: * -> *) a. Foldable t => t a -> Int
length forall a b. (a -> b) -> a -> b
$ Journal -> [Transaction]
jtxns Journal
j)
(forall (t :: * -> *) a. Foldable t => t a -> Int
length [TagName]
accounts)
(forall a. Show a => a -> RegexError
show [TagName]
accounts)
(forall a. Show a => a -> RegexError
show forall a b. (a -> b) -> a -> b
$ Journal -> Map TagName AmountStyle
jinferredcommodities Journal
j)
where accounts :: [TagName]
accounts = forall a. (a -> Bool) -> [a] -> [a]
filter (forall a. Eq a => a -> a -> Bool
/= TagName
"root") forall a b. (a -> b) -> a -> b
$ forall a. Tree a -> [a]
flatten forall a b. (a -> b) -> a -> b
$ Journal -> Tree TagName
journalAccountNameTree Journal
j
instance Semigroup Journal where Journal
j1 <> :: Journal -> Journal -> Journal
<> Journal
j2 = Journal
j1 Journal -> Journal -> Journal
`journalConcat` Journal
j2
journalConcat :: Journal -> Journal -> Journal
journalConcat :: Journal -> Journal -> Journal
journalConcat Journal
j1 Journal
j2 =
let
f1 :: RegexError
f1 = ShowS
takeFileName forall a b. (a -> b) -> a -> b
$ Journal -> RegexError
journalFilePath Journal
j1
f2 :: RegexError
f2 = forall b a. b -> (a -> b) -> Maybe a -> b
maybe RegexError
"(unknown)" ShowS
takeFileName forall a b. (a -> b) -> a -> b
$ forall a. [a] -> Maybe a
headMay forall a b. (a -> b) -> a -> b
$ Journal -> [RegexError]
jincludefilestack Journal
j2
in
RegexError -> Journal -> Journal
dbgJournalAcctDeclOrder (RegexError
"journalConcat: " forall a. Semigroup a => a -> a -> a
<> RegexError
f1 forall a. Semigroup a => a -> a -> a
<> RegexError
" <> " forall a. Semigroup a => a -> a -> a
<> RegexError
f2 forall a. Semigroup a => a -> a -> a
<> RegexError
", acct decls renumbered: ") forall a b. (a -> b) -> a -> b
$
Journal -> Journal
journalRenumberAccountDeclarations forall a b. (a -> b) -> a -> b
$
RegexError -> Journal -> Journal
dbgJournalAcctDeclOrder (RegexError
"journalConcat: " forall a. Semigroup a => a -> a -> a
<> RegexError
f1 forall a. Semigroup a => a -> a -> a
<> RegexError
" <> " forall a. Semigroup a => a -> a -> a
<> RegexError
f2 forall a. Semigroup a => a -> a -> a
<> RegexError
", acct decls : ") forall a b. (a -> b) -> a -> b
$
Journal {
jparsedefaultyear :: Maybe Integer
jparsedefaultyear = Journal -> Maybe Integer
jparsedefaultyear Journal
j2
,jparsedefaultcommodity :: Maybe (TagName, AmountStyle)
jparsedefaultcommodity = Journal -> Maybe (TagName, AmountStyle)
jparsedefaultcommodity Journal
j2
,jparsedecimalmark :: Maybe Char
jparsedecimalmark = Journal -> Maybe Char
jparsedecimalmark Journal
j2
,jparseparentaccounts :: [TagName]
jparseparentaccounts = Journal -> [TagName]
jparseparentaccounts Journal
j2
,jparsealiases :: [AccountAlias]
jparsealiases = Journal -> [AccountAlias]
jparsealiases Journal
j2
,jparsetimeclockentries :: [TimeclockEntry]
jparsetimeclockentries = Journal -> [TimeclockEntry]
jparsetimeclockentries Journal
j1 forall a. Semigroup a => a -> a -> a
<> Journal -> [TimeclockEntry]
jparsetimeclockentries Journal
j2
,jincludefilestack :: [RegexError]
jincludefilestack = Journal -> [RegexError]
jincludefilestack Journal
j2
,jdeclaredpayees :: [(TagName, PayeeDeclarationInfo)]
jdeclaredpayees = Journal -> [(TagName, PayeeDeclarationInfo)]
jdeclaredpayees Journal
j1 forall a. Semigroup a => a -> a -> a
<> Journal -> [(TagName, PayeeDeclarationInfo)]
jdeclaredpayees Journal
j2
,jdeclaredaccounts :: [(TagName, AccountDeclarationInfo)]
jdeclaredaccounts = Journal -> [(TagName, AccountDeclarationInfo)]
jdeclaredaccounts Journal
j1 forall a. Semigroup a => a -> a -> a
<> Journal -> [(TagName, AccountDeclarationInfo)]
jdeclaredaccounts Journal
j2
,jdeclaredaccounttags :: Map TagName [Tag]
jdeclaredaccounttags = Journal -> Map TagName [Tag]
jdeclaredaccounttags Journal
j1 forall a. Semigroup a => a -> a -> a
<> Journal -> Map TagName [Tag]
jdeclaredaccounttags Journal
j2
,jdeclaredaccounttypes :: Map AccountType [TagName]
jdeclaredaccounttypes = Journal -> Map AccountType [TagName]
jdeclaredaccounttypes Journal
j1 forall a. Semigroup a => a -> a -> a
<> Journal -> Map AccountType [TagName]
jdeclaredaccounttypes Journal
j2
,jaccounttypes :: Map TagName AccountType
jaccounttypes = Journal -> Map TagName AccountType
jaccounttypes Journal
j1 forall a. Semigroup a => a -> a -> a
<> Journal -> Map TagName AccountType
jaccounttypes Journal
j2
,jglobalcommoditystyles :: Map TagName AmountStyle
jglobalcommoditystyles = Journal -> Map TagName AmountStyle
jglobalcommoditystyles Journal
j1 forall a. Semigroup a => a -> a -> a
<> Journal -> Map TagName AmountStyle
jglobalcommoditystyles Journal
j2
,jcommodities :: Map TagName Commodity
jcommodities = Journal -> Map TagName Commodity
jcommodities Journal
j1 forall a. Semigroup a => a -> a -> a
<> Journal -> Map TagName Commodity
jcommodities Journal
j2
,jinferredcommodities :: Map TagName AmountStyle
jinferredcommodities = Journal -> Map TagName AmountStyle
jinferredcommodities Journal
j1 forall a. Semigroup a => a -> a -> a
<> Journal -> Map TagName AmountStyle
jinferredcommodities Journal
j2
,jpricedirectives :: [PriceDirective]
jpricedirectives = Journal -> [PriceDirective]
jpricedirectives Journal
j1 forall a. Semigroup a => a -> a -> a
<> Journal -> [PriceDirective]
jpricedirectives Journal
j2
,jinferredmarketprices :: [MarketPrice]
jinferredmarketprices = Journal -> [MarketPrice]
jinferredmarketprices Journal
j1 forall a. Semigroup a => a -> a -> a
<> Journal -> [MarketPrice]
jinferredmarketprices Journal
j2
,jtxnmodifiers :: [TransactionModifier]
jtxnmodifiers = Journal -> [TransactionModifier]
jtxnmodifiers Journal
j1 forall a. Semigroup a => a -> a -> a
<> Journal -> [TransactionModifier]
jtxnmodifiers Journal
j2
,jperiodictxns :: [PeriodicTransaction]
jperiodictxns = Journal -> [PeriodicTransaction]
jperiodictxns Journal
j1 forall a. Semigroup a => a -> a -> a
<> Journal -> [PeriodicTransaction]
jperiodictxns Journal
j2
,jtxns :: [Transaction]
jtxns = Journal -> [Transaction]
jtxns Journal
j1 forall a. Semigroup a => a -> a -> a
<> Journal -> [Transaction]
jtxns Journal
j2
,jfinalcommentlines :: TagName
jfinalcommentlines = Journal -> TagName
jfinalcommentlines Journal
j2
,jfiles :: [(RegexError, TagName)]
jfiles = Journal -> [(RegexError, TagName)]
jfiles Journal
j1 forall a. Semigroup a => a -> a -> a
<> Journal -> [(RegexError, TagName)]
jfiles Journal
j2
,jlastreadtime :: POSIXTime
jlastreadtime = forall a. Ord a => a -> a -> a
max (Journal -> POSIXTime
jlastreadtime Journal
j1) (Journal -> POSIXTime
jlastreadtime Journal
j2)
}
journalRenumberAccountDeclarations :: Journal -> Journal
journalRenumberAccountDeclarations :: Journal -> Journal
journalRenumberAccountDeclarations Journal
j = Journal
j{jdeclaredaccounts :: [(TagName, AccountDeclarationInfo)]
jdeclaredaccounts=[(TagName, AccountDeclarationInfo)]
jdas'}
where
jdas' :: [(TagName, AccountDeclarationInfo)]
jdas' = [(TagName
a, AccountDeclarationInfo
adi{adideclarationorder :: Int
adideclarationorder=Int
n}) | (Int
n, (TagName
a,AccountDeclarationInfo
adi)) <- forall a b. [a] -> [b] -> [(a, b)]
zip [Int
1..] forall a b. (a -> b) -> a -> b
$ Journal -> [(TagName, AccountDeclarationInfo)]
jdeclaredaccounts Journal
j]
dbgJournalAcctDeclOrder :: String -> Journal -> Journal
dbgJournalAcctDeclOrder :: RegexError -> Journal -> Journal
dbgJournalAcctDeclOrder RegexError
prefix =
forall a. Int -> (a -> RegexError) -> a -> a
traceOrLogAtWith Int
5 ((RegexError
prefixforall a. [a] -> [a] -> [a]
++) forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(TagName, AccountDeclarationInfo)] -> RegexError
showAcctDeclsSummary forall b c a. (b -> c) -> (a -> b) -> a -> c
. Journal -> [(TagName, AccountDeclarationInfo)]
jdeclaredaccounts)
where
showAcctDeclsSummary :: [(AccountName,AccountDeclarationInfo)] -> String
showAcctDeclsSummary :: [(TagName, AccountDeclarationInfo)] -> RegexError
showAcctDeclsSummary [(TagName, AccountDeclarationInfo)]
adis
| forall (t :: * -> *) a. Foldable t => t a -> Int
length [(TagName, AccountDeclarationInfo)]
adis forall a. Ord a => a -> a -> Bool
< (Int
2forall a. Num a => a -> a -> a
*Int
nforall a. Num a => a -> a -> a
+Int
2) = RegexError
"[" forall a. Semigroup a => a -> a -> a
<> [(TagName, AccountDeclarationInfo)] -> RegexError
showadis [(TagName, AccountDeclarationInfo)]
adis forall a. Semigroup a => a -> a -> a
<> RegexError
"]"
| Bool
otherwise =
RegexError
"[" forall a. Semigroup a => a -> a -> a
<> [(TagName, AccountDeclarationInfo)] -> RegexError
showadis (forall a. Int -> [a] -> [a]
take Int
n [(TagName, AccountDeclarationInfo)]
adis) forall a. Semigroup a => a -> a -> a
<> RegexError
" ... " forall a. Semigroup a => a -> a -> a
<> [(TagName, AccountDeclarationInfo)] -> RegexError
showadis (forall a. Int -> [a] -> [a]
takelast Int
n [(TagName, AccountDeclarationInfo)]
adis) forall a. Semigroup a => a -> a -> a
<> RegexError
"]"
where
n :: Int
n = Int
3
showadis :: [(TagName, AccountDeclarationInfo)] -> RegexError
showadis = forall a. [a] -> [[a]] -> [a]
intercalate RegexError
", " forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map (TagName, AccountDeclarationInfo) -> RegexError
showadi
showadi :: (TagName, AccountDeclarationInfo) -> RegexError
showadi (TagName
a,AccountDeclarationInfo
adi) = RegexError
"("forall a. Semigroup a => a -> a -> a
<>forall a. Show a => a -> RegexError
show (AccountDeclarationInfo -> Int
adideclarationorder AccountDeclarationInfo
adi)forall a. Semigroup a => a -> a -> a
<>RegexError
","forall a. Semigroup a => a -> a -> a
<>TagName -> RegexError
T.unpack TagName
aforall a. Semigroup a => a -> a -> a
<>RegexError
")"
takelast :: Int -> [a] -> [a]
takelast Int
n' = forall a. [a] -> [a]
reverse forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> [a] -> [a]
take Int
n' forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> [a]
reverse
instance Default Journal where
def :: Journal
def = Journal
nulljournal
nulljournal :: Journal
nulljournal :: Journal
nulljournal = Journal {
jparsedefaultyear :: Maybe Integer
jparsedefaultyear = forall a. Maybe a
Nothing
,jparsedefaultcommodity :: Maybe (TagName, AmountStyle)
jparsedefaultcommodity = forall a. Maybe a
Nothing
,jparsedecimalmark :: Maybe Char
jparsedecimalmark = forall a. Maybe a
Nothing
,jparseparentaccounts :: [TagName]
jparseparentaccounts = []
,jparsealiases :: [AccountAlias]
jparsealiases = []
,jparsetimeclockentries :: [TimeclockEntry]
jparsetimeclockentries = []
,jincludefilestack :: [RegexError]
jincludefilestack = []
,jdeclaredpayees :: [(TagName, PayeeDeclarationInfo)]
jdeclaredpayees = []
,jdeclaredaccounts :: [(TagName, AccountDeclarationInfo)]
jdeclaredaccounts = []
,jdeclaredaccounttags :: Map TagName [Tag]
jdeclaredaccounttags = forall k a. Map k a
M.empty
,jdeclaredaccounttypes :: Map AccountType [TagName]
jdeclaredaccounttypes = forall k a. Map k a
M.empty
,jaccounttypes :: Map TagName AccountType
jaccounttypes = forall k a. Map k a
M.empty
,jglobalcommoditystyles :: Map TagName AmountStyle
jglobalcommoditystyles = forall k a. Map k a
M.empty
,jcommodities :: Map TagName Commodity
jcommodities = forall k a. Map k a
M.empty
,jinferredcommodities :: Map TagName AmountStyle
jinferredcommodities = forall k a. Map k a
M.empty
,jpricedirectives :: [PriceDirective]
jpricedirectives = []
,jinferredmarketprices :: [MarketPrice]
jinferredmarketprices = []
,jtxnmodifiers :: [TransactionModifier]
jtxnmodifiers = []
,jperiodictxns :: [PeriodicTransaction]
jperiodictxns = []
,jtxns :: [Transaction]
jtxns = []
,jfinalcommentlines :: TagName
jfinalcommentlines = TagName
""
,jfiles :: [(RegexError, TagName)]
jfiles = []
,jlastreadtime :: POSIXTime
jlastreadtime = POSIXTime
0
}
journalFilePath :: Journal -> FilePath
journalFilePath :: Journal -> RegexError
journalFilePath = forall a b. (a, b) -> a
fst forall b c a. (b -> c) -> (a -> b) -> a -> c
. Journal -> (RegexError, TagName)
mainfile
journalFilePaths :: Journal -> [FilePath]
journalFilePaths :: Journal -> [RegexError]
journalFilePaths = forall a b. (a -> b) -> [a] -> [b]
map forall a b. (a, b) -> a
fst forall b c a. (b -> c) -> (a -> b) -> a -> c
. Journal -> [(RegexError, TagName)]
jfiles
mainfile :: Journal -> (FilePath, Text)
mainfile :: Journal -> (RegexError, TagName)
mainfile = forall a. a -> [a] -> a
headDef (RegexError
"(unknown)", TagName
"") forall b c a. (b -> c) -> (a -> b) -> a -> c
. Journal -> [(RegexError, TagName)]
jfiles
addTransaction :: Transaction -> Journal -> Journal
addTransaction :: Transaction -> Journal -> Journal
addTransaction Transaction
t Journal
j = Journal
j { jtxns :: [Transaction]
jtxns = Transaction
t forall a. a -> [a] -> [a]
: Journal -> [Transaction]
jtxns Journal
j }
addTransactionModifier :: TransactionModifier -> Journal -> Journal
addTransactionModifier :: TransactionModifier -> Journal -> Journal
addTransactionModifier TransactionModifier
mt Journal
j = Journal
j { jtxnmodifiers :: [TransactionModifier]
jtxnmodifiers = TransactionModifier
mt forall a. a -> [a] -> [a]
: Journal -> [TransactionModifier]
jtxnmodifiers Journal
j }
addPeriodicTransaction :: PeriodicTransaction -> Journal -> Journal
addPeriodicTransaction :: PeriodicTransaction -> Journal -> Journal
addPeriodicTransaction PeriodicTransaction
pt Journal
j = Journal
j { jperiodictxns :: [PeriodicTransaction]
jperiodictxns = PeriodicTransaction
pt forall a. a -> [a] -> [a]
: Journal -> [PeriodicTransaction]
jperiodictxns Journal
j }
addPriceDirective :: PriceDirective -> Journal -> Journal
addPriceDirective :: PriceDirective -> Journal -> Journal
addPriceDirective PriceDirective
h Journal
j = Journal
j { jpricedirectives :: [PriceDirective]
jpricedirectives = PriceDirective
h forall a. a -> [a] -> [a]
: Journal -> [PriceDirective]
jpricedirectives Journal
j }
journalTransactionAt :: Journal -> Integer -> Maybe Transaction
journalTransactionAt :: Journal -> Integer -> Maybe Transaction
journalTransactionAt Journal{jtxns :: Journal -> [Transaction]
jtxns=[Transaction]
ts} Integer
i =
forall a. [a] -> Maybe a
headMay [Transaction
t | Transaction
t <- [Transaction]
ts, Transaction -> Integer
tindex Transaction
t forall a. Eq a => a -> a -> Bool
== Integer
i]
journalNextTransaction :: Journal -> Transaction -> Maybe Transaction
journalNextTransaction :: Journal -> Transaction -> Maybe Transaction
journalNextTransaction Journal
j Transaction
t = Journal -> Integer -> Maybe Transaction
journalTransactionAt Journal
j (Transaction -> Integer
tindex Transaction
t forall a. Num a => a -> a -> a
+ Integer
1)
journalPrevTransaction :: Journal -> Transaction -> Maybe Transaction
journalPrevTransaction :: Journal -> Transaction -> Maybe Transaction
journalPrevTransaction Journal
j Transaction
t = Journal -> Integer -> Maybe Transaction
journalTransactionAt Journal
j (Transaction -> Integer
tindex Transaction
t forall a. Num a => a -> a -> a
- Integer
1)
journalPostings :: Journal -> [Posting]
journalPostings :: Journal -> [Posting]
journalPostings = forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Transaction -> [Posting]
tpostings forall b c a. (b -> c) -> (a -> b) -> a -> c
. Journal -> [Transaction]
jtxns
journalCommoditiesDeclared :: Journal -> [CommoditySymbol]
journalCommoditiesDeclared :: Journal -> [TagName]
journalCommoditiesDeclared = forall k a. Map k a -> [k]
M.keys forall b c a. (b -> c) -> (a -> b) -> a -> c
. Journal -> Map TagName Commodity
jcommodities
journalCommodities :: Journal -> S.Set CommoditySymbol
journalCommodities :: Journal -> Set TagName
journalCommodities Journal
j = forall k a. Map k a -> Set k
M.keysSet (Journal -> Map TagName Commodity
jcommodities Journal
j) forall a. Semigroup a => a -> a -> a
<> forall k a. Map k a -> Set k
M.keysSet (Journal -> Map TagName AmountStyle
jinferredcommodities Journal
j)
journalDescriptions :: Journal -> [Text]
journalDescriptions :: Journal -> [TagName]
journalDescriptions = forall a. Ord a => [a] -> [a]
nubSort forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map Transaction -> TagName
tdescription forall b c a. (b -> c) -> (a -> b) -> a -> c
. Journal -> [Transaction]
jtxns
journalPayeesDeclared :: Journal -> [Payee]
journalPayeesDeclared :: Journal -> [TagName]
journalPayeesDeclared = forall a. Ord a => [a] -> [a]
nubSort forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map forall a b. (a, b) -> a
fst forall b c a. (b -> c) -> (a -> b) -> a -> c
. Journal -> [(TagName, PayeeDeclarationInfo)]
jdeclaredpayees
journalPayeesUsed :: Journal -> [Payee]
journalPayeesUsed :: Journal -> [TagName]
journalPayeesUsed = forall a. Ord a => [a] -> [a]
nubSort forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map Transaction -> TagName
transactionPayee forall b c a. (b -> c) -> (a -> b) -> a -> c
. Journal -> [Transaction]
jtxns
journalPayeesDeclaredOrUsed :: Journal -> [Payee]
journalPayeesDeclaredOrUsed :: Journal -> [TagName]
journalPayeesDeclaredOrUsed Journal
j = forall (t :: * -> *) a. Foldable t => t a -> [a]
toList forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap forall a. Ord a => [a] -> Set a
S.fromList
[Journal -> [TagName]
journalPayeesDeclared Journal
j, Journal -> [TagName]
journalPayeesUsed Journal
j]
journalAccountNamesUsed :: Journal -> [AccountName]
journalAccountNamesUsed :: Journal -> [TagName]
journalAccountNamesUsed = [Posting] -> [TagName]
accountNamesFromPostings forall b c a. (b -> c) -> (a -> b) -> a -> c
. Journal -> [Posting]
journalPostings
journalAccountNamesImplied :: Journal -> [AccountName]
journalAccountNamesImplied :: Journal -> [TagName]
journalAccountNamesImplied = [TagName] -> [TagName]
expandAccountNames forall b c a. (b -> c) -> (a -> b) -> a -> c
. Journal -> [TagName]
journalAccountNamesUsed
journalAccountNamesDeclared :: Journal -> [AccountName]
journalAccountNamesDeclared :: Journal -> [TagName]
journalAccountNamesDeclared = forall a. Ord a => [a] -> [a]
nubSort forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map forall a b. (a, b) -> a
fst forall b c a. (b -> c) -> (a -> b) -> a -> c
. Journal -> [(TagName, AccountDeclarationInfo)]
jdeclaredaccounts
journalLeafAccountNamesDeclared :: Journal -> [AccountName]
journalLeafAccountNamesDeclared :: Journal -> [TagName]
journalLeafAccountNamesDeclared = forall a. Tree a -> [a]
treeLeaves forall b c a. (b -> c) -> (a -> b) -> a -> c
. [TagName] -> Tree TagName
accountNameTreeFrom forall b c a. (b -> c) -> (a -> b) -> a -> c
. Journal -> [TagName]
journalAccountNamesDeclared
journalAccountNamesDeclaredOrUsed :: Journal -> [AccountName]
journalAccountNamesDeclaredOrUsed :: Journal -> [TagName]
journalAccountNamesDeclaredOrUsed Journal
j = forall (t :: * -> *) a. Foldable t => t a -> [a]
toList forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap forall a. Ord a => [a] -> Set a
S.fromList
[Journal -> [TagName]
journalAccountNamesDeclared Journal
j, Journal -> [TagName]
journalAccountNamesUsed Journal
j]
journalAccountNamesDeclaredOrImplied :: Journal -> [AccountName]
journalAccountNamesDeclaredOrImplied :: Journal -> [TagName]
journalAccountNamesDeclaredOrImplied Journal
j = forall (t :: * -> *) a. Foldable t => t a -> [a]
toList forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap forall a. Ord a => [a] -> Set a
S.fromList
[Journal -> [TagName]
journalAccountNamesDeclared Journal
j, [TagName] -> [TagName]
expandAccountNames forall a b. (a -> b) -> a -> b
$ Journal -> [TagName]
journalAccountNamesUsed Journal
j]
journalAccountNames :: Journal -> [AccountName]
journalAccountNames :: Journal -> [TagName]
journalAccountNames = Journal -> [TagName]
journalAccountNamesDeclaredOrImplied
journalLeafAccountNames :: Journal -> [AccountName]
journalLeafAccountNames :: Journal -> [TagName]
journalLeafAccountNames = forall a. Tree a -> [a]
treeLeaves forall b c a. (b -> c) -> (a -> b) -> a -> c
. Journal -> Tree TagName
journalAccountNameTree
journalAccountNameTree :: Journal -> Tree AccountName
journalAccountNameTree :: Journal -> Tree TagName
journalAccountNameTree = [TagName] -> Tree TagName
accountNameTreeFrom forall b c a. (b -> c) -> (a -> b) -> a -> c
. Journal -> [TagName]
journalAccountNamesDeclaredOrImplied
journalAccountTags :: Journal -> AccountName -> [Tag]
journalAccountTags :: Journal -> TagName -> [Tag]
journalAccountTags Journal{Map TagName [Tag]
jdeclaredaccounttags :: Map TagName [Tag]
jdeclaredaccounttags :: Journal -> Map TagName [Tag]
jdeclaredaccounttags} TagName
a = forall k a. Ord k => a -> k -> Map k a -> a
M.findWithDefault [] TagName
a Map TagName [Tag]
jdeclaredaccounttags
journalInheritedAccountTags :: Journal -> AccountName -> [Tag]
journalInheritedAccountTags :: Journal -> TagName -> [Tag]
journalInheritedAccountTags Journal
j TagName
a =
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' (\[Tag]
ts TagName
a' -> [Tag]
ts forall a. Eq a => [a] -> [a] -> [a]
`union` Journal -> TagName -> [Tag]
journalAccountTags Journal
j TagName
a') [] [TagName]
as
where
as :: [TagName]
as = TagName
a forall a. a -> [a] -> [a]
: TagName -> [TagName]
parentAccountNames TagName
a
journalTransactionsSimilarTo :: Journal -> Query -> Text -> Int -> [(Double,Transaction)]
journalTransactionsSimilarTo :: Journal -> Query -> TagName -> Int -> [(Double, Transaction)]
journalTransactionsSimilarTo Journal{[Transaction]
jtxns :: [Transaction]
jtxns :: Journal -> [Transaction]
jtxns} Query
q TagName
desc Int
n =
forall a. Int -> [a] -> [a]
take Int
n forall a b. (a -> b) -> a -> b
$
forall a. (a -> a -> Ordering) -> [a] -> [a]
sortBy (\(Double
s1,Transaction
t1) (Double
s2,Transaction
t2) -> forall a. Ord a => a -> a -> Ordering
compare (Double
s2,Transaction -> Day
tdate Transaction
t2) (Double
s1,Transaction -> Day
tdate Transaction
t1)) forall a b. (a -> b) -> a -> b
$
forall a. (a -> Bool) -> [a] -> [a]
filter ((forall a. Ord a => a -> a -> Bool
> Double
threshold)forall b c a. (b -> c) -> (a -> b) -> a -> c
.forall a b. (a, b) -> a
fst)
[(TagName -> TagName -> Double
compareDescriptions TagName
desc forall a b. (a -> b) -> a -> b
$ Transaction -> TagName
tdescription Transaction
t, Transaction
t) | Transaction
t <- [Transaction]
jtxns, Query
q Query -> Transaction -> Bool
`matchesTransaction` Transaction
t]
where
threshold :: Double
threshold = Double
0
compareDescriptions :: Text -> Text -> Double
compareDescriptions :: TagName -> TagName -> Double
compareDescriptions TagName
a TagName
b =
(if TagName
a TagName -> TagName -> Bool
`T.isInfixOf` TagName
b then (Double
0.5forall a. Num a => a -> a -> a
+) else forall a. a -> a
id) forall a b. (a -> b) -> a -> b
$
RegexError -> RegexError -> Double
compareStrings (TagName -> RegexError
simplify TagName
a) (TagName -> RegexError
simplify TagName
b)
where
simplify :: TagName -> RegexError
simplify = TagName -> RegexError
T.unpack forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool) -> TagName -> TagName
T.filter (Bool -> Bool
notforall b c a. (b -> c) -> (a -> b) -> a -> c
.Char -> Bool
isDigit)
compareStrings :: String -> String -> Double
compareStrings :: RegexError -> RegexError -> Double
compareStrings RegexError
"" RegexError
"" = Double
1
compareStrings [Char
_] RegexError
"" = Double
0
compareStrings RegexError
"" [Char
_] = Double
0
compareStrings [Char
a] [Char
b] = if Char -> Char
toUpper Char
a forall a. Eq a => a -> a -> Bool
== Char -> Char
toUpper Char
b then Double
1 else Double
0
compareStrings RegexError
s1 RegexError
s2 = Double
2 forall a. Num a => a -> a -> a
* Double
commonpairs forall a. Fractional a => a -> a -> a
/ Double
totalpairs
where
pairs1 :: Set RegexError
pairs1 = forall a. Ord a => [a] -> Set a
S.fromList forall a b. (a -> b) -> a -> b
$ RegexError -> [RegexError]
wordLetterPairs forall a b. (a -> b) -> a -> b
$ ShowS
uppercase RegexError
s1
pairs2 :: Set RegexError
pairs2 = forall a. Ord a => [a] -> Set a
S.fromList forall a b. (a -> b) -> a -> b
$ RegexError -> [RegexError]
wordLetterPairs forall a b. (a -> b) -> a -> b
$ ShowS
uppercase RegexError
s2
commonpairs :: Double
commonpairs = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ forall a. Set a -> Int
S.size forall a b. (a -> b) -> a -> b
$ forall a. Ord a => Set a -> Set a -> Set a
S.intersection Set RegexError
pairs1 Set RegexError
pairs2
totalpairs :: Double
totalpairs = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ forall a. Set a -> Int
S.size Set RegexError
pairs1 forall a. Num a => a -> a -> a
+ forall a. Set a -> Int
S.size Set RegexError
pairs2
wordLetterPairs :: String -> [String]
wordLetterPairs :: RegexError -> [RegexError]
wordLetterPairs = forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap RegexError -> [RegexError]
letterPairs forall b c a. (b -> c) -> (a -> b) -> a -> c
. RegexError -> [RegexError]
words
letterPairs :: String -> [String]
letterPairs :: RegexError -> [RegexError]
letterPairs (Char
a:Char
b:RegexError
rest) = [Char
a,Char
b] forall a. a -> [a] -> [a]
: RegexError -> [RegexError]
letterPairs (Char
bforall a. a -> [a] -> [a]
:RegexError
rest)
letterPairs RegexError
_ = []
journalConversionAccount :: Journal -> AccountName
journalConversionAccount :: Journal -> TagName
journalConversionAccount =
forall a. a -> [a] -> a
headDef (RegexError -> TagName
T.pack RegexError
"equity:conversion")
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall k a. Ord k => a -> k -> Map k a -> a
M.findWithDefault [] AccountType
Conversion
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Journal -> Map AccountType [TagName]
jdeclaredaccounttypes
journalAccountType :: Journal -> AccountName -> Maybe AccountType
journalAccountType :: Journal -> TagName -> Maybe AccountType
journalAccountType Journal{Map TagName AccountType
jaccounttypes :: Map TagName AccountType
jaccounttypes :: Journal -> Map TagName AccountType
jaccounttypes} = Map TagName AccountType -> TagName -> Maybe AccountType
accountNameType Map TagName AccountType
jaccounttypes
journalAddAccountTypes :: Journal -> Journal
journalAddAccountTypes :: Journal -> Journal
journalAddAccountTypes Journal
j = Journal
j{jaccounttypes :: Map TagName AccountType
jaccounttypes = Journal -> Map TagName AccountType
journalAccountTypes Journal
j}
journalAccountTypes :: Journal -> M.Map AccountName AccountType
journalAccountTypes :: Journal -> Map TagName AccountType
journalAccountTypes Journal
j = forall k a. Ord k => [(k, a)] -> Map k a
M.fromList [(TagName
a,AccountType
acctType) | (TagName
a, Just (AccountType
acctType,Bool
_)) <- forall a. Tree a -> [a]
flatten Tree (TagName, Maybe (AccountType, Bool))
t']
where
t :: Tree TagName
t = [TagName] -> Tree TagName
accountNameTreeFrom forall a b. (a -> b) -> a -> b
$ Journal -> [TagName]
journalAccountNames Journal
j :: Tree AccountName
t' :: Tree (TagName, Maybe (AccountType, Bool))
t' = Maybe (AccountType, Bool)
-> Tree TagName -> Tree (TagName, Maybe (AccountType, Bool))
settypes forall a. Maybe a
Nothing Tree TagName
t :: Tree (AccountName, Maybe (AccountType, Bool))
where
settypes :: Maybe (AccountType, Bool) -> Tree AccountName -> Tree (AccountName, Maybe (AccountType, Bool))
settypes :: Maybe (AccountType, Bool)
-> Tree TagName -> Tree (TagName, Maybe (AccountType, Bool))
settypes Maybe (AccountType, Bool)
mparenttype (Node TagName
a [Tree TagName]
subs) = forall a. a -> [Tree a] -> Tree a
Node (TagName
a, Maybe (AccountType, Bool)
mtype) (forall a b. (a -> b) -> [a] -> [b]
map (Maybe (AccountType, Bool)
-> Tree TagName -> Tree (TagName, Maybe (AccountType, Bool))
settypes Maybe (AccountType, Bool)
mtype) [Tree TagName]
subs)
where
mtype :: Maybe (AccountType, Bool)
mtype = forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup TagName
a Map TagName (AccountType, Bool)
declaredtypes forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe (AccountType, Bool)
minferred
where
declaredtypes :: Map TagName (AccountType, Bool)
declaredtypes = (,Bool
True) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Journal -> Map TagName AccountType
journalDeclaredAccountTypes Journal
j
minferred :: Maybe (AccountType, Bool)
minferred = if forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
False forall a b. (a, b) -> b
snd Maybe (AccountType, Bool)
mparenttype
then Maybe (AccountType, Bool)
mparenttype
else (,Bool
False) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TagName -> Maybe AccountType
accountNameInferType TagName
a forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe (AccountType, Bool)
mparenttype
journalDeclaredAccountTypes :: Journal -> M.Map AccountName AccountType
journalDeclaredAccountTypes :: Journal -> Map TagName AccountType
journalDeclaredAccountTypes Journal{Map AccountType [TagName]
jdeclaredaccounttypes :: Map AccountType [TagName]
jdeclaredaccounttypes :: Journal -> Map AccountType [TagName]
jdeclaredaccounttypes} =
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [forall a b. (a -> b) -> [a] -> [b]
map (,AccountType
t) [TagName]
as | (AccountType
t,[TagName]
as) <- forall k a. Map k a -> [(k, a)]
M.toList Map AccountType [TagName]
jdeclaredaccounttypes]
journalPostingsAddAccountTags :: Journal -> Journal
journalPostingsAddAccountTags :: Journal -> Journal
journalPostingsAddAccountTags Journal
j = (Posting -> Posting) -> Journal -> Journal
journalMapPostings Posting -> Posting
addtags Journal
j
where addtags :: Posting -> Posting
addtags Posting
p = Posting
p Posting -> [Tag] -> Posting
`postingAddTags` (Journal -> TagName -> [Tag]
journalInheritedAccountTags Journal
j forall a b. (a -> b) -> a -> b
$ Posting -> TagName
paccount Posting
p)
filterJournalTransactions :: Query -> Journal -> Journal
filterJournalTransactions :: Query -> Journal -> Journal
filterJournalTransactions Query
q j :: Journal
j@Journal{[Transaction]
jtxns :: [Transaction]
jtxns :: Journal -> [Transaction]
jtxns} = Journal
j{jtxns :: [Transaction]
jtxns=forall a. (a -> Bool) -> [a] -> [a]
filter ((TagName -> Maybe AccountType) -> Query -> Transaction -> Bool
matchesTransactionExtra (Journal -> TagName -> Maybe AccountType
journalAccountType Journal
j) Query
q) [Transaction]
jtxns}
filterJournalPostings :: Query -> Journal -> Journal
filterJournalPostings :: Query -> Journal -> Journal
filterJournalPostings Query
q j :: Journal
j@Journal{jtxns :: Journal -> [Transaction]
jtxns=[Transaction]
ts} = Journal
j{jtxns :: [Transaction]
jtxns=forall a b. (a -> b) -> [a] -> [b]
map ((TagName -> Maybe AccountType)
-> Query -> Transaction -> Transaction
filterTransactionPostingsExtra (Journal -> TagName -> Maybe AccountType
journalAccountType Journal
j) Query
q) [Transaction]
ts}
filterJournalRelatedPostings :: Query -> Journal -> Journal
filterJournalRelatedPostings :: Query -> Journal -> Journal
filterJournalRelatedPostings Query
q j :: Journal
j@Journal{jtxns :: Journal -> [Transaction]
jtxns=[Transaction]
ts} = Journal
j{jtxns :: [Transaction]
jtxns=forall a b. (a -> b) -> [a] -> [b]
map (Query -> Transaction -> Transaction
filterTransactionRelatedPostings Query
q) [Transaction]
ts}
filterJournalAmounts :: Query -> Journal -> Journal
filterJournalAmounts :: Query -> Journal -> Journal
filterJournalAmounts Query
q j :: Journal
j@Journal{jtxns :: Journal -> [Transaction]
jtxns=[Transaction]
ts} = Journal
j{jtxns :: [Transaction]
jtxns=forall a b. (a -> b) -> [a] -> [b]
map (Query -> Transaction -> Transaction
filterTransactionAmounts Query
q) [Transaction]
ts}
filterTransactionAmounts :: Query -> Transaction -> Transaction
filterTransactionAmounts :: Query -> Transaction -> Transaction
filterTransactionAmounts Query
q t :: Transaction
t@Transaction{tpostings :: Transaction -> [Posting]
tpostings=[Posting]
ps} = Transaction
t{tpostings :: [Posting]
tpostings=forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe (Query -> Posting -> Maybe Posting
filterPostingAmount Query
q) [Posting]
ps}
filterPostingAmount :: Query -> Posting -> Maybe Posting
filterPostingAmount :: Query -> Posting -> Maybe Posting
filterPostingAmount Query
q p :: Posting
p@Posting{pamount :: Posting -> MixedAmount
pamount=MixedAmount
as}
| forall (t :: * -> *) a. Foldable t => t a -> Bool
null Map MixedAmountKey Amount
newamt = forall a. Maybe a
Nothing
| Bool
otherwise = forall a. a -> Maybe a
Just Posting
p{pamount :: MixedAmount
pamount=Map MixedAmountKey Amount -> MixedAmount
Mixed Map MixedAmountKey Amount
newamt}
where
Mixed Map MixedAmountKey Amount
newamt = (Amount -> Bool) -> MixedAmount -> MixedAmount
filterMixedAmount (Query
q Query -> Amount -> Bool
`matchesAmount`) MixedAmount
as
filterTransactionPostings :: Query -> Transaction -> Transaction
filterTransactionPostings :: Query -> Transaction -> Transaction
filterTransactionPostings Query
q t :: Transaction
t@Transaction{tpostings :: Transaction -> [Posting]
tpostings=[Posting]
ps} = Transaction
t{tpostings :: [Posting]
tpostings=forall a. (a -> Bool) -> [a] -> [a]
filter (Query
q Query -> Posting -> Bool
`matchesPosting`) [Posting]
ps}
filterTransactionPostingsExtra :: (AccountName -> Maybe AccountType) -> Query -> Transaction -> Transaction
TagName -> Maybe AccountType
atypes Query
q t :: Transaction
t@Transaction{tpostings :: Transaction -> [Posting]
tpostings=[Posting]
ps} =
Transaction
t{tpostings :: [Posting]
tpostings=forall a. (a -> Bool) -> [a] -> [a]
filter ((TagName -> Maybe AccountType) -> Query -> Posting -> Bool
matchesPostingExtra TagName -> Maybe AccountType
atypes Query
q) [Posting]
ps}
filterTransactionRelatedPostings :: Query -> Transaction -> Transaction
filterTransactionRelatedPostings :: Query -> Transaction -> Transaction
filterTransactionRelatedPostings Query
q t :: Transaction
t@Transaction{tpostings :: Transaction -> [Posting]
tpostings=[Posting]
ps} =
Transaction
t{tpostings :: [Posting]
tpostings=if forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Posting]
matches then [] else [Posting]
ps forall a. Eq a => [a] -> [a] -> [a]
\\ [Posting]
matches}
where matches :: [Posting]
matches = forall a. (a -> Bool) -> [a] -> [a]
filter (Query -> Posting -> Bool
matchesPosting Query
q) [Posting]
ps
journalMapTransactions :: (Transaction -> Transaction) -> Journal -> Journal
journalMapTransactions :: (Transaction -> Transaction) -> Journal -> Journal
journalMapTransactions Transaction -> Transaction
f j :: Journal
j@Journal{jtxns :: Journal -> [Transaction]
jtxns=[Transaction]
ts} = Journal
j{jtxns :: [Transaction]
jtxns=forall a b. (a -> b) -> [a] -> [b]
map Transaction -> Transaction
f [Transaction]
ts}
journalMapPostings :: (Posting -> Posting) -> Journal -> Journal
journalMapPostings :: (Posting -> Posting) -> Journal -> Journal
journalMapPostings Posting -> Posting
f j :: Journal
j@Journal{jtxns :: Journal -> [Transaction]
jtxns=[Transaction]
ts} = Journal
j{jtxns :: [Transaction]
jtxns=forall a b. (a -> b) -> [a] -> [b]
map ((Posting -> Posting) -> Transaction -> Transaction
transactionMapPostings Posting -> Posting
f) [Transaction]
ts}
journalMapPostingAmounts :: (MixedAmount -> MixedAmount) -> Journal -> Journal
journalMapPostingAmounts :: (MixedAmount -> MixedAmount) -> Journal -> Journal
journalMapPostingAmounts MixedAmount -> MixedAmount
f = (Posting -> Posting) -> Journal -> Journal
journalMapPostings ((MixedAmount -> MixedAmount) -> Posting -> Posting
postingTransformAmount MixedAmount -> MixedAmount
f)
journalReverse :: Journal -> Journal
journalReverse :: Journal -> Journal
journalReverse Journal
j =
Journal
j {jfiles :: [(RegexError, TagName)]
jfiles = forall a. [a] -> [a]
reverse forall a b. (a -> b) -> a -> b
$ Journal -> [(RegexError, TagName)]
jfiles Journal
j
,jdeclaredaccounts :: [(TagName, AccountDeclarationInfo)]
jdeclaredaccounts = forall a. [a] -> [a]
reverse forall a b. (a -> b) -> a -> b
$ Journal -> [(TagName, AccountDeclarationInfo)]
jdeclaredaccounts Journal
j
,jtxns :: [Transaction]
jtxns = forall a. [a] -> [a]
reverse forall a b. (a -> b) -> a -> b
$ Journal -> [Transaction]
jtxns Journal
j
,jtxnmodifiers :: [TransactionModifier]
jtxnmodifiers = forall a. [a] -> [a]
reverse forall a b. (a -> b) -> a -> b
$ Journal -> [TransactionModifier]
jtxnmodifiers Journal
j
,jperiodictxns :: [PeriodicTransaction]
jperiodictxns = forall a. [a] -> [a]
reverse forall a b. (a -> b) -> a -> b
$ Journal -> [PeriodicTransaction]
jperiodictxns Journal
j
,jpricedirectives :: [PriceDirective]
jpricedirectives = forall a. [a] -> [a]
reverse forall a b. (a -> b) -> a -> b
$ Journal -> [PriceDirective]
jpricedirectives Journal
j
}
journalSetLastReadTime :: POSIXTime -> Journal -> Journal
journalSetLastReadTime :: POSIXTime -> Journal -> Journal
journalSetLastReadTime POSIXTime
t Journal
j = Journal
j{ jlastreadtime :: POSIXTime
jlastreadtime = POSIXTime
t }
journalNumberAndTieTransactions :: Journal -> Journal
journalNumberAndTieTransactions = Journal -> Journal
journalTieTransactions forall b c a. (b -> c) -> (a -> b) -> a -> c
. Journal -> Journal
journalNumberTransactions
journalNumberTransactions :: Journal -> Journal
journalNumberTransactions :: Journal -> Journal
journalNumberTransactions j :: Journal
j@Journal{jtxns :: Journal -> [Transaction]
jtxns=[Transaction]
ts} = Journal
j{jtxns :: [Transaction]
jtxns=forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith (\Integer
i Transaction
t -> Transaction
t{tindex :: Integer
tindex=Integer
i}) [Integer
1..] [Transaction]
ts}
journalTieTransactions :: Journal -> Journal
journalTieTransactions :: Journal -> Journal
journalTieTransactions j :: Journal
j@Journal{jtxns :: Journal -> [Transaction]
jtxns=[Transaction]
ts} = Journal
j{jtxns :: [Transaction]
jtxns=forall a b. (a -> b) -> [a] -> [b]
map Transaction -> Transaction
txnTieKnot [Transaction]
ts}
journalUntieTransactions :: Transaction -> Transaction
journalUntieTransactions :: Transaction -> Transaction
journalUntieTransactions t :: Transaction
t@Transaction{tpostings :: Transaction -> [Posting]
tpostings=[Posting]
ps} = Transaction
t{tpostings :: [Posting]
tpostings=forall a b. (a -> b) -> [a] -> [b]
map (\Posting
p -> Posting
p{ptransaction :: Maybe Transaction
ptransaction=forall a. Maybe a
Nothing}) [Posting]
ps}
journalModifyTransactions :: Day -> Journal -> Either String Journal
journalModifyTransactions :: Day -> Journal -> Either RegexError Journal
journalModifyTransactions Day
d Journal
j =
case (TagName -> Maybe AccountType)
-> (TagName -> [Tag])
-> Map TagName AmountStyle
-> Day
-> [TransactionModifier]
-> [Transaction]
-> Either RegexError [Transaction]
modifyTransactions (Journal -> TagName -> Maybe AccountType
journalAccountType Journal
j) (Journal -> TagName -> [Tag]
journalInheritedAccountTags Journal
j) (Journal -> Map TagName AmountStyle
journalCommodityStyles Journal
j) Day
d (Journal -> [TransactionModifier]
jtxnmodifiers Journal
j) (Journal -> [Transaction]
jtxns Journal
j) of
Right [Transaction]
ts -> forall a b. b -> Either a b
Right Journal
j{jtxns :: [Transaction]
jtxns=[Transaction]
ts}
Left RegexError
err -> forall a b. a -> Either a b
Left RegexError
err
journalApplyCommodityStyles :: Journal -> Either String Journal
journalApplyCommodityStyles :: Journal -> Either RegexError Journal
journalApplyCommodityStyles = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Journal -> Journal
fixjournal forall b c a. (b -> c) -> (a -> b) -> a -> c
. Journal -> Either RegexError Journal
journalInferCommodityStyles
where
fixjournal :: Journal -> Journal
fixjournal j :: Journal
j@Journal{jpricedirectives :: Journal -> [PriceDirective]
jpricedirectives=[PriceDirective]
pds} =
(Posting -> Posting) -> Journal -> Journal
journalMapPostings (Map TagName AmountStyle -> Posting -> Posting
postingApplyCommodityStyles Map TagName AmountStyle
styles) Journal
j{jpricedirectives :: [PriceDirective]
jpricedirectives=forall a b. (a -> b) -> [a] -> [b]
map PriceDirective -> PriceDirective
fixpricedirective [PriceDirective]
pds}
where
styles :: Map TagName AmountStyle
styles = Journal -> Map TagName AmountStyle
journalCommodityStyles Journal
j
fixpricedirective :: PriceDirective -> PriceDirective
fixpricedirective pd :: PriceDirective
pd@PriceDirective{pdamount :: PriceDirective -> Amount
pdamount=Amount
a} = PriceDirective
pd{pdamount :: Amount
pdamount=Map TagName AmountStyle -> Amount -> Amount
styleAmountExceptPrecision Map TagName AmountStyle
styles Amount
a}
journalCommodityStyles :: Journal -> M.Map CommoditySymbol AmountStyle
journalCommodityStyles :: Journal -> Map TagName AmountStyle
journalCommodityStyles Journal
j =
Map TagName AmountStyle
globalstyles forall a. Semigroup a => a -> a -> a
<> Map TagName AmountStyle
declaredstyles forall a. Semigroup a => a -> a -> a
<> Map TagName AmountStyle
defaultcommoditystyle forall a. Semigroup a => a -> a -> a
<> Map TagName AmountStyle
inferredstyles
where
globalstyles :: Map TagName AmountStyle
globalstyles = Journal -> Map TagName AmountStyle
jglobalcommoditystyles Journal
j
declaredstyles :: Map TagName AmountStyle
declaredstyles = forall a b k. (a -> Maybe b) -> Map k a -> Map k b
M.mapMaybe Commodity -> Maybe AmountStyle
cformat forall a b. (a -> b) -> a -> b
$ Journal -> Map TagName Commodity
jcommodities Journal
j
defaultcommoditystyle :: Map TagName AmountStyle
defaultcommoditystyle = forall k a. Ord k => [(k, a)] -> Map k a
M.fromList forall a b. (a -> b) -> a -> b
$ forall a. [Maybe a] -> [a]
catMaybes [Journal -> Maybe (TagName, AmountStyle)
jparsedefaultcommodity Journal
j]
inferredstyles :: Map TagName AmountStyle
inferredstyles = Journal -> Map TagName AmountStyle
jinferredcommodities Journal
j
journalInferCommodityStyles :: Journal -> Either String Journal
journalInferCommodityStyles :: Journal -> Either RegexError Journal
journalInferCommodityStyles Journal
j =
case [Amount] -> Either RegexError (Map TagName AmountStyle)
commodityStylesFromAmounts forall a b. (a -> b) -> a -> b
$ Journal -> [Amount]
journalStyleInfluencingAmounts Journal
j of
Left RegexError
e -> forall a b. a -> Either a b
Left RegexError
e
Right Map TagName AmountStyle
cs -> forall a b. b -> Either a b
Right Journal
j{jinferredcommodities :: Map TagName AmountStyle
jinferredcommodities = forall a. Show a => RegexError -> a -> a
dbg7 RegexError
"journalInferCommodityStyles" Map TagName AmountStyle
cs}
commodityStylesFromAmounts :: [Amount] -> Either String (M.Map CommoditySymbol AmountStyle)
commodityStylesFromAmounts :: [Amount] -> Either RegexError (Map TagName AmountStyle)
commodityStylesFromAmounts =
forall a b. b -> Either a b
Right forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (\Amount
a -> forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
M.insertWith AmountStyle -> AmountStyle -> AmountStyle
canonicalStyle (Amount -> TagName
acommodity Amount
a) (Amount -> AmountStyle
astyle Amount
a)) forall a. Monoid a => a
mempty
canonicalStyleFrom :: [AmountStyle] -> AmountStyle
canonicalStyleFrom :: [AmountStyle] -> AmountStyle
canonicalStyleFrom = forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' AmountStyle -> AmountStyle -> AmountStyle
canonicalStyle AmountStyle
amountstyle
canonicalStyle :: AmountStyle -> AmountStyle -> AmountStyle
canonicalStyle :: AmountStyle -> AmountStyle -> AmountStyle
canonicalStyle AmountStyle
a AmountStyle
b = AmountStyle
a{asprecision :: AmountPrecision
asprecision=AmountPrecision
prec, asdecimalpoint :: Maybe Char
asdecimalpoint=Maybe Char
decmark, asdigitgroups :: Maybe DigitGroupStyle
asdigitgroups=Maybe DigitGroupStyle
mgrps}
where
prec :: AmountPrecision
prec = forall a. Ord a => a -> a -> a
max (AmountStyle -> AmountPrecision
asprecision AmountStyle
a) (AmountStyle -> AmountPrecision
asprecision AmountStyle
b)
mgrps :: Maybe DigitGroupStyle
mgrps = AmountStyle -> Maybe DigitGroupStyle
asdigitgroups AmountStyle
a forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> AmountStyle -> Maybe DigitGroupStyle
asdigitgroups AmountStyle
b
defdecmark :: Char
defdecmark = case Maybe DigitGroupStyle
mgrps of
Just (DigitGroups Char
'.' [Word8]
_) -> Char
','
Maybe DigitGroupStyle
_ -> Char
'.'
decmark :: Maybe Char
decmark = case Maybe DigitGroupStyle
mgrps of
Just DigitGroupStyle
_ -> forall a. a -> Maybe a
Just Char
defdecmark
Maybe DigitGroupStyle
Nothing -> AmountStyle -> Maybe Char
asdecimalpoint AmountStyle
a forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> AmountStyle -> Maybe Char
asdecimalpoint AmountStyle
b forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall a. a -> Maybe a
Just Char
defdecmark
journalInferMarketPricesFromTransactions :: Journal -> Journal
journalInferMarketPricesFromTransactions :: Journal -> Journal
journalInferMarketPricesFromTransactions Journal
j =
Journal
j{jinferredmarketprices :: [MarketPrice]
jinferredmarketprices =
forall a. Show a => RegexError -> a -> a
dbg4 RegexError
"jinferredmarketprices" forall b c a. (b -> c) -> (a -> b) -> a -> c
.
forall a b. (a -> b) -> [a] -> [b]
map PriceDirective -> MarketPrice
priceDirectiveToMarketPrice forall b c a. (b -> c) -> (a -> b) -> a -> c
.
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Posting -> [PriceDirective]
postingPriceDirectivesFromCost forall a b. (a -> b) -> a -> b
$
Journal -> [Posting]
journalPostings Journal
j
}
journalToCost :: ConversionOp -> Journal -> Journal
journalToCost :: ConversionOp -> Journal -> Journal
journalToCost ConversionOp
cost j :: Journal
j@Journal{jtxns :: Journal -> [Transaction]
jtxns=[Transaction]
ts} = Journal
j{jtxns :: [Transaction]
jtxns=forall a b. (a -> b) -> [a] -> [b]
map (Map TagName AmountStyle
-> ConversionOp -> Transaction -> Transaction
transactionToCost Map TagName AmountStyle
styles ConversionOp
cost) [Transaction]
ts}
where
styles :: Map TagName AmountStyle
styles = Journal -> Map TagName AmountStyle
journalCommodityStyles Journal
j
journalAddInferredEquityPostings :: Journal -> Journal
journalAddInferredEquityPostings :: Journal -> Journal
journalAddInferredEquityPostings Journal
j = (Transaction -> Transaction) -> Journal -> Journal
journalMapTransactions (TagName -> Transaction -> Transaction
transactionAddInferredEquityPostings TagName
equityAcct) Journal
j
where
equityAcct :: TagName
equityAcct = Journal -> TagName
journalConversionAccount Journal
j
journalAddPricesFromEquity :: Journal -> Either String Journal
journalAddPricesFromEquity :: Journal -> Either RegexError Journal
journalAddPricesFromEquity Journal
j = do
[Transaction]
ts <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (Map TagName AccountType
-> Transaction -> Either RegexError Transaction
transactionAddPricesFromEquity forall a b. (a -> b) -> a -> b
$ Journal -> Map TagName AccountType
jaccounttypes Journal
j) forall a b. (a -> b) -> a -> b
$ Journal -> [Transaction]
jtxns Journal
j
forall (m :: * -> *) a. Monad m => a -> m a
return Journal
j{jtxns :: [Transaction]
jtxns=[Transaction]
ts}
journalStyleInfluencingAmounts :: Journal -> [Amount]
journalStyleInfluencingAmounts :: Journal -> [Amount]
journalStyleInfluencingAmounts Journal
j =
forall a. Show a => RegexError -> a -> a
dbg7 RegexError
"journalStyleInfluencingAmounts" forall a b. (a -> b) -> a -> b
$
forall a. [Maybe a] -> [a]
catMaybes forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [
[Maybe Amount
mdefaultcommodityamt]
,forall a b. (a -> b) -> [a] -> [b]
map (forall a. a -> Maybe a
Just forall b c a. (b -> c) -> (a -> b) -> a -> c
. PriceDirective -> Amount
pdamount) forall a b. (a -> b) -> a -> b
$ Journal -> [PriceDirective]
jpricedirectives Journal
j
,forall a b. (a -> b) -> [a] -> [b]
map forall a. a -> Maybe a
Just forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (MixedAmount -> [Amount]
amountsRaw forall b c a. (b -> c) -> (a -> b) -> a -> c
. Posting -> MixedAmount
pamount) forall a b. (a -> b) -> a -> b
$ Journal -> [Posting]
journalPostings Journal
j
]
where
mdefaultcommodityamt :: Maybe Amount
mdefaultcommodityamt =
case Journal -> Maybe (TagName, AmountStyle)
jparsedefaultcommodity Journal
j of
Just (TagName
symbol,AmountStyle
style) -> forall a. a -> Maybe a
Just Amount
nullamt{acommodity :: TagName
acommodity=TagName
symbol,astyle :: AmountStyle
astyle=AmountStyle
style}
Maybe (TagName, AmountStyle)
Nothing -> forall a. Maybe a
Nothing
journalDateSpan :: Bool -> Journal -> DateSpan
journalDateSpan :: Bool -> Journal -> DateSpan
journalDateSpan Bool
False = Maybe WhichDate -> Journal -> DateSpan
journalDateSpanHelper forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just WhichDate
PrimaryDate
journalDateSpan Bool
True = Maybe WhichDate -> Journal -> DateSpan
journalDateSpanHelper forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just WhichDate
SecondaryDate
journalDateSpanBothDates :: Journal -> DateSpan
journalDateSpanBothDates :: Journal -> DateSpan
journalDateSpanBothDates = Maybe WhichDate -> Journal -> DateSpan
journalDateSpanHelper forall a. Maybe a
Nothing
journalDateSpanHelper :: Maybe WhichDate -> Journal -> DateSpan
journalDateSpanHelper :: Maybe WhichDate -> Journal -> DateSpan
journalDateSpanHelper Maybe WhichDate
whichdate Journal
j =
Maybe Day -> Maybe Day -> DateSpan
DateSpan (forall a. Ord a => [a] -> Maybe a
minimumMay [Day]
dates) (Integer -> Day -> Day
addDays Integer
1 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Ord a => [a] -> Maybe a
maximumMay [Day]
dates)
where
dates :: [Day]
dates = [Day]
pdates forall a. [a] -> [a] -> [a]
++ [Day]
tdates
tdates :: [Day]
tdates = forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Transaction -> [Day]
gettdate [Transaction]
ts
pdates :: [Day]
pdates = forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Posting -> [Day]
getpdate forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Transaction -> [Posting]
tpostings [Transaction]
ts
ts :: [Transaction]
ts = Journal -> [Transaction]
jtxns Journal
j
gettdate :: Transaction -> [Day]
gettdate Transaction
t = case Maybe WhichDate
whichdate of
Just WhichDate
PrimaryDate -> [Transaction -> Day
tdate Transaction
t]
Just WhichDate
SecondaryDate -> [forall a. a -> Maybe a -> a
fromMaybe (Transaction -> Day
tdate Transaction
t) forall a b. (a -> b) -> a -> b
$ Transaction -> Maybe Day
tdate2 Transaction
t]
Maybe WhichDate
Nothing -> Transaction -> Day
tdate Transaction
t forall a. a -> [a] -> [a]
: forall a. Maybe a -> [a]
maybeToList (Transaction -> Maybe Day
tdate2 Transaction
t)
getpdate :: Posting -> [Day]
getpdate Posting
p = case Maybe WhichDate
whichdate of
Just WhichDate
PrimaryDate -> forall a. Maybe a -> [a]
maybeToList forall a b. (a -> b) -> a -> b
$ Posting -> Maybe Day
pdate Posting
p
Just WhichDate
SecondaryDate -> forall a. Maybe a -> [a]
maybeToList forall a b. (a -> b) -> a -> b
$ Posting -> Maybe Day
pdate2 Posting
p forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Posting -> Maybe Day
pdate Posting
p
Maybe WhichDate
Nothing -> forall a. [Maybe a] -> [a]
catMaybes [Posting -> Maybe Day
pdate Posting
p, Posting -> Maybe Day
pdate2 Posting
p]
journalStartDate :: Bool -> Journal -> Maybe Day
journalStartDate :: Bool -> Journal -> Maybe Day
journalStartDate Bool
secondary Journal
j = Maybe Day
b where DateSpan Maybe Day
b Maybe Day
_ = Bool -> Journal -> DateSpan
journalDateSpan Bool
secondary Journal
j
journalEndDate :: Bool -> Journal -> Maybe Day
journalEndDate :: Bool -> Journal -> Maybe Day
journalEndDate Bool
secondary Journal
j = Maybe Day
e where DateSpan Maybe Day
_ Maybe Day
e = Bool -> Journal -> DateSpan
journalDateSpan Bool
secondary Journal
j
journalLastDay :: Bool -> Journal -> Maybe Day
journalLastDay :: Bool -> Journal -> Maybe Day
journalLastDay Bool
secondary Journal
j = Integer -> Day -> Day
addDays (-Integer
1) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Bool -> Journal -> Maybe Day
journalEndDate Bool
secondary Journal
j
journalPivot :: Text -> Journal -> Journal
journalPivot :: TagName -> Journal -> Journal
journalPivot TagName
fieldortagname Journal
j = Journal
j{jtxns :: [Transaction]
jtxns = forall a b. (a -> b) -> [a] -> [b]
map (TagName -> Transaction -> Transaction
transactionPivot TagName
fieldortagname) forall b c a. (b -> c) -> (a -> b) -> a -> c
. Journal -> [Transaction]
jtxns forall a b. (a -> b) -> a -> b
$ Journal
j}
transactionPivot :: Text -> Transaction -> Transaction
transactionPivot :: TagName -> Transaction -> Transaction
transactionPivot TagName
fieldortagname Transaction
t = Transaction
t{tpostings :: [Posting]
tpostings = forall a b. (a -> b) -> [a] -> [b]
map (TagName -> Posting -> Posting
postingPivot TagName
fieldortagname) forall b c a. (b -> c) -> (a -> b) -> a -> c
. Transaction -> [Posting]
tpostings forall a b. (a -> b) -> a -> b
$ Transaction
t}
postingPivot :: Text -> Posting -> Posting
postingPivot :: TagName -> Posting -> Posting
postingPivot TagName
fieldortagname Posting
p = Posting
p{paccount :: TagName
paccount = TagName
pivotedacct, poriginal :: Maybe Posting
poriginal = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ Posting -> Posting
originalPosting Posting
p}
where
pivotedacct :: TagName
pivotedacct
| Just Transaction
t <- Posting -> Maybe Transaction
ptransaction Posting
p, TagName
fieldortagname forall a. Eq a => a -> a -> Bool
== TagName
"code" = Transaction -> TagName
tcode Transaction
t
| Just Transaction
t <- Posting -> Maybe Transaction
ptransaction Posting
p, TagName
fieldortagname forall a. Eq a => a -> a -> Bool
== TagName
"description" = Transaction -> TagName
tdescription Transaction
t
| Just Transaction
t <- Posting -> Maybe Transaction
ptransaction Posting
p, TagName
fieldortagname forall a. Eq a => a -> a -> Bool
== TagName
"payee" = Transaction -> TagName
transactionPayee Transaction
t
| Just Transaction
t <- Posting -> Maybe Transaction
ptransaction Posting
p, TagName
fieldortagname forall a. Eq a => a -> a -> Bool
== TagName
"note" = Transaction -> TagName
transactionNote Transaction
t
| Just Transaction
t <- Posting -> Maybe Transaction
ptransaction Posting
p, TagName
fieldortagname forall a. Eq a => a -> a -> Bool
== TagName
"status" = RegexError -> TagName
T.pack forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> RegexError
show forall b c a. (b -> c) -> (a -> b) -> a -> c
. Transaction -> Status
tstatus forall a b. (a -> b) -> a -> b
$ Transaction
t
| Just (TagName
_, TagName
value) <- TagName -> Posting -> Maybe Tag
postingFindTag TagName
fieldortagname Posting
p = TagName
value
| Bool
otherwise = TagName
""
postingFindTag :: TagName -> Posting -> Maybe (TagName, TagValue)
postingFindTag :: TagName -> Posting -> Maybe Tag
postingFindTag TagName
tagname Posting
p = forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
find ((TagName
tagnameforall a. Eq a => a -> a -> Bool
==) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> a
fst) forall a b. (a -> b) -> a -> b
$ Posting -> [Tag]
postingAllTags Posting
p
journalApplyAliases :: [AccountAlias] -> Journal -> Either RegexError Journal
journalApplyAliases :: [AccountAlias] -> Journal -> Either RegexError Journal
journalApplyAliases [] Journal
j = forall a b. b -> Either a b
Right Journal
j
journalApplyAliases [AccountAlias]
aliases Journal
j =
case forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ([AccountAlias] -> Transaction -> Either RegexError Transaction
transactionApplyAliases [AccountAlias]
aliases) forall a b. (a -> b) -> a -> b
$ Journal -> [Transaction]
jtxns Journal
j of
Right [Transaction]
ts -> forall a b. b -> Either a b
Right Journal
j{jtxns :: [Transaction]
jtxns = [Transaction]
ts}
Left RegexError
err -> forall a b. a -> Either a b
Left RegexError
err
samplejournal :: Journal
samplejournal = Bool -> Journal
samplejournalMaybeExplicit Bool
True
samplejournalMaybeExplicit :: Bool -> Journal
samplejournalMaybeExplicit :: Bool -> Journal
samplejournalMaybeExplicit Bool
explicit = Journal
nulljournal
{jtxns :: [Transaction]
jtxns = [
Transaction -> Transaction
txnTieKnot forall a b. (a -> b) -> a -> b
$ Transaction {
tindex :: Integer
tindex=Integer
0,
tsourcepos :: (SourcePos, SourcePos)
tsourcepos=(SourcePos, SourcePos)
nullsourcepos,
tdate :: Day
tdate=Integer -> Int -> Int -> Day
fromGregorian Integer
2008 Int
01 Int
01,
tdate2 :: Maybe Day
tdate2=forall a. Maybe a
Nothing,
tstatus :: Status
tstatus=Status
Unmarked,
tcode :: TagName
tcode=TagName
"",
tdescription :: TagName
tdescription=TagName
"income",
tcomment :: TagName
tcomment=TagName
"",
ttags :: [Tag]
ttags=[],
tpostings :: [Posting]
tpostings=
[TagName
"assets:bank:checking" TagName -> Amount -> Posting
`post` DecimalRaw Integer -> Amount
usd DecimalRaw Integer
1
,TagName
"income:salary" TagName -> Amount -> Posting
`post` if Bool
explicit then DecimalRaw Integer -> Amount
usd (-DecimalRaw Integer
1) else Amount
missingamt
],
tprecedingcomment :: TagName
tprecedingcomment=TagName
""
}
,
Transaction -> Transaction
txnTieKnot forall a b. (a -> b) -> a -> b
$ Transaction {
tindex :: Integer
tindex=Integer
0,
tsourcepos :: (SourcePos, SourcePos)
tsourcepos=(SourcePos, SourcePos)
nullsourcepos,
tdate :: Day
tdate=Integer -> Int -> Int -> Day
fromGregorian Integer
2008 Int
06 Int
01,
tdate2 :: Maybe Day
tdate2=forall a. Maybe a
Nothing,
tstatus :: Status
tstatus=Status
Unmarked,
tcode :: TagName
tcode=TagName
"",
tdescription :: TagName
tdescription=TagName
"gift",
tcomment :: TagName
tcomment=TagName
"",
ttags :: [Tag]
ttags=[],
tpostings :: [Posting]
tpostings=
[TagName
"assets:bank:checking" TagName -> Amount -> Posting
`post` DecimalRaw Integer -> Amount
usd DecimalRaw Integer
1
,TagName
"income:gifts" TagName -> Amount -> Posting
`post` if Bool
explicit then DecimalRaw Integer -> Amount
usd (-DecimalRaw Integer
1) else Amount
missingamt
],
tprecedingcomment :: TagName
tprecedingcomment=TagName
""
}
,
Transaction -> Transaction
txnTieKnot forall a b. (a -> b) -> a -> b
$ Transaction {
tindex :: Integer
tindex=Integer
0,
tsourcepos :: (SourcePos, SourcePos)
tsourcepos=(SourcePos, SourcePos)
nullsourcepos,
tdate :: Day
tdate=Integer -> Int -> Int -> Day
fromGregorian Integer
2008 Int
06 Int
02,
tdate2 :: Maybe Day
tdate2=forall a. Maybe a
Nothing,
tstatus :: Status
tstatus=Status
Unmarked,
tcode :: TagName
tcode=TagName
"",
tdescription :: TagName
tdescription=TagName
"save",
tcomment :: TagName
tcomment=TagName
"",
ttags :: [Tag]
ttags=[],
tpostings :: [Posting]
tpostings=
[TagName
"assets:bank:saving" TagName -> Amount -> Posting
`post` DecimalRaw Integer -> Amount
usd DecimalRaw Integer
1
,TagName
"assets:bank:checking" TagName -> Amount -> Posting
`post` if Bool
explicit then DecimalRaw Integer -> Amount
usd (-DecimalRaw Integer
1) else Amount
missingamt
],
tprecedingcomment :: TagName
tprecedingcomment=TagName
""
}
,
Transaction -> Transaction
txnTieKnot forall a b. (a -> b) -> a -> b
$ Transaction {
tindex :: Integer
tindex=Integer
0,
tsourcepos :: (SourcePos, SourcePos)
tsourcepos=(SourcePos, SourcePos)
nullsourcepos,
tdate :: Day
tdate=Integer -> Int -> Int -> Day
fromGregorian Integer
2008 Int
06 Int
03,
tdate2 :: Maybe Day
tdate2=forall a. Maybe a
Nothing,
tstatus :: Status
tstatus=Status
Cleared,
tcode :: TagName
tcode=TagName
"",
tdescription :: TagName
tdescription=TagName
"eat & shop",
tcomment :: TagName
tcomment=TagName
"",
ttags :: [Tag]
ttags=[],
tpostings :: [Posting]
tpostings=[TagName
"expenses:food" TagName -> Amount -> Posting
`post` DecimalRaw Integer -> Amount
usd DecimalRaw Integer
1
,TagName
"expenses:supplies" TagName -> Amount -> Posting
`post` DecimalRaw Integer -> Amount
usd DecimalRaw Integer
1
,TagName
"assets:cash" TagName -> Amount -> Posting
`post` if Bool
explicit then DecimalRaw Integer -> Amount
usd (-DecimalRaw Integer
2) else Amount
missingamt
],
tprecedingcomment :: TagName
tprecedingcomment=TagName
""
}
,
Transaction -> Transaction
txnTieKnot forall a b. (a -> b) -> a -> b
$ Transaction {
tindex :: Integer
tindex=Integer
0,
tsourcepos :: (SourcePos, SourcePos)
tsourcepos=(SourcePos, SourcePos)
nullsourcepos,
tdate :: Day
tdate=Integer -> Int -> Int -> Day
fromGregorian Integer
2008 Int
10 Int
01,
tdate2 :: Maybe Day
tdate2=forall a. Maybe a
Nothing,
tstatus :: Status
tstatus=Status
Unmarked,
tcode :: TagName
tcode=TagName
"",
tdescription :: TagName
tdescription=TagName
"take a loan",
tcomment :: TagName
tcomment=TagName
"",
ttags :: [Tag]
ttags=[],
tpostings :: [Posting]
tpostings=[TagName
"assets:bank:checking" TagName -> Amount -> Posting
`post` DecimalRaw Integer -> Amount
usd DecimalRaw Integer
1
,TagName
"liabilities:debts" TagName -> Amount -> Posting
`post` DecimalRaw Integer -> Amount
usd (-DecimalRaw Integer
1)
],
tprecedingcomment :: TagName
tprecedingcomment=TagName
""
}
,
Transaction -> Transaction
txnTieKnot forall a b. (a -> b) -> a -> b
$ Transaction {
tindex :: Integer
tindex=Integer
0,
tsourcepos :: (SourcePos, SourcePos)
tsourcepos=(SourcePos, SourcePos)
nullsourcepos,
tdate :: Day
tdate=Integer -> Int -> Int -> Day
fromGregorian Integer
2008 Int
12 Int
31,
tdate2 :: Maybe Day
tdate2=forall a. Maybe a
Nothing,
tstatus :: Status
tstatus=Status
Unmarked,
tcode :: TagName
tcode=TagName
"",
tdescription :: TagName
tdescription=TagName
"pay off",
tcomment :: TagName
tcomment=TagName
"",
ttags :: [Tag]
ttags=[],
tpostings :: [Posting]
tpostings=[TagName
"liabilities:debts" TagName -> Amount -> Posting
`post` DecimalRaw Integer -> Amount
usd DecimalRaw Integer
1
,TagName
"assets:bank:checking" TagName -> Amount -> Posting
`post` if Bool
explicit then DecimalRaw Integer -> Amount
usd (-DecimalRaw Integer
1) else Amount
missingamt
],
tprecedingcomment :: TagName
tprecedingcomment=TagName
""
}
]
}
tests_Journal :: TestTree
tests_Journal = RegexError -> [TestTree] -> TestTree
testGroup RegexError
"Journal" [
RegexError -> Assertion -> TestTree
testCase RegexError
"journalDateSpan" forall a b. (a -> b) -> a -> b
$
Bool -> Journal -> DateSpan
journalDateSpan Bool
True Journal
nulljournal{
jtxns :: [Transaction]
jtxns = [Transaction
nulltransaction{tdate :: Day
tdate = Integer -> Int -> Int -> Day
fromGregorian Integer
2014 Int
02 Int
01
,tpostings :: [Posting]
tpostings = [Posting
posting{pdate :: Maybe Day
pdate=forall a. a -> Maybe a
Just (Integer -> Int -> Int -> Day
fromGregorian Integer
2014 Int
01 Int
10)}]
}
,Transaction
nulltransaction{tdate :: Day
tdate = Integer -> Int -> Int -> Day
fromGregorian Integer
2014 Int
09 Int
01
,tpostings :: [Posting]
tpostings = [Posting
posting{pdate2 :: Maybe Day
pdate2=forall a. a -> Maybe a
Just (Integer -> Int -> Int -> Day
fromGregorian Integer
2014 Int
10 Int
10)}]
}
]
}
forall a. (Eq a, Show a, HasCallStack) => a -> a -> Assertion
@?= (Maybe Day -> Maybe Day -> DateSpan
DateSpan (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ Integer -> Int -> Int -> Day
fromGregorian Integer
2014 Int
1 Int
10) (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ Integer -> Int -> Int -> Day
fromGregorian Integer
2014 Int
10 Int
11))
]