moneyGuru

moneyGuru is a personal finance management application. With it, you can evaluate your financial situation so you can make informed (and thus better) decisions. Most finance applications have the same goal, but moneyGuru's difference is in the way it achieves it. Rather than having reports which you have to configure (or find out which pre-configured report is the right one), your important financial data (net worth, profit) is constantly up-to-date and "in your face". This allows you to constantly make informed decision rather than doing so periodically.

Unmaintained

This project has been on life support for a while, but I still maintained it because I still used it. Not any more.

As I write in the context of my new primary (very niche) project, I believe that current modern technology is unsustainable, lacks resilience, and is on course for collapse within the decade (or two. I tend to be overly pessimistic). I'm in the process of severing my ties to it and I've reverted to physical paper accounting. Simplicity over efficiency feels good.

This makes this project unmaintained. It was in the middle of a rewrite that was going well, but still had some problems compared to the 2.13.1 release.

Users, until you find a replacement, I recommend that you use 2.13.1.

If anyone wants to fork this, please do! If it looks good, I'll be happy to link to the fork. I think it would be a good idea to change the name.

If the forker is more of a Python person, she would probably want to fork from 2.11. If she prefers C, then she can fork from master.

The great C rewrite

If you look at recent commits in this project, you'll notice that there a lot of activity to rewrite Python code in C. Yup, that's what I'm doing. The long term goal would be to rewrite the entirety of core in C, keeping only the Python test suite. That would be a huge effort though. core.gui, core.document are too big and dynamic. I don't think I'll actually get there. core.model, core.loader and core.saver are more realistic goals.

Why am I doing this? Mostly because I'm aching to become more intimate with C. Sure, I already know C a little bit, did toy projects, participated to other established ones, but I don't feel like I'm proficient in C. I don't know what it takes to build a "real C app" with everything it entails (proper build system, using glibc, really have to deal with memory management problems, using well known libraries (sqlite and soon icu), internalizing pointer logic (I know how pointers work, but it's not natural for my brain to think about pointer logic))

In almost any case, if you're telling me "I'm planning on rewriting this 50K SLOC python app", I'm going to tell you "you're crazy, it's a guaranteed failure".

However, 10 years ago when I insisted on strict TDD with all tests being at the integration testing level, that costed me a lot of efforts that ended up being a bit useless, considering the limited success of the application.

It occurred to me recently that the result of that effort was a great untapped asset because it does allow the kind of rewrite that in any other situation would be a guaranteed failure: test coverage on moneyGuru is very good and is written at a level that allows everything underneath to take pretty much any form.

Those tests are like a teacher telling me "you're doing it (wrong|right)". If tests pass without segfaults, it has pretty good chances of being sound code because many many cases are covered. That allows me to try a lot of thing. The only uncaught problem is memory leaks. I'll have to learn using tools to detect them soon.

If moneyGuru had other developers around it, I wouldn't do it because it would be rather rude to them, but since I'm pretty much alone with this project, I'm paying myself a learning lesson.

Users shouldn't suffer much from the rewrite: test coverage is very good and I still use this app for my own personal needs, so it's not going to end up with glaring post-rewrite problems. Users will, on the other hand, benefit from decreased resource usage and increased speed.

Contents of this folder

This package contains the source for moneyGuru. Its documentation is available online. Here's how this source tree is organised:

• ccore: The "very core" code of moneyGuru. Written in C. Introduced recently, will expand with time. The goal could be to rewrite the whole of core in C, but core.gui will be a big chunk. Might not be worth it.
• core: Contains the core logic code for moneyGuru. It's Python code.
• qt: UI code for the Qt toolkit. It's written in Python and uses PyQt.
• images: Images used by the different UI codebases.
• help: Help document, written for [Sphinx][sphinx].
• locale: .po files for localisation.
• support: various files to help with the build process.

There are also other sub-folder that comes from external repositories and are part of this repo as git submodules:

• qtlib: A collection of helpers used across Qt UI codebases of HS applications.

How to build moneyGuru from source

Prerequisites

• Python 3.5+
• PyQt5
• SQLite 3 (as a library)
• Glib
• GNU build environment

On Ubuntu, the apt-get command to install all pre-requisites is:

$ apt-get install python3-dev python3-pyqt5 pyqt5-dev-tools libsqlite3-dev \
    glib2.0-dev gettext

On Gentoo, it's:

$ USE="gui widgets printsupport" emerge PyQt5 
$ emerge dev-libs/glib:2 dev-db/sqlite sys-devel/gettext

make

moneyGuru is built with "make":

$ make
$ make run

Running tests

Prerequisites

• CUnit
• Tox

Running

The complete test suite is ran with Tox. cd into the project folder and run tox.

You can also run automated tests without Tox but you'll need to install pytest 3.10+. You can then run pytest core

There are some C-only tests that run with Cunit. Tox already runs them, but if you want to run them as well, you can cd into ccore and run make tests.

Further documentation

For further development-related documentation, there's a "moneyGuru Developer Documentation" section in the english version of the main documentation. This documentation is built with the app and is also available online.