import Data.Decimal (DecimalRaw(..))
import qualified Data.Either
import qualified Data.List
+import Data.List.NonEmpty (NonEmpty(..))
import qualified Data.Map.Strict as Data.Map
import Data.Text (Text)
import qualified Data.Time.Calendar as Time
import qualified Hcompta.Format.Ledger.Read as Format.Ledger.Read
import qualified Hcompta.Format.Ledger.Journal as Format.Ledger.Journal
import qualified Hcompta.Format.Ledger.Write as Format.Ledger.Write
+import qualified Hcompta.Lib.TreeMap as Lib.TreeMap
--instance Eq Text.Parsec.ParseError where
-- (==) = const (const False)
TestList
[ "Model" ~: TestList
[ "Account" ~: TestList
- [ "fold" ~: TestList
- [ "[] = []" ~:
- (reverse $ Account.fold [] (:) []) ~?= []
- , "[A] = [[A]]" ~:
- (reverse $ Account.fold ["A"] (:) []) ~?= [["A"]]
- , "[A, B] = [[A], [A, B]]" ~:
- (reverse $ Account.fold ["A", "B"] (:) []) ~?= [["A"], ["A", "B"]]
- , "[A, B, C] = [[A], [A, B], [A, B, C]]" ~:
- (reverse $ Account.fold ["A", "B", "C"] (:) []) ~?= [["A"], ["A", "B"], ["A", "B", "C"]]
+ [ "foldr" ~: TestList
+ [ "[A]" ~:
+ (reverse $ Account.foldr ("A":|[]) (:) []) ~?= ["A":|[]]
+ , "[A, B]" ~:
+ (reverse $ Account.foldr ("A":|["B"]) (:) []) ~?= ["A":|[], "A":|["B"]]
+ , "[A, B, C]" ~:
+ (reverse $ Account.foldr ("A":|["B", "C"]) (:) []) ~?= ["A":|[], "A":|["B"], "A":|["B", "C"]]
]
, "ascending" ~: TestList
- [ "[] = []" ~:
- Account.ascending [] ~?= []
- , "[A] = []" ~:
- Account.ascending ["A"] ~?= []
- , "[A, B] = [A]" ~:
- Account.ascending ["A", "B"] ~?= ["A"]
- , "[A, B, C] = [A, B]" ~:
- Account.ascending ["A", "B", "C"] ~?= ["A", "B"]
+ [ "[A]" ~:
+ Account.ascending ("A":|[]) ~?= Nothing
+ , "[A, B]" ~:
+ Account.ascending ("A":|["B"]) ~?= Just ("A":|[])
+ , "[A, B, C]" ~:
+ Account.ascending ("A":|["B", "C"]) ~?= Just ("A":|["B"])
]
]
, "Amount" ~: TestList
[ "posting" ~: TestList
[ "[A+$1] = A+$1 & $+1" ~:
(Calc.Balance.posting
- Posting.nil
- { Posting.account=["A"]
- , Posting.amounts=Amount.from_List [ Amount.usd $ 1 ]
+ (Posting.nil ("A":|[]))
+ { Posting.amounts=Amount.from_List [ Amount.usd $ 1 ]
}
Calc.Balance.nil)
~?=
Calc.Balance.Balance
{ Calc.Balance.by_account =
- Data.Map.fromList
- [ (["A"], Amount.from_List [ Amount.usd $ 1 ]) ]
+ Lib.TreeMap.from_List const
+ [ ("A":|[], Amount.from_List [ Amount.usd $ 1 ]) ]
, Calc.Balance.by_unit =
Data.Map.fromList $
Data.List.map Calc.Balance.assoc_unit_sum $
[ Calc.Balance.Unit_Sum
{ Calc.Balance.amount = Amount.usd $ 1
, Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
- [["A"]]
+ ["A":|[]]
}
]
}
(Data.List.foldl
(flip Calc.Balance.posting)
Calc.Balance.nil
- [ Posting.nil
- { Posting.account=["A"]
- , Posting.amounts=Amount.from_List [ Amount.usd $ 1 ]
+ [ (Posting.nil ("A":|[]))
+ { Posting.amounts=Amount.from_List [ Amount.usd $ 1 ]
}
- , Posting.nil
- { Posting.account=["A"]
- , Posting.amounts=Amount.from_List [ Amount.usd $ -1 ]
+ , (Posting.nil ("A":|[]))
+ { Posting.amounts=Amount.from_List [ Amount.usd $ -1 ]
}
])
~?=
Calc.Balance.Balance
{ Calc.Balance.by_account =
- Data.Map.fromList
- [ (["A"], Amount.from_List [ Amount.usd $ 0 ]) ]
+ Lib.TreeMap.from_List const
+ [ ("A":|[], Amount.from_List [ Amount.usd $ 0 ]) ]
, Calc.Balance.by_unit =
Data.Map.fromList $
Data.List.map Calc.Balance.assoc_unit_sum $
[ Calc.Balance.Unit_Sum
{ Calc.Balance.amount = Amount.usd $ 0
, Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
- [["A"]]
+ ["A":|[]]
}
]
}
(Data.List.foldl
(flip Calc.Balance.posting)
Calc.Balance.nil
- [ Posting.nil
- { Posting.account=["A"]
- , Posting.amounts=Amount.from_List [ Amount.usd $ 1 ]
+ [ (Posting.nil ("A":|[]))
+ { Posting.amounts=Amount.from_List [ Amount.usd $ 1 ]
}
- , Posting.nil
- { Posting.account=["A"]
- , Posting.amounts=Amount.from_List [ Amount.eur $ -1 ]
+ , (Posting.nil ("A":|[]))
+ { Posting.amounts=Amount.from_List [ Amount.eur $ -1 ]
}
])
~?=
Calc.Balance.Balance
{ Calc.Balance.by_account =
- Data.Map.fromList
- [ (["A"], Amount.from_List [ Amount.usd $ 1, Amount.eur $ -1 ]) ]
+ Lib.TreeMap.from_List const
+ [ ("A":|[], Amount.from_List [ Amount.usd $ 1, Amount.eur $ -1 ]) ]
, Calc.Balance.by_unit =
Data.Map.fromList $
Data.List.map Calc.Balance.assoc_unit_sum $
[ Calc.Balance.Unit_Sum
{ Calc.Balance.amount = Amount.usd $ 1
, Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
- [["A"]]
+ ["A":|[]]
}
, Calc.Balance.Unit_Sum
{ Calc.Balance.amount = Amount.eur $ -1
, Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
- [["A"]]
+ ["A":|[]]
}
]
}
(Data.List.foldl
(flip Calc.Balance.posting)
Calc.Balance.nil
- [ Posting.nil
- { Posting.account=["A"]
- , Posting.amounts=Amount.from_List [ Amount.usd $ 1 ]
+ [ (Posting.nil ("A":|[]))
+ { Posting.amounts=Amount.from_List [ Amount.usd $ 1 ]
}
- , Posting.nil
- { Posting.account=["B"]
- , Posting.amounts=Amount.from_List [ Amount.usd $ -1 ]
+ , (Posting.nil ("B":|[]))
+ { Posting.amounts=Amount.from_List [ Amount.usd $ -1 ]
}
])
~?=
Calc.Balance.Balance
{ Calc.Balance.by_account =
- Data.Map.fromList
- [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
- , (["B"], Amount.from_List [ Amount.usd $ -1 ])
+ Lib.TreeMap.from_List const
+ [ ("A":|[], Amount.from_List [ Amount.usd $ 1 ])
+ , ("B":|[], Amount.from_List [ Amount.usd $ -1 ])
]
, Calc.Balance.by_unit =
Data.Map.fromList $
[ Calc.Balance.Unit_Sum
{ Calc.Balance.amount = Amount.usd $ 0
, Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
- [["A"], ["B"]]
+ ["A":|[], "B":|[]]
}
]
}
(Data.List.foldl
(flip Calc.Balance.posting)
Calc.Balance.nil
- [ Posting.nil
- { Posting.account=["A"]
- , Posting.amounts=Amount.from_List [ Amount.usd $ 1, Amount.eur $ 2 ]
+ [ (Posting.nil ("A":|[]))
+ { Posting.amounts=Amount.from_List [ Amount.usd $ 1, Amount.eur $ 2 ]
}
- , Posting.nil
- { Posting.account=["A"]
- , Posting.amounts=Amount.from_List [ Amount.usd $ -1, Amount.eur $ -2 ]
+ , (Posting.nil ("A":|[]))
+ { Posting.amounts=Amount.from_List [ Amount.usd $ -1, Amount.eur $ -2 ]
}
])
~?=
Calc.Balance.Balance
{ Calc.Balance.by_account =
- Data.Map.fromList
- [ (["A"], Amount.from_List [ Amount.usd $ 0, Amount.eur $ 0 ])
+ Lib.TreeMap.from_List const
+ [ ("A":|[], Amount.from_List [ Amount.usd $ 0, Amount.eur $ 0 ])
]
, Calc.Balance.by_unit =
Data.Map.fromList $
[ Calc.Balance.Unit_Sum
{ Calc.Balance.amount = Amount.usd $ 0
, Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
- [["A"]]
+ ["A":|[]]
}
, Calc.Balance.Unit_Sum
{ Calc.Balance.amount = Amount.eur $ 0
, Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
- [["A"]]
+ ["A":|[]]
}
]
}
(Data.List.foldl
(flip Calc.Balance.posting)
Calc.Balance.nil
- [ Posting.nil
- { Posting.account=["A"]
- , Posting.amounts=Amount.from_List [ Amount.usd $ 1, Amount.eur $ 2, Amount.gbp $ 3 ]
+ [ (Posting.nil ("A":|[]))
+ { Posting.amounts=Amount.from_List [ Amount.usd $ 1, Amount.eur $ 2, Amount.gbp $ 3 ]
}
- , Posting.nil
- { Posting.account=["B"]
- , Posting.amounts=Amount.from_List [ Amount.usd $ -1, Amount.eur $ -2, Amount.gbp $ -3 ]
+ , (Posting.nil ("B":|[]))
+ { Posting.amounts=Amount.from_List [ Amount.usd $ -1, Amount.eur $ -2, Amount.gbp $ -3 ]
}
])
~?=
Calc.Balance.Balance
{ Calc.Balance.by_account =
- Data.Map.fromList
- [ (["A"], Amount.from_List [ Amount.usd $ 1, Amount.eur $ 2, Amount.gbp $ 3 ])
- , (["B"], Amount.from_List [ Amount.usd $ -1, Amount.eur $ -2, Amount.gbp $ -3 ])
+ Lib.TreeMap.from_List const
+ [ ("A":|[], Amount.from_List [ Amount.usd $ 1, Amount.eur $ 2, Amount.gbp $ 3 ])
+ , ("B":|[], Amount.from_List [ Amount.usd $ -1, Amount.eur $ -2, Amount.gbp $ -3 ])
]
, Calc.Balance.by_unit =
Data.Map.fromList $
[ Calc.Balance.Unit_Sum
{ Calc.Balance.amount = Amount.usd $ 0
, Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
- [["A"], ["B"]]
+ ["A":|[], "B":|[]]
}
, Calc.Balance.Unit_Sum
{ Calc.Balance.amount = Amount.eur $ 0
, Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
- [["A"], ["B"]]
+ ["A":|[], "B":|[]]
}
, Calc.Balance.Unit_Sum
{ Calc.Balance.amount = Amount.gbp $ 0
, Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
- [["A"], ["B"]]
+ ["A":|[], "B":|[]]
}
]
}
Calc.Balance.union
(Calc.Balance.Balance
{ Calc.Balance.by_account =
- Data.Map.fromList
- [ (["A"], Amount.from_List [ Amount.usd $ 1 ]) ]
+ Lib.TreeMap.from_List const
+ [ ("A":|[], Amount.from_List [ Amount.usd $ 1 ]) ]
, Calc.Balance.by_unit =
Data.Map.fromList $
Data.List.map Calc.Balance.assoc_unit_sum $
[ Calc.Balance.Unit_Sum
{ Calc.Balance.amount = Amount.usd $ 1
, Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
- [["A"]]
+ ["A":|[]]
}
]
})
(Calc.Balance.Balance
{ Calc.Balance.by_account =
- Data.Map.fromList
- [ (["A"], Amount.from_List [ Amount.usd $ 1 ]) ]
+ Lib.TreeMap.from_List const
+ [ ("A":|[], Amount.from_List [ Amount.usd $ 1 ]) ]
, Calc.Balance.by_unit =
Data.Map.fromList $
Data.List.map Calc.Balance.assoc_unit_sum $
[ Calc.Balance.Unit_Sum
{ Calc.Balance.amount = Amount.usd $ 1
, Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
- [["A"]]
+ ["A":|[]]
}
]
})
~?=
Calc.Balance.Balance
{ Calc.Balance.by_account =
- Data.Map.fromList
- [ (["A"], Amount.from_List [ Amount.usd $ 2 ]) ]
+ Lib.TreeMap.from_List const
+ [ ("A":|[], Amount.from_List [ Amount.usd $ 2 ]) ]
, Calc.Balance.by_unit =
Data.Map.fromList $
Data.List.map Calc.Balance.assoc_unit_sum $
[ Calc.Balance.Unit_Sum
{ Calc.Balance.amount = Amount.usd $ 2
, Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
- [["A"]]
+ ["A":|[]]
}
]
}
Calc.Balance.union
(Calc.Balance.Balance
{ Calc.Balance.by_account =
- Data.Map.fromList
- [ (["A"], Amount.from_List [ Amount.usd $ 1 ]) ]
+ Lib.TreeMap.from_List const
+ [ ("A":|[], Amount.from_List [ Amount.usd $ 1 ]) ]
, Calc.Balance.by_unit =
Data.Map.fromList $
Data.List.map Calc.Balance.assoc_unit_sum $
[ Calc.Balance.Unit_Sum
{ Calc.Balance.amount = Amount.usd $ 1
, Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
- [["A"]]
+ ["A":|[]]
}
]
})
(Calc.Balance.Balance
{ Calc.Balance.by_account =
- Data.Map.fromList
- [ (["B"], Amount.from_List [ Amount.usd $ 1 ]) ]
+ Lib.TreeMap.from_List const
+ [ ("B":|[], Amount.from_List [ Amount.usd $ 1 ]) ]
, Calc.Balance.by_unit =
Data.Map.fromList $
Data.List.map Calc.Balance.assoc_unit_sum $
[ Calc.Balance.Unit_Sum
{ Calc.Balance.amount = Amount.usd $ 1
, Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
- [["B"]]
+ ["B":|[]]
}
]
})
~?=
Calc.Balance.Balance
{ Calc.Balance.by_account =
- Data.Map.fromList
- [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
- , (["B"], Amount.from_List [ Amount.usd $ 1 ]) ]
+ Lib.TreeMap.from_List const
+ [ ("A":|[], Amount.from_List [ Amount.usd $ 1 ])
+ , ("B":|[], Amount.from_List [ Amount.usd $ 1 ]) ]
, Calc.Balance.by_unit =
Data.Map.fromList $
Data.List.map Calc.Balance.assoc_unit_sum $
[ Calc.Balance.Unit_Sum
{ Calc.Balance.amount = Amount.usd $ 2
, Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
- [["A"], ["B"]]
+ ["A":|[], "B":|[]]
}
]
}
Calc.Balance.union
(Calc.Balance.Balance
{ Calc.Balance.by_account =
- Data.Map.fromList
- [ (["A"], Amount.from_List [ Amount.usd $ 1 ]) ]
+ Lib.TreeMap.from_List const
+ [ ("A":|[], Amount.from_List [ Amount.usd $ 1 ]) ]
, Calc.Balance.by_unit =
Data.Map.fromList $
Data.List.map Calc.Balance.assoc_unit_sum $
[ Calc.Balance.Unit_Sum
{ Calc.Balance.amount = Amount.usd $ 1
, Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
- [["A"]]
+ ["A":|[]]
}
]
})
(Calc.Balance.Balance
{ Calc.Balance.by_account =
- Data.Map.fromList
- [ (["B"], Amount.from_List [ Amount.eur $ 1 ]) ]
+ Lib.TreeMap.from_List const
+ [ ("B":|[], Amount.from_List [ Amount.eur $ 1 ]) ]
, Calc.Balance.by_unit =
Data.Map.fromList $
Data.List.map Calc.Balance.assoc_unit_sum $
[ Calc.Balance.Unit_Sum
{ Calc.Balance.amount = Amount.eur $ 1
, Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
- [["B"]]
+ ["B":|[]]
}
]
})
~?=
Calc.Balance.Balance
{ Calc.Balance.by_account =
- Data.Map.fromList
- [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
- , (["B"], Amount.from_List [ Amount.eur $ 1 ]) ]
+ Lib.TreeMap.from_List const
+ [ ("A":|[], Amount.from_List [ Amount.usd $ 1 ])
+ , ("B":|[], Amount.from_List [ Amount.eur $ 1 ]) ]
, Calc.Balance.by_unit =
Data.Map.fromList $
Data.List.map Calc.Balance.assoc_unit_sum $
[ Calc.Balance.Unit_Sum
{ Calc.Balance.amount = Amount.usd $ 1
, Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
- [["A"]]
+ ["A":|[]]
}
, Calc.Balance.Unit_Sum
{ Calc.Balance.amount = Amount.eur $ 1
, Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
- [["B"]]
+ ["B":|[]]
}
]
}
]
, "expand" ~: TestList
- [ "nil_By_Account = nil_By_Account" ~:
+ [ "nil_By_Account" ~:
Calc.Balance.expand
Calc.Balance.nil_By_Account
~?=
- (Calc.Balance.Expanded $
- Calc.Balance.nil_By_Account)
+ Lib.TreeMap.empty
, "A+$1 = A+$1" ~:
Calc.Balance.expand
- (Data.Map.fromList
- [ (["A"], Amount.from_List [ Amount.usd $ 1 ]) ])
+ (Lib.TreeMap.from_List const
+ [ ("A":|[], Amount.from_List [ Amount.usd $ 1 ]) ])
~?=
- (Calc.Balance.Expanded $
- Data.Map.fromList
- [ (["A"], Amount.from_List [ Amount.usd $ 1 ]) ])
+ (Lib.TreeMap.from_List const
+ [ ("A":|[], Calc.Balance.Account_Sum_Expanded
+ { Calc.Balance.inclusive = Amount.from_List [ Amount.usd $ 1 ]
+ , Calc.Balance.exclusive = Amount.from_List [ Amount.usd $ 1 ]
+ })
+ ])
, "A/A+$1 = A+$1 A/A+$1" ~:
Calc.Balance.expand
- (Data.Map.fromList
- [ (["A", "A"], Amount.from_List [ Amount.usd $ 1 ]) ])
+ (Lib.TreeMap.from_List const
+ [ ("A":|["A"], Amount.from_List [ Amount.usd $ 1 ]) ])
~?=
- (Calc.Balance.Expanded $
- Data.Map.fromList
- [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
- , (["A", "A"], Amount.from_List [ Amount.usd $ 1 ]) ])
+ (Lib.TreeMap.from_List const
+ [ ("A":|[], Calc.Balance.Account_Sum_Expanded
+ { Calc.Balance.inclusive = Amount.from_List [ Amount.usd $ 1 ]
+ , Calc.Balance.exclusive = Amount.from_List []
+ })
+ , ("A":|["A"], Calc.Balance.Account_Sum_Expanded
+ { Calc.Balance.inclusive = Amount.from_List [ Amount.usd $ 1 ]
+ , Calc.Balance.exclusive = Amount.from_List [ Amount.usd $ 1 ]
+ })
+ ])
, "A/B+$1 = A+$1 A/B+$1" ~:
Calc.Balance.expand
- (Data.Map.fromList
- [ (["A", "B"], Amount.from_List [ Amount.usd $ 1 ]) ])
+ (Lib.TreeMap.from_List const
+ [ ("A":|["B"], Amount.from_List [ Amount.usd $ 1 ]) ])
~?=
- (Calc.Balance.Expanded $
- Data.Map.fromList
- [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
- , (["A", "B"], Amount.from_List [ Amount.usd $ 1 ]) ])
+ (Lib.TreeMap.from_List const
+ [ ("A":|[], Calc.Balance.Account_Sum_Expanded
+ { Calc.Balance.inclusive = Amount.from_List [ Amount.usd $ 1 ]
+ , Calc.Balance.exclusive = Amount.from_List []
+ })
+ , ("A":|["B"], Calc.Balance.Account_Sum_Expanded
+ { Calc.Balance.inclusive = Amount.from_List [ Amount.usd $ 1 ]
+ , Calc.Balance.exclusive = Amount.from_List [ Amount.usd $ 1 ]
+ })
+ ])
, "A/B/C+$1 = A+$1 A/B+$1 A/B/C+$1" ~:
Calc.Balance.expand
- (Data.Map.fromList
- [ (["A", "B", "C"], Amount.from_List [ Amount.usd $ 1 ]) ])
+ (Lib.TreeMap.from_List const
+ [ ("A":|["B", "C"], Amount.from_List [ Amount.usd $ 1 ]) ])
~?=
- (Calc.Balance.Expanded $
- Data.Map.fromList
- [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
- , (["A", "B"], Amount.from_List [ Amount.usd $ 1 ])
- , (["A", "B", "C"], Amount.from_List [ Amount.usd $ 1 ]) ])
+ (Lib.TreeMap.from_List const
+ [ ("A":|[], Calc.Balance.Account_Sum_Expanded
+ { Calc.Balance.inclusive = Amount.from_List [ Amount.usd $ 1 ]
+ , Calc.Balance.exclusive = Amount.from_List []
+ })
+ , ("A":|["B"], Calc.Balance.Account_Sum_Expanded
+ { Calc.Balance.inclusive = Amount.from_List [ Amount.usd $ 1 ]
+ , Calc.Balance.exclusive = Amount.from_List []
+ })
+ , ("A":|["B", "C"], Calc.Balance.Account_Sum_Expanded
+ { Calc.Balance.inclusive = Amount.from_List [ Amount.usd $ 1 ]
+ , Calc.Balance.exclusive = Amount.from_List [ Amount.usd $ 1 ]
+ })
+ ])
, "A+$1 A/B+$1 = A+$2 A/B+$1" ~:
Calc.Balance.expand
- (Data.Map.fromList
- [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
- , (["A", "B"], Amount.from_List [ Amount.usd $ 1 ]) ])
+ (Lib.TreeMap.from_List const
+ [ ("A":|[], Amount.from_List [ Amount.usd $ 1 ])
+ , ("A":|["B"], Amount.from_List [ Amount.usd $ 1 ])
+ ])
~?=
- (Calc.Balance.Expanded $
- Data.Map.fromList
- [ (["A"], Amount.from_List [ Amount.usd $ 2 ])
- , (["A", "B"], Amount.from_List [ Amount.usd $ 1 ]) ])
+ (Lib.TreeMap.from_List const
+ [ ("A":|[], Calc.Balance.Account_Sum_Expanded
+ { Calc.Balance.inclusive = Amount.from_List [ Amount.usd $ 2 ]
+ , Calc.Balance.exclusive = Amount.from_List [ Amount.usd $ 1 ]
+ })
+ , ("A":|["B"], Calc.Balance.Account_Sum_Expanded
+ { Calc.Balance.inclusive = Amount.from_List [ Amount.usd $ 1 ]
+ , Calc.Balance.exclusive = Amount.from_List [ Amount.usd $ 1 ]
+ })
+ ])
, "A+$1 A/B+$1 A/B/C+$1 = A+$3 A/B+$2 A/B/C+$1" ~:
Calc.Balance.expand
- (Data.Map.fromList
- [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
- , (["A", "B"], Amount.from_List [ Amount.usd $ 1 ])
- , (["A", "B", "C"], Amount.from_List [ Amount.usd $ 1 ])
+ (Lib.TreeMap.from_List const
+ [ ("A":|[], Amount.from_List [ Amount.usd $ 1 ])
+ , ("A":|["B"], Amount.from_List [ Amount.usd $ 1 ])
+ , ("A":|["B", "C"], Amount.from_List [ Amount.usd $ 1 ])
])
~?=
- (Calc.Balance.Expanded $
- Data.Map.fromList
- [ (["A"], Amount.from_List [ Amount.usd $ 3 ])
- , (["A", "B"], Amount.from_List [ Amount.usd $ 2 ])
- , (["A", "B", "C"], Amount.from_List [ Amount.usd $ 1 ])
+ (Lib.TreeMap.from_List const
+ [ ("A":|[], Calc.Balance.Account_Sum_Expanded
+ { Calc.Balance.inclusive = Amount.from_List [ Amount.usd $ 3 ]
+ , Calc.Balance.exclusive = Amount.from_List [ Amount.usd $ 1 ]
+ })
+ , ("A":|["B"], Calc.Balance.Account_Sum_Expanded
+ { Calc.Balance.inclusive = Amount.from_List [ Amount.usd $ 2 ]
+ , Calc.Balance.exclusive = Amount.from_List [ Amount.usd $ 1 ]
+ })
+ , ("A":|["B", "C"], Calc.Balance.Account_Sum_Expanded
+ { Calc.Balance.inclusive = Amount.from_List [ Amount.usd $ 1 ]
+ , Calc.Balance.exclusive = Amount.from_List [ Amount.usd $ 1 ]
+ })
])
, "A+$1 A/B+$1 A/B/C+$1 A/B/C/D+$1 = A+$4 A/B+$3 A/B/C+$2 A/B/C/D+$1" ~:
Calc.Balance.expand
- (Data.Map.fromList
- [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
- , (["A", "B"], Amount.from_List [ Amount.usd $ 1 ])
- , (["A", "B", "C"], Amount.from_List [ Amount.usd $ 1 ])
- , (["A", "B", "C", "D"], Amount.from_List [ Amount.usd $ 1 ])
+ (Lib.TreeMap.from_List const
+ [ ("A":|[], Amount.from_List [ Amount.usd $ 1 ])
+ , ("A":|["B"], Amount.from_List [ Amount.usd $ 1 ])
+ , ("A":|["B", "C"], Amount.from_List [ Amount.usd $ 1 ])
+ , ("A":|["B", "C", "D"], Amount.from_List [ Amount.usd $ 1 ])
])
~?=
- (Calc.Balance.Expanded $
- Data.Map.fromList
- [ (["A"], Amount.from_List [ Amount.usd $ 4 ])
- , (["A", "B"], Amount.from_List [ Amount.usd $ 3 ])
- , (["A", "B", "C"], Amount.from_List [ Amount.usd $ 2 ])
- , (["A", "B", "C", "D"], Amount.from_List [ Amount.usd $ 1 ])
+ (Lib.TreeMap.from_List const
+ [ ("A":|[], Calc.Balance.Account_Sum_Expanded
+ { Calc.Balance.inclusive = Amount.from_List [ Amount.usd $ 4 ]
+ , Calc.Balance.exclusive = Amount.from_List [ Amount.usd $ 1 ]
+ })
+ , ("A":|["B"], Calc.Balance.Account_Sum_Expanded
+ { Calc.Balance.inclusive = Amount.from_List [ Amount.usd $ 3 ]
+ , Calc.Balance.exclusive = Amount.from_List [ Amount.usd $ 1 ]
+ })
+ , ("A":|["B", "C"], Calc.Balance.Account_Sum_Expanded
+ { Calc.Balance.inclusive = Amount.from_List [ Amount.usd $ 2 ]
+ , Calc.Balance.exclusive = Amount.from_List [ Amount.usd $ 1 ]
+ })
+ , ("A":|["B", "C", "D"], Calc.Balance.Account_Sum_Expanded
+ { Calc.Balance.inclusive = Amount.from_List [ Amount.usd $ 1 ]
+ , Calc.Balance.exclusive = Amount.from_List [ Amount.usd $ 1 ]
+ })
])
- , "A+$1 A/B+$1 B/A+$1 = A+$2 A/B+$1 B/A+$1" ~:
+ , "A+$1 A/B+$1 A/BB+$1 AA/B+$1 = A+$3 A/B+$1 A/BB+$1 AA+$1 AA/B+$1" ~:
Calc.Balance.expand
- (Data.Map.fromList
- [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
- , (["A", "B"], Amount.from_List [ Amount.usd $ 1 ])
- , (["B", "A"], Amount.from_List [ Amount.usd $ 1 ]) ])
- ~?=
- (Calc.Balance.Expanded $
- Data.Map.fromList
- [ (["A"], Amount.from_List [ Amount.usd $ 2 ])
- , (["A", "B"], Amount.from_List [ Amount.usd $ 1 ])
- , (["B"], Amount.from_List [ Amount.usd $ 1 ])
- , (["B", "A"], Amount.from_List [ Amount.usd $ 1 ]) ])
- , "A+$1 A/B+$1 B/A+$1 = A+$2 A/B+$1 B/A+$1" ~:
- Calc.Balance.expand
- (Data.Map.fromList
- [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
- , (["A", "B"], Amount.from_List [ Amount.usd $ 1 ])
- , (["B", "A"], Amount.from_List [ Amount.usd $ 1 ]) ])
+ (Lib.TreeMap.from_List const
+ [ ("A":|[], Amount.from_List [ Amount.usd $ 1 ])
+ , ("A":|["B"], Amount.from_List [ Amount.usd $ 1 ])
+ , ("A":|["BB"], Amount.from_List [ Amount.usd $ 1 ])
+ , ("AA":|["B"], Amount.from_List [ Amount.usd $ 1 ])
+ ])
~?=
- (Calc.Balance.Expanded $
- Data.Map.fromList
- [ (["A"], Amount.from_List [ Amount.usd $ 2 ])
- , (["A", "B"], Amount.from_List [ Amount.usd $ 1 ])
- , (["B"], Amount.from_List [ Amount.usd $ 1 ])
- , (["B", "A"], Amount.from_List [ Amount.usd $ 1 ]) ])
+ (Lib.TreeMap.from_List const
+ [ ("A":|[], Calc.Balance.Account_Sum_Expanded
+ { Calc.Balance.inclusive = Amount.from_List [ Amount.usd $ 3 ]
+ , Calc.Balance.exclusive = Amount.from_List [ Amount.usd $ 1 ]
+ })
+ , ("A":|["B"], Calc.Balance.Account_Sum_Expanded
+ { Calc.Balance.inclusive = Amount.from_List [ Amount.usd $ 1 ]
+ , Calc.Balance.exclusive = Amount.from_List [ Amount.usd $ 1 ]
+ })
+ , ("A":|["BB"], Calc.Balance.Account_Sum_Expanded
+ { Calc.Balance.inclusive = Amount.from_List [ Amount.usd $ 1 ]
+ , Calc.Balance.exclusive = Amount.from_List [ Amount.usd $ 1 ]
+ })
+ , ("AA":|[], Calc.Balance.Account_Sum_Expanded
+ { Calc.Balance.inclusive = Amount.from_List [ Amount.usd $ 1 ]
+ , Calc.Balance.exclusive = Amount.from_List []
+ })
+ , ("AA":|["B"], Calc.Balance.Account_Sum_Expanded
+ { Calc.Balance.inclusive = Amount.from_List [ Amount.usd $ 1 ]
+ , Calc.Balance.exclusive = Amount.from_List [ Amount.usd $ 1 ]
+ })
+ ])
]
, "is_equilibrable" ~: TestList
[ "nil" ~: TestCase $
Calc.Balance.equilibre $
Calc.Balance.Balance
{ Calc.Balance.by_account =
- Data.Map.fromList
- [ (["A"], Amount.from_List [ Amount.usd $ 0 ])
+ Lib.TreeMap.from_List const
+ [ ("A":|[], Amount.from_List [ Amount.usd $ 0 ])
]
, Calc.Balance.by_unit =
Data.Map.fromList $
[ Calc.Balance.Unit_Sum
{ Calc.Balance.amount = Amount.usd $ 0
, Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
- [["A"]]
+ ["A":|[]]
}
]
}
Calc.Balance.equilibre $
Calc.Balance.Balance
{ Calc.Balance.by_account =
- Data.Map.fromList
- [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
+ Lib.TreeMap.from_List const
+ [ ("A":|[], Amount.from_List [ Amount.usd $ 1 ])
]
, Calc.Balance.by_unit =
Data.Map.fromList $
[ Calc.Balance.Unit_Sum
{ Calc.Balance.amount = Amount.usd $ 1
, Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
- [["A"]]
+ ["A":|[]]
}
]
}
Calc.Balance.equilibre $
Calc.Balance.Balance
{ Calc.Balance.by_account =
- Data.Map.fromList
- [ (["A"], Amount.from_List [ Amount.usd $ 0, Amount.eur $ 0 ])
+ Lib.TreeMap.from_List const
+ [ ("A":|[], Amount.from_List [ Amount.usd $ 0, Amount.eur $ 0 ])
]
, Calc.Balance.by_unit =
Data.Map.fromList $
[ Calc.Balance.Unit_Sum
{ Calc.Balance.amount = Amount.usd $ 0
, Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
- [["A"]]
+ ["A":|[]]
}
, Calc.Balance.Unit_Sum
{ Calc.Balance.amount = Amount.eur $ 0
, Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
- [["A"]]
+ ["A":|[]]
}
]
}
Calc.Balance.equilibre $
Calc.Balance.Balance
{ Calc.Balance.by_account =
- Data.Map.fromList
- [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
- , (["B"], Amount.from_List [ Amount.usd $ -1 ])
+ Lib.TreeMap.from_List const
+ [ ("A":|[], Amount.from_List [ Amount.usd $ 1 ])
+ , ("B":|[], Amount.from_List [ Amount.usd $ -1 ])
]
, Calc.Balance.by_unit =
Data.Map.fromList $
[ Calc.Balance.Unit_Sum
{ Calc.Balance.amount = Amount.usd $ 0
, Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
- [["A"], ["B"]]
+ ["A":|[], "B":|[]]
}
]
}
Calc.Balance.equilibre $
Calc.Balance.Balance
{ Calc.Balance.by_account =
- Data.Map.fromList
- [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
- , (["B"], Amount.from_List [])
+ Lib.TreeMap.from_List const
+ [ ("A":|[], Amount.from_List [ Amount.usd $ 1 ])
+ , ("B":|[], Amount.from_List [])
]
, Calc.Balance.by_unit =
Data.Map.fromList $
[ Calc.Balance.Unit_Sum
{ Calc.Balance.amount = Amount.usd $ 1
, Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
- [["A"]]
+ ["A":|[]]
}
]
}
Calc.Balance.equilibre $
Calc.Balance.Balance
{ Calc.Balance.by_account =
- Data.Map.fromList
- [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
- , (["B"], Amount.from_List [ Amount.eur $ 1 ])
+ Lib.TreeMap.from_List const
+ [ ("A":|[], Amount.from_List [ Amount.usd $ 1 ])
+ , ("B":|[], Amount.from_List [ Amount.eur $ 1 ])
]
, Calc.Balance.by_unit =
Data.Map.fromList $
[ Calc.Balance.Unit_Sum
{ Calc.Balance.amount = Amount.usd $ 1
, Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
- [["A"]]
+ ["A":|[]]
}
, Calc.Balance.Unit_Sum
{ Calc.Balance.amount = Amount.eur $ 1
, Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
- [["B"]]
+ ["B":|[]]
}
]
}
Calc.Balance.equilibre $
Calc.Balance.Balance
{ Calc.Balance.by_account =
- Data.Map.fromList
- [ (["A"], Amount.from_List [ Amount.usd $ 1 ])
- , (["B"], Amount.from_List [ Amount.usd $ -1, Amount.eur $ 1 ])
+ Lib.TreeMap.from_List const
+ [ ("A":|[], Amount.from_List [ Amount.usd $ 1 ])
+ , ("B":|[], Amount.from_List [ Amount.usd $ -1, Amount.eur $ 1 ])
]
, Calc.Balance.by_unit =
Data.Map.fromList $
[ Calc.Balance.Unit_Sum
{ Calc.Balance.amount = Amount.usd $ 0
, Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
- [["A"], ["B"]]
+ ["A":|[], "B":|[]]
}
, Calc.Balance.Unit_Sum
{ Calc.Balance.amount = Amount.eur $ 1
, Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
- [["B"]]
+ ["B":|[]]
}
]
}
Calc.Balance.equilibre $
Calc.Balance.Balance
{ Calc.Balance.by_account =
- Data.Map.fromList
- [ (["A"], Amount.from_List [ Amount.usd $ 1, Amount.eur $ 2, Amount.gbp $ 3 ])
- , (["B"], Amount.from_List [ Amount.usd $ -1, Amount.eur $ -2, Amount.gbp $ -3 ])
+ Lib.TreeMap.from_List const
+ [ ("A":|[], Amount.from_List [ Amount.usd $ 1, Amount.eur $ 2, Amount.gbp $ 3 ])
+ , ("B":|[], Amount.from_List [ Amount.usd $ -1, Amount.eur $ -2, Amount.gbp $ -3 ])
]
, Calc.Balance.by_unit =
Data.Map.fromList $
[ Calc.Balance.Unit_Sum
{ Calc.Balance.amount = Amount.usd $ 0
, Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
- [["A"], ["B"]]
+ ["A":|[], "B":|[]]
}
, Calc.Balance.Unit_Sum
{ Calc.Balance.amount = Amount.eur $ 0
, Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
- [["A"], ["B"]]
+ ["A":|[], "B":|[]]
}
, Calc.Balance.Unit_Sum
{ Calc.Balance.amount = Amount.gbp $ 0
, Calc.Balance.accounts = Data.Map.fromList $ Data.List.map (,())
- [["A"], ["B"]]
+ ["A":|[], "B":|[]]
}
]
}
(Format.Ledger.Read.account <* P.eof)
() "" ("A"::Text)])
~?=
- [["A"]]
+ ["A":|[]]
, "\"A:\" = Left" ~:
(Data.Either.rights $
[P.runParser
(Format.Ledger.Read.account <* P.eof)
() "" ("A:B"::Text)])
~?=
- [["A", "B"]]
+ ["A":|["B"]]
, "\"A:B:C\" = Right [\"A\", \"B\", \"C\"]" ~:
(Data.Either.rights $
[P.runParser
(Format.Ledger.Read.account <* P.eof)
() "" ("A:B:C"::Text)])
~?=
- [["A", "B", "C"]]
+ ["A":|["B", "C"]]
, "\"Aa:Bbb:Cccc\" = Right [\"Aa\", \"Bbb\", \":Cccc\"]" ~:
(Data.Either.rights $
[P.runParser
(Format.Ledger.Read.account <* P.eof)
() "" ("Aa:Bbb:Cccc"::Text)])
~?=
- [["Aa", "Bbb", "Cccc"]]
+ ["Aa":|["Bbb", "Cccc"]]
, "\"A a : B b b : C c c c\" = Right [\"A a \", \" B b b \", \": C c c c\"]" ~:
(Data.Either.rights $
[P.runParser
(Format.Ledger.Read.account <* P.eof)
() "" ("A a : B b b : C c c c"::Text)])
~?=
- [["A a ", " B b b ", " C c c c"]]
+ ["A a ":|[" B b b ", " C c c c"]]
, "\"A: :C\" = Right [\"A\", \" \", \"C\"]" ~:
(Data.Either.rights $
[P.runParser
(Format.Ledger.Read.account <* P.eof)
() "" ("A: :C"::Text)])
~?=
- [["A", " ", "C"]]
+ ["A":|[" ", "C"]]
, "\"A::C\" = Left" ~:
(Data.Either.rights $
[P.runParser
(Format.Ledger.Read.posting <* P.eof)
Format.Ledger.Read.nil_Context "" (" A:B:C"::Text)])
~?=
- [ ( Posting.nil
- { Posting.account = ["A","B","C"]
- , Posting.sourcepos = P.newPos "" 1 1
+ [ ( (Posting.nil ("A":|["B", "C"]))
+ { Posting.sourcepos = P.newPos "" 1 1
}
, Posting.Type_Regular
)
(Format.Ledger.Read.posting <* P.eof)
Format.Ledger.Read.nil_Context "" (" !A:B:C"::Text)])
~?=
- [ Posting.nil
- { Posting.account = ["A","B","C"]
- , Posting.sourcepos = P.newPos "" 1 1
+ [ (Posting.nil ("A":|["B", "C"]))
+ { Posting.sourcepos = P.newPos "" 1 1
, Posting.status = True
}
]
(Format.Ledger.Read.posting <* P.eof)
Format.Ledger.Read.nil_Context "" (" *A:B:C"::Text)])
~?=
- [ Posting.nil
- { Posting.account = ["A","B","C"]
- , Posting.amounts = Data.Map.fromList []
+ [ (Posting.nil ("A":|["B", "C"]))
+ { Posting.amounts = Data.Map.fromList []
, Posting.comments = []
, Posting.dates = []
, Posting.status = True
(Format.Ledger.Read.posting <* P.eof)
Format.Ledger.Read.nil_Context "" (" A:B:C $1"::Text)])
~?=
- [ Posting.nil
- { Posting.account = ["A","B","C $1"]
- , Posting.sourcepos = P.newPos "" 1 1
+ [ (Posting.nil ("A":|["B","C $1"]))
+ { Posting.sourcepos = P.newPos "" 1 1
}
]
, " A:B:C $1 = Right A:B:C $1" ~:
(Format.Ledger.Read.posting <* P.eof)
Format.Ledger.Read.nil_Context "" (" A:B:C $1"::Text)])
~?=
- [ Posting.nil
- { Posting.account = ["A","B","C"]
- , Posting.amounts = Data.Map.fromList
+ [ (Posting.nil ("A":|["B", "C"]))
+ { Posting.amounts = Data.Map.fromList
[ ("$", Amount.nil
{ Amount.quantity = 1
, Amount.style = Amount.Style.nil
(Format.Ledger.Read.posting <* P.eof)
Format.Ledger.Read.nil_Context "" (" A:B:C $1 + 1€"::Text)])
~?=
- [ Posting.nil
- { Posting.account = ["A","B","C"]
- , Posting.amounts = Data.Map.fromList
+ [ (Posting.nil ("A":|["B", "C"]))
+ { Posting.amounts = Data.Map.fromList
[ ("$", Amount.nil
{ Amount.quantity = 1
, Amount.style = Amount.Style.nil
(Format.Ledger.Read.posting <* P.eof)
Format.Ledger.Read.nil_Context "" (" A:B:C $1 + 1$"::Text)])
~?=
- [ Posting.nil
- { Posting.account = ["A","B","C"]
- , Posting.amounts = Data.Map.fromList
+ [ (Posting.nil ("A":|["B", "C"]))
+ { Posting.amounts = Data.Map.fromList
[ ("$", Amount.nil
{ Amount.quantity = 2
, Amount.style = Amount.Style.nil
(Format.Ledger.Read.posting <* P.eof)
Format.Ledger.Read.nil_Context "" (" A:B:C $1 + 1$ + 1$"::Text)])
~?=
- [ Posting.nil
- { Posting.account = ["A","B","C"]
- , Posting.amounts = Data.Map.fromList
+ [ (Posting.nil ("A":|["B", "C"]))
+ { Posting.amounts = Data.Map.fromList
[ ("$", Amount.nil
{ Amount.quantity = 3
, Amount.style = Amount.Style.nil
(Format.Ledger.Read.posting <* P.eof)
Format.Ledger.Read.nil_Context "" (" A:B:C ; some comment"::Text)])
~?=
- [ Posting.nil
- { Posting.account = ["A","B","C"]
- , Posting.amounts = Data.Map.fromList []
+ [ (Posting.nil ("A":|["B", "C"]))
+ { Posting.amounts = Data.Map.fromList []
, Posting.comments = [" some comment"]
, Posting.sourcepos = P.newPos "" 1 1
}
(Format.Ledger.Read.posting <* P.eof)
Format.Ledger.Read.nil_Context "" (" A:B:C ; some comment\n ; some other comment"::Text)])
~?=
- [ Posting.nil
- { Posting.account = ["A","B","C"]
- , Posting.amounts = Data.Map.fromList []
+ [ (Posting.nil ("A":|["B", "C"]))
+ { Posting.amounts = Data.Map.fromList []
, Posting.comments = [" some comment", " some other comment"]
, Posting.sourcepos = P.newPos "" 1 1
}
(Format.Ledger.Read.posting)
Format.Ledger.Read.nil_Context "" (" A:B:C $1 ; some comment"::Text)])
~?=
- [ Posting.nil
- { Posting.account = ["A","B","C"]
- , Posting.amounts = Data.Map.fromList
+ [ (Posting.nil ("A":|["B", "C"]))
+ { Posting.amounts = Data.Map.fromList
[ ("$", Amount.nil
{ Amount.quantity = 1
, Amount.style = Amount.Style.nil
(Format.Ledger.Read.posting <* P.eof)
Format.Ledger.Read.nil_Context "" (" A:B:C ; N:V"::Text)])
~?=
- [ Posting.nil
- { Posting.account = ["A","B","C"]
- , Posting.comments = [" N:V"]
+ [ (Posting.nil ("A":|["B", "C"]))
+ { Posting.comments = [" N:V"]
, Posting.sourcepos = P.newPos "" 1 1
, Posting.tags = Data.Map.fromList
[ ("N", ["V"])
(Format.Ledger.Read.posting <* P.eof)
Format.Ledger.Read.nil_Context "" (" A:B:C ; some comment N:V"::Text)])
~?=
- [ Posting.nil
- { Posting.account = ["A","B","C"]
- , Posting.comments = [" some comment N:V"]
+ [ (Posting.nil ("A":|["B", "C"]))
+ { Posting.comments = [" some comment N:V"]
, Posting.sourcepos = P.newPos "" 1 1
, Posting.tags = Data.Map.fromList
[ ("N", ["V"])
(Format.Ledger.Read.posting )
Format.Ledger.Read.nil_Context "" (" A:B:C ; some comment N:V v, N2:V2 v2"::Text)])
~?=
- [ Posting.nil
- { Posting.account = ["A","B","C"]
- , Posting.comments = [" some comment N:V v, N2:V2 v2"]
+ [ (Posting.nil ("A":|["B", "C"]))
+ { Posting.comments = [" some comment N:V v, N2:V2 v2"]
, Posting.sourcepos = P.newPos "" 1 1
, Posting.tags = Data.Map.fromList
[ ("N", ["V v"])
(Format.Ledger.Read.posting <* P.eof)
Format.Ledger.Read.nil_Context "" (" A:B:C ; N:V\n ; N:V2"::Text)])
~?=
- [ Posting.nil
- { Posting.account = ["A","B","C"]
- , Posting.comments = [" N:V", " N:V2"]
+ [ (Posting.nil ("A":|["B", "C"]))
+ { Posting.comments = [" N:V", " N:V2"]
, Posting.sourcepos = P.newPos "" 1 1
, Posting.tags = Data.Map.fromList
[ ("N", ["V", "V2"])
(Format.Ledger.Read.posting <* P.eof)
Format.Ledger.Read.nil_Context "" (" A:B:C ; N:V\n ; N2:V"::Text)])
~?=
- [ Posting.nil
- { Posting.account = ["A","B","C"]
- , Posting.comments = [" N:V", " N2:V"]
+ [ (Posting.nil ("A":|["B", "C"]))
+ { Posting.comments = [" N:V", " N2:V"]
, Posting.sourcepos = P.newPos "" 1 1
, Posting.tags = Data.Map.fromList
[ ("N", ["V"])
(Format.Ledger.Read.posting <* P.eof)
Format.Ledger.Read.nil_Context "" (" A:B:C ; date:2001/01/01"::Text)])
~?=
- [ Posting.nil
- { Posting.account = ["A","B","C"]
- , Posting.comments = [" date:2001/01/01"]
+ [ (Posting.nil ("A":|["B", "C"]))
+ { Posting.comments = [" date:2001/01/01"]
, Posting.dates =
[ Time.ZonedTime
(Time.LocalTime
(Format.Ledger.Read.posting <* P.eof)
Format.Ledger.Read.nil_Context "" (" (A:B:C)"::Text)])
~?=
- [ ( Posting.nil
- { Posting.account = ["A","B","C"]
- , Posting.sourcepos = P.newPos "" 1 1
+ [ ( (Posting.nil ("A":|["B", "C"]))
+ { Posting.sourcepos = P.newPos "" 1 1
}
, Posting.Type_Virtual
)
(Format.Ledger.Read.posting <* P.eof)
Format.Ledger.Read.nil_Context "" (" [A:B:C]"::Text)])
~?=
- [ ( Posting.nil
- { Posting.account = ["A","B","C"]
- , Posting.sourcepos = P.newPos "" 1 1
+ [ ( (Posting.nil ("A":|["B", "C"]))
+ { Posting.sourcepos = P.newPos "" 1 1
}
, Posting.Type_Virtual_Balanced
)
, [] )
, Transaction.description="some description"
, Transaction.postings = Posting.from_List
- [ Posting.nil
- { Posting.account = ["A","B","C"]
- , Posting.amounts = Data.Map.fromList
+ [ (Posting.nil ("A":|["B", "C"]))
+ { Posting.amounts = Data.Map.fromList
[ ("$", Amount.nil
{ Amount.quantity = 1
, Amount.style = Amount.Style.nil
]
, Posting.sourcepos = P.newPos "" 2 1
}
- , Posting.nil
- { Posting.account = ["a","b","c"]
- , Posting.sourcepos = P.newPos "" 3 1
+ , (Posting.nil ("a":|["b", "c"]))
+ { Posting.sourcepos = P.newPos "" 3 1
}
]
, Transaction.sourcepos = P.newPos "" 1 1
, [] )
, Transaction.description="some description"
, Transaction.postings = Posting.from_List
- [ Posting.nil
- { Posting.account = ["A","B","C"]
- , Posting.amounts = Data.Map.fromList
+ [ (Posting.nil ("A":|["B", "C"]))
+ { Posting.amounts = Data.Map.fromList
[ ("$", Amount.nil
{ Amount.quantity = 1
, Amount.style = Amount.Style.nil
]
, Posting.sourcepos = P.newPos "" 2 1
}
- , Posting.nil
- { Posting.account = ["a","b","c"]
- , Posting.sourcepos = P.newPos "" 3 1
+ , (Posting.nil ("a":|["b", "c"]))
+ { Posting.sourcepos = P.newPos "" 3 1
}
]
, Transaction.sourcepos = P.newPos "" 1 1
, [] )
, Transaction.description="some description"
, Transaction.postings = Posting.from_List
- [ Posting.nil
- { Posting.account = ["A","B","C"]
- , Posting.amounts = Data.Map.fromList
+ [ (Posting.nil ("A":|["B", "C"]))
+ { Posting.amounts = Data.Map.fromList
[ ("$", Amount.nil
{ Amount.quantity = 1
, Amount.style = Amount.Style.nil
]
, Posting.sourcepos = P.newPos "" 5 1
}
- , Posting.nil
- { Posting.account = ["a","b","c"]
- , Posting.sourcepos = P.newPos "" 6 1
+ , (Posting.nil ("a":|["b", "c"]))
+ { Posting.sourcepos = P.newPos "" 6 1
, Posting.tags = Data.Map.fromList []
}
]
, [] )
, Transaction.description="1° description"
, Transaction.postings = Posting.from_List
- [ Posting.nil
- { Posting.account = ["A","B","C"]
- , Posting.amounts = Data.Map.fromList
+ [ (Posting.nil ("A":|["B", "C"]))
+ { Posting.amounts = Data.Map.fromList
[ ("$", Amount.nil
{ Amount.quantity = 1
, Amount.style = Amount.Style.nil
]
, Posting.sourcepos = P.newPos "" 2 1
}
- , Posting.nil
- { Posting.account = ["a","b","c"]
- , Posting.sourcepos = P.newPos "" 3 1
+ , (Posting.nil ("a":|["b", "c"]))
+ { Posting.sourcepos = P.newPos "" 3 1
}
]
, Transaction.sourcepos = P.newPos "" 1 1
, [] )
, Transaction.description="2° description"
, Transaction.postings = Posting.from_List
- [ Posting.nil
- { Posting.account = ["A","B","C"]
- , Posting.amounts = Data.Map.fromList
+ [ (Posting.nil ("A":|["B", "C"]))
+ { Posting.amounts = Data.Map.fromList
[ ("$", Amount.nil
{ Amount.quantity = 1
, Amount.style = Amount.Style.nil
]
, Posting.sourcepos = P.newPos "" 5 1
}
- , Posting.nil
- { Posting.account = ["x","y","z"]
- , Posting.sourcepos = P.newPos "" 6 1
+ , (Posting.nil ("x":|["y", "z"]))
+ { Posting.sourcepos = P.newPos "" 6 1
}
]
, Transaction.sourcepos = P.newPos "" 4 1
]
, "Write" ~: TestList
[ "account" ~: TestList
- [ "nil" ~:
- ((Format.Ledger.Write.show False $
- Format.Ledger.Write.account Posting.Type_Regular
- Account.nil)
- ~?=
- "")
- , "A" ~:
+ [ "A" ~:
((Format.Ledger.Write.show False $
- Format.Ledger.Write.account Posting.Type_Regular
- ["A"])
+ Format.Ledger.Write.account Posting.Type_Regular $
+ "A":|[])
~?=
"A")
, "A:B:C" ~:
((Format.Ledger.Write.show False $
- Format.Ledger.Write.account Posting.Type_Regular
- ["A", "B", "C"])
+ Format.Ledger.Write.account Posting.Type_Regular $
+ "A":|["B", "C"])
~?=
"A:B:C")
, "(A:B:C)" ~:
((Format.Ledger.Write.show False $
- Format.Ledger.Write.account Posting.Type_Virtual
- ["A", "B", "C"])
+ Format.Ledger.Write.account Posting.Type_Virtual $
+ "A":|["B", "C"])
~?=
"(A:B:C)")
, "[A:B:C]" ~:
((Format.Ledger.Write.show False $
- Format.Ledger.Write.account Posting.Type_Virtual_Balanced
- ["A", "B", "C"])
+ Format.Ledger.Write.account Posting.Type_Virtual_Balanced $
+ "A":|["B", "C"])
~?=
"[A:B:C]")
]
, [] )
, Transaction.description="some description"
, Transaction.postings = Posting.from_List
- [ Posting.nil
- { Posting.account = ["A","B","C"]
- , Posting.amounts = Data.Map.fromList
+ [ (Posting.nil ("A":|["B", "C"]))
+ { Posting.amounts = Data.Map.fromList
[ ("$", Amount.nil
{ Amount.quantity = 1
, Amount.style = Amount.Style.nil
})
]
}
- , Posting.nil
- { Posting.account = ["a","b","c"]
- , Posting.comments = ["first comment","second comment","third comment"]
+ , (Posting.nil ("a":|["b", "c"]))
+ { Posting.comments = ["first comment","second comment","third comment"]
}
]
})
, [] )
, Transaction.description="some description"
, Transaction.postings = Posting.from_List
- [ Posting.nil
- { Posting.account = ["A","B","C"]
- , Posting.amounts = Data.Map.fromList
+ [ (Posting.nil ("A":|["B", "C"]))
+ { Posting.amounts = Data.Map.fromList
[ ("$", Amount.nil
{ Amount.quantity = 1
, Amount.style = Amount.Style.nil
})
]
}
- , Posting.nil
- { Posting.account = ["AA","BB","CC"]
- , Posting.amounts = Data.Map.fromList
+ , (Posting.nil ("AA":|["BB", "CC"]))
+ { Posting.amounts = Data.Map.fromList
[ ("$", Amount.nil
{ Amount.quantity = 123
, Amount.style = Amount.Style.nil
sourcephile / git / comptalang.git / commitdiff