Add AccountGroup and cleanup (#6)

* [DO NOT MERGE] WIP

* Add Identifier and AccountNode

* Split to multiline and add AccountId()

Author: Eric Forgy

src/Ledgers.jl

@@ -18,102 +18,96 @@ import Instruments: instrument, symbol, amount, name, currency
 export Credit, Debit, Account, Ledger, Entry, AccountId, AccountInfo
 export id, balance, credit!, debit!, post!, instrument, symbol, amount, name, currency
 
-struct AccountId{T}
-    value::T
+abstract type Identifier end
+struct AccountId <: Identifier
+    value::UUID
 end
+AccountId() = AccountId(uuid4())
 
-Base.show(io::IO, id::AccountId) = print(io, id.value)
+struct AccountCode
+    value::String
+end
 
-mutable struct Account{P<:Position,I<:AccountId}
-    id::I
+abstract type AccountType end
+struct Credit <: AccountType end
+struct Debit <: AccountType end
+
+mutable struct Account{P<:Position}
+    id::AccountId
     balance::P
 end
-Account(balance::Position) = Account(AccountId(uuid4()), balance)
+Account(balance::Position) = Account(AccountId(), balance)
 
-# Identity function (to make code more generic)
-account(v::Account) = v
+abstract type AccountNode end
+struct AccountInfo{AT<:AccountType,A<:Account} <: AccountNode
+    account::A
+    code::AccountCode
+    name::String
 
-id(account::Account) = account.id
-balance(account::Account) = account.balance
+    function AccountInfo(::Type{T}, account, code, name) where {T<:AccountType}
+        return new{T}(account, code, name)
+    end
+end
 
-instrument(::Account{P}) where {P<:Position} = instrument(P)
-symbol(::Account{P}) where {P<:Position} = symbol(P)
-currency(::Account{P}) where {P<:Position} = currency(P)
+struct AccountGroup{AT<:AccountType} <: AccountNode
+    code::AccountCode
+    name::String
+    parent::Union{Nothing,AccountGroup{<:AccountType}}
+    subaccounts::Vector{AccountInfo}
+    subgroups::Vector{AccountGroup}
 
-amount(amt::Account) = amount(amt.balance)
+    function AccountGroup(::Type{T}, account, name, parent=nothing) where {T<:AccountType}
+        new{T}(account, code, name, parent, Vector{AccountInfo}(), Vector{AccountGroup}())
+    end
+end
 
-debit!(account::Account, amt::Position) = (account.balance += amt)
-credit!(account::Account, amt::Position) = (account.balance -= amt)
+# Identity function (to make code more generic)
+account(acc::Account) = acc
+account(info::AccountInfo) = info.account
 
-Base.show(io::IO, account::Account) = print(io, "$(string(id(account))): $(balance(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
 
-struct Entry{D,C}
-    debit::D
-    credit::C
-end
+parent(group::AccountGroup) = group.parent
+subaccounts(group::AccountGroup) = group.subaccounts
+subgroups(group::AccountGroup) = group.subgroups
 
-Base.show(io::IO, e::Entry{<:Account,<:Account}) =
-    print(io, "Entry:\n", "  Debit: $(e.debit)\n", "  Credit: $(e.credit)")
+id(acc::Account) = acc.id
+id(info::AccountInfo) = id(account(info))
 
-abstract type AccountType end
-struct Credit <: AccountType end
-struct Debit <: AccountType end
+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)))
 
-Base.show(io::IO, ::Type{Debit}) = print(io, "Debit")
-Base.show(io::IO, ::Type{Credit}) = print(io, "Credit")
+instrument(::Account{P}) where {P<:Position} = instrument(P)
+instrument(info::AccountInfo) = instrument(account(info))
 
-# SPJ: this does not maintain the distinction we'd talked about, of keeping
-# all debit accounts and all credit accounts in with separate types.
-# This will end up doing a lot of processing at run-time, and will be relatively
-# rather slow compared to what we had discussed.
+symbol(::Account{P}) where {P<:Position} = symbol(P)
+symbol(info::AccountInfo) = symbol(account(info))
 
-struct AccountInfo{T<:AccountType}
-    account::Account
-    name::String
-    parent::Union{Nothing,AccountInfo}
-    subaccounts::Vector{AccountInfo}
+currency(::Account{P}) where {P<:Position} = currency(P)
+currency(info::AccountInfo) = currency(account(info))
 
-    function AccountInfo(::Type{T}, account, name, parent=nothing) where {T<:AccountType}
-        ag = new{T}(account, name, parent, Vector{AccountInfo}())
-        (parent === nothing) || push!(parent.subaccounts, ag)
-        return ag
-    end
-end
+amount(acc::Account) = amount(balance(acc))
+amount(info::AccountInfo) = amount(balance(account(info)))
 
-account(info::AccountInfo) = info.account
-name(info::AccountInfo) = info.name
-parent(info::AccountInfo) = info.parent
-subaccounts(info::AccountInfo) = info.subaccounts
+debit!(acc::Account, amt::Position) = (acc.balance += amt)
+credit!(acc::Account, amt::Position) = (acc.balance -= amt)
 
-id(info::AccountInfo) = id(account(info))
-balance(info::AccountInfo{Debit}) = 
-    isempty(subaccounts(info)) ? balance(account(info)) : 
-    balance(account(info)) + sum(map(info->balance(account(info)), subaccounts(info)))
-balance(info::AccountInfo{Credit}) = 
-    isempty(subaccounts(info)) ? -balance(account(info)) :
-    -balance(account(info)) - sum(map(info->balance(account(info)), subaccounts(info)))
+struct Entry{D<:Account,C<:Account}
+    debit::D
+    credit::C
+end
 
 function post!(entry::Entry, amt::Position)
     debit!(account(entry.debit), amt)
     credit!(account(entry.credit), amt)
     entry
 end
 
-AbstractTrees.children(info::AccountInfo) =
-    isempty(subaccounts(info)) ? Vector{AccountInfo}() : subaccounts(info)
-AbstractTrees.printnode(io::IO,info::AccountInfo) =
-    print(io, "$(name(info)) ($(id(info))): $(balance(info))")
-
-Base.show(io::IO,info::AccountInfo) =
-    isempty(subaccounts(info)) ? printnode(io, info) : print_tree(io, info)
-
-function Base.show(io::IO, e::Entry)
-    print(io,
-          "Entry:\n",
-          "  Debit: $(name(e.debit)) ($(id(e.debit))): $(balance(e.debit))\n",
-          "  Credit: $(name(e.credit)) ($(id(e.credit))): $(balance(e.credit))\n")
-end
-
 struct Ledger{P<:Position,I<:AccountId}
     indexes::Dict{I,Int}
     accounts::StructArray{Account{P,I}}
@@ -128,15 +122,14 @@ struct Ledger{P<:Position,I<:AccountId}
 end
 
 Base.getindex(ledger::Ledger, ix) = ledger.accounts[ix]
-
 Base.getindex(ledger::Ledger, id::AccountId) =
     ledger.accounts[ledger.indexes[id]]
 Base.getindex(ledger::Ledger, array::AbstractVector{<:AccountId}) =
     ledger.accounts[broadcast(id->ledger.indexes[id], array)]
 
-function add_account!(ledger::Ledger, account::Account)
-    push!(ledger.accounts, account)
-    ledger.indexes[id(account)] = length(ledger.accounts)
+function add_account!(ledger::Ledger, acc::Account)
+    push!(ledger.accounts, acc)
+    ledger.indexes[id(acc)] = length(ledger.accounts)
 end
 
 # const chartofaccounts = Dict{String,AccountGroup{<:Cash}}()
@@ -180,4 +173,33 @@ end
 #     return newaccount
 # 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, 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(info::AccountInfo) =
+#     isempty(subaccounts(info)) ? Vector{AccountInfo}() : subaccounts(info)
+# AbstractTrees.printnode(io::IO,info::AccountInfo) =
+#     print(io, "$(name(info)) ($(id(info))): $(balance(info))")
+
+# Base.show(io::IO,info::AccountInfo) =
+#     isempty(subaccounts(info)) ? printnode(io, info) : print_tree(io, info)
+
+# Base.show(io::IO, e::Entry) =
+#     print(io, "Entry:\n", "  Debit: $(e.debit)\n", "  Credit: $(e.credit)")
+
+# function Base.show(io::IO, e::Entry)
+#     print(io,
+#           "Entry:\n",
+#           "  Debit: $(name(e.debit)) ($(id(e.debit))): $(balance(e.debit))\n",
+#           "  Credit: $(name(e.credit)) ($(id(e.credit))): $(balance(e.credit))\n")
+# end
+
 end # module Ledgers