First working (kind of) version with new design (#7)

* [DO NOT MERGE] It compiles...

* Example is working

* Add tests

* Add tree display

Author: Eric Forgy

src/Ledgers.jl

@@ -12,94 +12,119 @@ Licensed under MIT License, see LICENSE.md
 module Ledgers
 
 using UUIDs, StructArrays, AbstractTrees
-using Instruments, Assets
+using Instruments
 import Instruments: instrument, symbol, amount, name, currency
+using Assets: USD
 
-export Credit, Debit, Account, Ledger, Entry, AccountId, AccountInfo
-export id, balance, credit!, debit!, post!, instrument, symbol, amount, name, currency
+export Account, Ledger, Entry, AccountId, AccountCode, AccountInfo, AccountGroup
+export id, balance, credit!, debit!, post!, instrument, symbol, amount, code, name, currency
+export parent, subaccounts, subgroups
 
 abstract type Identifier end
+
 struct AccountId <: Identifier
     value::UUID
 end
+
 AccountId() = AccountId(uuid4())
 
 struct AccountCode
     value::String
 end
 
-abstract type AccountType end
-struct Credit <: AccountType end
-struct Debit <: AccountType end
+abstract type AccountType{B <: Position} end
 
-mutable struct Account{P<:Position}
+mutable struct Account{B <: Position} <: AccountType{B}
     id::AccountId
-    balance::P
+    balance::B
 end
-Account(balance::Position) = Account(AccountId(), balance)
 
-abstract type AccountNode end
-struct AccountInfo{AT<:AccountType,A<:Account} <: AccountNode
-    account::A
+Account(balance::Position) = Account{typeof(balance)}(AccountId(), balance)
+
+abstract type AccountNode{B <: Position} <: AccountType{B} end
+
+struct AccountInfo{B <: Position} <: AccountNode{B}
+    account::Account{B}
     code::AccountCode
     name::String
+    isdebit::Bool
 
-    function AccountInfo(::Type{T}, account, code, name) where {T<:AccountType}
-        return new{T}(account, code, name)
+    function AccountInfo{B}(account::Account{B}, code, name, isdebit=true, parent=nothing) where {B <: Position}
+        acc = new{B}(account, code, name, isdebit)
+        parent === nothing || push!(parent.subaccounts, acc)
+        acc
     end
 end
 
-struct AccountGroup{AT<:AccountType} <: AccountNode
+AccountInfo(account::Account{B}, code, name, isdebit=true, parent=nothing) where {B <: Position} =
+    AccountInfo{B}(account, code, name, isdebit, parent)
+
+struct AccountGroup{B <: Position} <: AccountNode{B}
+    id::AccountId
     code::AccountCode
     name::String
-    parent::Union{Nothing,AccountGroup{<:AccountType}}
-    subaccounts::Vector{AccountInfo}
-    subgroups::Vector{AccountGroup}
-
-    function AccountGroup(::Type{T}, account, name, parent=nothing) where {T<:AccountType}
-        new{T}(account, code, name, parent, Vector{AccountInfo}(), Vector{AccountGroup}())
+    isdebit::Bool
+    parent::Union{Nothing,AccountGroup{B}}
+    subaccounts::StructArray{AccountInfo{B}}
+    subgroups::StructArray{AccountGroup{B}}
+
+    function AccountGroup{B}(
+        id,
+        code,
+        name,
+        isdebit=true,
+        parent=nothing,
+        subaccounts=StructArray(Vector{AccountInfo{B}}()),
+        subgroups=StructArray(Vector{AccountGroup{B}}())) where {B <: Position}
+        acc = new{B}(id, code, name, isdebit, parent, subaccounts, subgroups)
+        parent === nothing || push!(parent.subgroups, acc)
+        acc
     end
 end
 
+AccountGroup(
+    ::B,
+    code,
+    name,
+    isdebit=true,
+    parent=nothing, 
+    subaccounts=StructArray(Vector{AccountInfo{B}}()),
+    subgroups=StructArray(Vector{AccountGroup{B}}())) where {B <: Position} =
+    AccountGroup{B}(AccountId(), code, name, isdebit, parent, subaccounts, subgroups)
+
 # Identity function (to make code more generic)
-account(acc::Account) = acc
+account(acc::AccountType) = acc
 account(info::AccountInfo) = info.account
 
-account_type(::Union{AccountInfo{AT},AccountGroup{AT}}) where {AT} = AT
-code(acc::Union{<:AccountInfo,<:AccountGroup}) = acc.code
-name(acc::Union{<:AccountInfo,<:AccountGroup}) = acc.name
+code(acc::AccountNode) = acc.code
+name(acc::AccountNode) = acc.name
+isdebit(acc::AccountNode) = acc.isdebit
 
 parent(group::AccountGroup) = group.parent
 subaccounts(group::AccountGroup) = group.subaccounts
 subgroups(group::AccountGroup) = group.subgroups
 
-id(acc::Account) = acc.id
-id(info::AccountInfo) = id(account(info))
+id(acc::AccountType) = account(acc).id
 
-balance(acc::Account) = acc.balance
-balance(info::AccountInfo) = balance(account(info))
-balance(group::AccountGroup) = 
-    sum(map(info->balance(info), subaccounts(group))) + 
-    sum(map(grp->balance(grp), subgroups(group)))
+balance(acc) = account(acc).balance
+balance(group::AccountGroup) = isempty(subgroups(group)) ?
+    sum(balance.(subaccounts(group))) :
+    sum(balance.(subaccounts(group))) + sum(balance.(subgroups(group)))
 
-instrument(::Account{P}) where {P<:Position} = instrument(P)
-instrument(info::AccountInfo) = instrument(account(info))
+instrument(::AccountType{B}) where {B <: Position} = instrument(B)
 
-symbol(::Account{P}) where {P<:Position} = symbol(P)
-symbol(info::AccountInfo) = symbol(account(info))
+symbol(::AccountType{B}) where {B <: Position} = symbol(B)
 
-currency(::Account{P}) where {P<:Position} = currency(P)
-currency(info::AccountInfo) = currency(account(info))
+currency(::AccountType{B}) where {B <: Position} = currency(B)
 
-amount(acc::Account) = amount(balance(acc))
-amount(info::AccountInfo) = amount(balance(account(info)))
+amount(acc::AccountType) = amount(balance(acc))
 
 debit!(acc::Account, amt::Position) = (acc.balance += amt)
 credit!(acc::Account, amt::Position) = (acc.balance -= amt)
 
-struct Entry{D<:Account,C<:Account}
-    debit::D
-    credit::C
+struct Entry{B <: Position}
+    debit::AccountInfo{B}
+    credit::AccountInfo{B}
 end
 
 function post!(entry::Entry, amt::Position)
@@ -108,16 +133,16 @@ function post!(entry::Entry, amt::Position)
     entry
 end
 
-struct Ledger{P<:Position,I<:AccountId}
-    indexes::Dict{I,Int}
-    accounts::StructArray{Account{P,I}}
+struct Ledger{P <: Position}
+    indexes::Dict{AccountId,Int}
+    accounts::StructArray{Account{P}}
 
-    function Ledger(accounts::Vector{Account{P,I}}) where {P<:Position,I<:AccountId}
-        indexes = Dict{I,Int}()
+    function Ledger(accounts::Vector{Account{P}}) where {P <: Position}
+        indexes = Dict{AccountId,Int}()
         for (index, account) in enumerate(accounts)
             indexes[id(account)] = index
         end
-        new{P,I}(indexes, StructArray(accounts))
+        new{P}(indexes, StructArray(accounts))
     end
 end
 
@@ -132,6 +157,18 @@ function add_account!(ledger::Ledger, acc::Account)
     ledger.indexes[id(acc)] = length(ledger.accounts)
 end
 
+function example()
+    group = AccountGroup(USD(0), AccountCode("0000000"), "Account Group", false)
+    assets = AccountGroup(USD(0), AccountCode("1000000"), "Assets", true, group)
+    liabilities = AccountGroup(USD(0), AccountCode("2000000"), "Liabilities", false, group)
+    cash = AccountInfo(Account(USD(0)), AccountCode("1010000"), "Cash", true, assets)
+    payable = AccountInfo(Account(USD(0)), AccountCode("2010000"), "Accounts Payable", false, liabilities)
+
+    entry = Entry(cash, payable)
+    group, assets, liabilities, cash, payable, entry
+end
+
+
 # const chartofaccounts = Dict{String,AccountGroup{<:Cash}}()
 
 # function getledger(a::AccountGroup)
@@ -174,15 +211,23 @@ end
 # end
 
 Base.show(io::IO, id::Identifier) = print(io, id.value)
+
 Base.show(io::IO, code::AccountCode) = print(io, code.value)
 
-Base.show(io::IO, ::Type{Debit}) = print(io, "Debit")
-Base.show(io::IO, ::Type{Credit}) = print(io, "Credit")
+Base.show(io::IO, acc::Account) = print(io, "$(string(id(acc))): $(balance(acc))")
+
+Base.show(io::IO, acc::AccountNode) = print_tree(io, acc)
+
+Base.show(io::IO, entry::Entry) = print_tree(io, entry)
+
+AbstractTrees.children(acc::AccountGroup) = vcat(Vector(subgroups(acc)),Vector(subaccounts(acc)))
+
+AbstractTrees.printnode(io::IO, acc::AccountNode) = 
+    print(io, "[$(code(acc))] $(name(acc)): $(isdebit(acc) ? balance(acc) : -balance(acc))")
 
-Base.show(io::IO, acc::Account) = print(io, "$(string(id(acc))): $(balance(acc)).")
-Base.show(io::IO, info::AccountInfo{Debit}) = print(io, "$(code(info)) - $(name(info)): $(balance(info)).")
-Base.show(io::IO, info::AccountInfo{Credit}) = print(io, "$(code(info)) - $(name(info)): $(-balance(info)).")
+AbstractTrees.children(entry::Entry) = [entry.debit, entry.credit]
 
+AbstractTrees.printnode(io::IO, ::Entry) = print(io, "Entry:")
 
 # AbstractTrees.children(info::AccountInfo) =
 #     isempty(subaccounts(info)) ? Vector{AccountInfo}() : subaccounts(info)

test/runtests.jl

@@ -1,20 +1,24 @@
 using Ledgers, Test
 using Assets: USD
 
-group = AccountInfo(Credit, Account(AccountId("0000000"), USD(0)), "Account Group")
-assets = AccountInfo(Debit, Account(AccountId("1000000"), USD(0)),
-                     "Assets", group)
-liabilities = AccountInfo(Credit, Account(AccountId("2000000"), USD(0)),
-                          "Liabilities", group)
-cash = AccountInfo(Debit, Account(AccountId("1010000"), USD(0)),
-                   "Cash", assets)
-payable = AccountInfo(Credit, Account(AccountId("2010000"), USD(0)),
-                      "Accounts Payable", liabilities)
-
-entry = Entry(cash, payable)
+group, assets, liabilities, cash, payable, entry = Ledgers.example()
 
 @testset "Account creation" begin
     @test id(group) isa AccountId
     @test id(assets) isa AccountId
-    @test id(cash).value == "1010000"
+    @test code(cash).value === "1010000"
+    @test name(payable) === "Accounts Payable"
+    @test balance(group) === 0USD
+    @test balance(assets) === 0USD
+    @test balance(liabilities) === 0USD
 end
+
+@testset "Post entry" begin
+    amt = 10USD
+    post!(entry, amt)
+    @test balance(group) === 0USD
+    @test balance(assets) === amt
+    @test balance(liabilities) === -amt
+    @test balance(cash) === amt
+    @test balance(payable) === -amt
+end