Name: double_entry
Owner: Buildkite
Description: null
Forked from: keithpitt/double_entry
Created: 2017-01-11 23:25:26.0
Updated: 2017-01-11 23:25:29.0
Pushed: 2017-01-11 23:51:03.0
Size: 266
Language: Ruby
GitHub Committers
| User | Most Recent Commit | # Commits |
|---|
Other Committers
| User | Most Recent Commit | # Commits |
|---|
Keep track of all the monies!
DoubleEntry is an accounting system based on the principles of a Double-entry Bookkeeping system. While this gem acts like a double-entry bookkeeping system, as it creates two entries in the database for each transfer, it does not enforce accounting rules.
DoubleEntry uses the Money gem to avoid floating point rounding errors.
DoubleEntry has been tested with:
Ruby Versions: 1.9.3, 2.0.0, 2.1.2
Rails Versions: Rails 3.2.x, 4.0.x, 4.1.x
Databases Supported:
In your application's Gemfile, add:
'double_entry'
Download and install the gem with Bundler:
le
Generate Rails schema migrations for the required tables:
s generate double_entry:install
Update the local database:
db:migrate
The entire API for recording financial transactions is available through a few methods in the DoubleEntry module. For full details on what the API provides, please view the documentation on these methods.
A configuration file should be used to define a set of accounts, and potential transfers between those accounts. See the Configuration section for more details.
Money is kept in Accounts.
Each Account has a scope, which is used to subdivide the account into smaller accounts. For example, an account can be scoped by user to ensure that each user has their own individual account.
Scoping accounts is recommended. Unscoped accounts may perform more slowly than scoped accounts due to lock contention.
To get a particular account:
unt = DoubleEntry.account(:spending, :scope => user)
(This actually returns an Account::Instance object.)
See DoubleEntry::Account for more info.
Calling:
unt.balance
will return the current balance for an account as a Money object.
To transfer money between accounts:
leEntry.transfer(
.dollars,
rom => one_account,
o => another_account,
ode => :a_business_code_for_this_type_of_transfer,
The possible transfers, and their codes, should be defined in the configuration.
See DoubleEntry::Transfer for more info.
If you're doing more than one transfer in a single financial transaction, or you're doing other database operations along with the transfer, you'll need to manually lock the accounts you're using:
leEntry.lock_accounts(account_a, account_b) do
Perhaps transfer some money
ubleEntry.transfer(Money.new(20_00), :from => account_a, :to => account_b, :code => :purchase)
Perform other tasks that should be commited atomically with the transfer of funds...
The lock_accounts call generates a database transaction, which must be the outermost transaction.
See DoubleEntry::Locking for more info.
All transfers and balances are stored in the lines table. As this is a double-entry accounting system, each transfer generates two lines table entries: one for the source account, and one for the destination.
Lines table entries also store the running balance for the account. To retrieve the current balance for an account, we find the most recent lines table entry for it.
See DoubleEntry::Line for more info.
AccountBalance records cache the current balance for each Account, and are used to perform database level locking.
A configuration file should be used to define a set of accounts, optional scopes on the accounts, and permitted transfers between those accounts.
The configuration file should be kept in your application's load path. For example, config/initializers/double_entry.rb
For example, the following specifies two accounts, savings and checking. Each account is scoped by User (where User is an object with an ID), meaning each user can have their own account of each type.
This configuration also specifies that money can be transferred between the two accounts.
ire 'double_entry'
leEntry.configure do |config|
nfig.define_accounts do |accounts|
user_scope = accounts.active_record_scope_identifier(User)
accounts.define(:identifier => :savings, :scope_identifier => user_scope, :positive_only => true)
accounts.define(:identifier => :checking, :scope_identifier => user_scope)
d
nfig.define_transfers do |transfers|
transfers.define(:from => :checking, :to => :savings, :code => :deposit)
transfers.define(:from => :savings, :to => :checking, :code => :withdraw)
d
By default an account's currency is the same as Money.default_currency from the money gem.
You can also specify a currency on a per account basis. Transfers between accounts of different currencies are not allowed.
leEntry.configure do |config|
nfig.define_accounts do |accounts|
accounts.define(:identifier => :savings, :scope_identifier => user_scope, :currency => :aud)
d
Run a concurrency test on the code.
This spawns a bunch of processes, and does random transactions between a set of accounts, then validates that all the numbers add up at the end.
You can also tell out it to flush out the account balances table at regular intervals, to validate that new account balances records get created with the correct balances from the lines table.
./script/jack_hammer -t 20
Cleaning out the database...
Setting up 5 accounts...
Spawning 20 processes...
Flushing balances
Process 1 running 1 transfers...
Process 0 running 1 transfers...
Process 3 running 1 transfers...
Process 2 running 1 transfers...
Process 4 running 1 transfers...
Process 5 running 1 transfers...
Process 6 running 1 transfers...
Process 7 running 1 transfers...
Process 8 running 1 transfers...
Process 9 running 1 transfers...
Process 10 running 1 transfers...
Process 11 running 1 transfers...
Process 12 running 1 transfers...
Process 13 running 1 transfers...
Process 14 running 1 transfers...
Process 16 running 1 transfers...
Process 15 running 1 transfers...
Process 17 running 1 transfers...
Process 19 running 1 transfers...
Process 18 running 1 transfers...
Reconciling...
All the Line records were written, FTW!
All accounts reconciled, FTW!
Done successfully :)
See the Github project issues.
Clone this repo.
clone git@github.com:envato/double_entry.git && cd double_entry
Run the included setup script to install the gem dependencies.
ript/setup.sh
Install MySQL, PostgreSQL and SQLite. We run tests against all three databases.
Create a database in MySQL.
l -u root -e 'create database double_entry_test;'
Create a database in PostgreSQL.
-c 'create database double_entry_test;' -U postgres
Specify how the tests should connect to the database
pec/support/{database.example.yml,database.yml}
spec/support/database.yml
Run the tests
le exec rake