double_booked 0.0.2

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2013 Jay McAliley
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,79 @@
+# DoubleBooked
+
+Flexible double-entry accounting engine for Rails apps using ActiveRecord
+
+## Overview
+
+The core of `double_booked` are Accounts and Transactions.  The concept of an account is probably familiar to most developers-- think of your checking or savings accounts.  A transaction links two accounts together, posting a debit to one, and a credit to another.  The credits and debits must be equal in amount.  That's it!
+
+The system also includes invoices, payments, and the ability to mark any eligible transaction as payment for an invoice, as long as the buyer's account is involved in the transaction.
+
+## Installation
+
+In your Gemfile, put:
+```
+source :rubygems
+gem 'double_booked'
+```
+
+Then on the command line:
+```bash
+bundle install
+rails g double_booked:migrations
+rake db:migrate
+```
+
+## Usage
+
+To use `double_booked`, you'll need to create a model that is a subclass of
+`DetailAccount`. A `DetailAccount` represents an account that is directly
+debited from or credited to, for example a bank account.
+
+Let's say your users have a TokenAccount record, and are able to award each other tokens from their accounts. You'd set up the models as such:
+
+```ruby
+class User < ActiveRecord::Base
+  has_one :token_account, :as => :owner
+end
+
+class TokenAccount < DetailAccount
+  owned_by :user
+end
+```
+
+You may want to set up a special user to issue tokens:
+
+```ruby
+# Setup the token issuer and account (the "bank")
+token_issuer = User.create :email => 'token_issuer@myapp.com', ...
+token_bank = token_issuer.create_token_account
+
+token_bank.current_balance
+# => 0
+
+# Issue 10 tokens to the user Jack
+jack = User.find_by_name "Jack"
+token_bank.transfer(10).to jack.token_account
+
+jack.token_account.current_balance
+# => 10
+
+token_bank.current_balance
+# => -10
+
+# Now have Jack give 2 tokens to Bob
+bob = User.find_by_name("Bob")
+
+bob.token_account.current_balance
+# => 0
+
+jack.token_account.transfer(10).to bob.token_account
+
+jack.token_account.current_balance
+# => 8
+
+bob.token_account.current_balance
+# => 2
+```
+
+At any time, the total tokens in all accounts should sum up to zero.

data/Rakefile

@@ -0,0 +1,35 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'DoubleBooked'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec)
+  task :default => :spec
+rescue LoadError => ls
+  puts "rspec failing to load."
+  exit(1)
+end
+
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+Bundler::GemHelper.install_tasks

data/app/assets/javascripts/double_booked/application.js

@@ -0,0 +1,15 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// the compiled file.
+//
+// WARNING: THE FIRST BLANK LINE MARKS THE END OF WHAT'S TO BE PROCESSED, ANY BLANK LINE SHOULD
+// GO AFTER THE REQUIRES BELOW.
+//
+//= require jquery
+//= require jquery_ujs
+//= require_tree .

data/app/assets/stylesheets/double_booked/application.css

@@ -0,0 +1,13 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the top of the
+ * compiled file, but it's generally better to create a new file per style scope.
+ *
+ *= require_self
+ *= require_tree .
+*/

data/app/controllers/double_booked/application_controller.rb

@@ -0,0 +1,4 @@
+module DoubleBooked
+  class ApplicationController < ActionController::Base
+  end
+end

data/app/helpers/double_booked/application_helper.rb

@@ -0,0 +1,4 @@
+module DoubleBooked
+  module ApplicationHelper
+  end
+end

data/app/models/account.rb

@@ -0,0 +1,44 @@
+class Account < ActiveRecord::Base
+  has_many :balances
+  validate :no_direct_subclass
+
+  class << self
+    attr_accessor :owner_type
+  end
+
+  def self.owned_by(klass)
+    @owner_type = klass.to_s.classify.constantize
+    belongs_to :owner, :polymorphic => true
+    validate :check_owner_type
+  end
+
+  def balance_at(date)
+    balance = balances.where(:evaluated_at => date).first
+    balance ||= Balance.new(:account => self, :evaluated_at => date)
+  end
+
+  def balance_before(date)
+    balances.find :first, :conditions => ["evaluated_at < ?", date],
+                          :order => "evaluated_at DESC"
+  end
+
+  def current_balance
+    balance_at(Time.now)
+  end
+
+private
+  def check_owner_type
+    errors.add(:base, "owner must be an #{self.class.owner_type}") if
+      self.class.owner_type and !(owner.is_a? self.class.owner_type)
+  end
+
+  def no_direct_subclass
+    # FIXME -- refactor Account as a mixin instead of using STI
+    # consider using abstract_class for DetailAccount & SummaryAccount
+    msg = "Record must not be an Account or a direct subclass of it. " +
+          "Subclass the DetailAccount or SummaryAccount class instead."
+    direct_subclass = self.class.superclass == Account || self.class == Account
+    errors.add :base, msg if direct_subclass
+  end
+
+end

data/app/models/balance.rb

@@ -0,0 +1,40 @@
+class Balance < ActiveRecord::Base
+  belongs_to :account
+  validates_presence_of :account, :evaluated_at, :balance
+
+  def balance
+    super or self.balance = calculate_balance
+  end
+
+  def readonly?
+    !new_record?
+  end
+
+private
+
+  def calculate_balance
+    entries.inject(previous_balance) {|balance, entry| balance + entry.amount}
+  end
+
+  def previous
+    account.balance_before(evaluated_at)
+  end
+
+  def previous_balance
+    previous ? previous.balance : 0
+  end
+
+  def entries
+    account.entries.find(:all, :conditions => entry_conditions,
+                               :joins => :transaction)
+  end
+
+  def entry_conditions
+    column = "transactions.created_at"
+    if previous
+     ["#{column} > ? AND #{column} <= ?", previous.evaluated_at, evaluated_at]
+    else
+     ["#{column} <= ?", evaluated_at]
+    end
+  end
+end

data/app/models/blank_transaction.rb

@@ -0,0 +1,17 @@
+class BlankTransaction
+  attr_accessor :amount, :account_from, :account_to
+
+  def initialize(amount, account_from)
+    @amount = amount
+    @account_from = account_from
+  end
+
+  def to(account_to, args = {})
+    defaults = {
+      :account_from => @account_from,
+      :account_to => account_to,
+      :amount => @amount
+    }
+    Transaction.create args.merge(defaults) 
+  end
+end

data/app/models/credit.rb

@@ -0,0 +1,25 @@
+class Credit < Entry
+
+  validate :require_debit
+  validate :sign_convention
+  validate :conservation_principle
+  attr_accessible :amount, :detail_account
+
+  def sign_convention
+    errors.add(:amount, "Credit must be non-negative") unless amount >= 0
+  end
+
+  def debit
+    transaction ? transaction.debit : nil
+  end
+
+  def require_debit
+    errors.add(:base, "Debit must be saved before credit") unless !debit.nil?
+  end
+
+  def conservation_principle
+    errors.add(:base, "Credit and debit amounts must add up to zero") unless
+      (debit.nil? or amount + debit.amount == 0)
+  end
+
+end

data/app/models/debit.rb

@@ -0,0 +1,15 @@
+class Debit < Entry
+
+  validate :sign_convention
+  has_one :credit, :through => :transaction
+  attr_accessible :amount, :detail_account
+
+  def sign_convention
+    errors.add(:base, "Debit must be non-positive") unless amount <= 0
+  end
+
+  def balanced?
+    !credit.nil? and (credit.amount + amount == 0)
+  end
+
+end

data/app/models/detail_account.rb

@@ -0,0 +1,11 @@
+class DetailAccount < Account
+  has_many :entries
+  has_many :transactions, :through => :entries
+  has_many :debits
+  has_many :credits
+
+  def transfer(amount)
+    BlankTransaction.new amount, self
+  end
+
+end

data/app/models/entry.rb

@@ -0,0 +1,13 @@
+class Entry < ActiveRecord::Base
+
+  belongs_to :detail_account
+  belongs_to :transaction
+  has_one :invoice_line, :as => :line_item
+  validates_presence_of :detail_account, :transaction
+  validates_numericality_of :amount
+
+  def readonly?
+    !new_record?
+  end
+
+end

data/app/models/invoice.rb

@@ -0,0 +1,82 @@
+class Invoice < ActiveRecord::Base
+  belongs_to :buyer_account, :class_name => 'DetailAccount'
+  belongs_to :seller_account, :class_name => 'DetailAccount'
+  has_many :invoice_payments, :as => :auxilliary_model
+  has_many :invoice_lines
+  has_many :line_items, :through => :invoice_lines
+
+  validates_presence_of :buyer_account, :seller_account
+
+  def self.build(entries)
+    accounts = check_accounts entries
+    invoice = Invoice.create! :buyer_account => accounts[:buyer],
+                              :seller_account => accounts[:seller]
+    entries.each do |entry|
+      line = invoice.invoice_lines.create :line_item => entry
+      line.save!
+    end
+    invoice.close
+    invoice
+  end
+
+  def close
+    update_attribute(:closed, true)
+  end
+
+  def open?
+    !closed?
+  end
+
+  def paid?
+    amount_owed <= 0
+  end
+
+  def amount_billed
+    line_items.inject(0) {|amount, item| amount + item.amount}
+  end
+
+  def amount_paid
+    invoice_payments(true).inject(0) {|amount, payment| amount + payment.amount}
+  end
+
+  def amount_owed
+    amount_billed - amount_paid
+  end
+
+  def pay_in_full(options = {})
+    pay(amount_owed, options)
+  end
+
+  def pay(amount, options = {})
+    options.merge!({:description => "Payment for Invoice ##{formatted_id}",
+                    :auxilliary_model => self,
+                    :account_from => buyer_account,
+                    :account_to => seller_account,
+                    :amount => amount})
+    InvoicePayment.create! options
+  end
+
+  def formatted_id
+    "%08i" % id
+  end
+
+private
+  def self.check_accounts(entries)
+    accounts, last_accounts = {}, {}
+    entries.each do |entry|
+      accounts = get_accounts entry
+      raise ArgumentError, "All entries must involve the same accounts" unless
+        last_accounts.empty? || accounts == last_accounts
+      last_accounts = accounts
+    end
+    accounts
+  end
+
+  def self.get_accounts(entry)
+    buyer = entry.detail_account
+    seller = entry.transaction.debited_account
+    seller = entry.transaction.credited_account if seller == buyer
+    {:seller => seller, :buyer => buyer}
+  end
+
+end

data/app/models/invoice_line.rb

@@ -0,0 +1,26 @@
+class InvoiceLine < ActiveRecord::Base
+  belongs_to :invoice
+  belongs_to :line_item, :class_name => 'Entry'
+  validates_presence_of :invoice, :line_item
+  validate :open_invoice
+  validate :correct_account
+  validates_uniqueness_of :line_item_id
+
+  def paid?
+    invoice.paid?
+  end
+
+private
+
+  def open_invoice
+    return true unless invoice # another validation will catch
+    errors.add(:invoice, "is closed") unless invoice(true).open?
+  end
+
+  def correct_account
+    return true unless invoice && line_item # another validation will catch
+    errors.add(:base, "Line item is applied to the wrong account") unless
+      line_item.detail_account == invoice.buyer_account
+  end
+
+end

data/app/models/invoice_payment.rb

@@ -0,0 +1,15 @@
+class InvoicePayment < Transaction
+  validate :valid_invoice
+
+  alias :invoice :auxilliary_model
+
+  def pays_in_full?
+    amount >= invoice.amount_billed
+  end
+
+private
+  def valid_invoice
+    invoice.is_a? Invoice
+  end
+
+end

data/app/models/statement.rb

@@ -0,0 +1,30 @@
+class Statement
+  attr_accessor :account, :period_start, :period_end
+
+  def initialize(account, period_start, period_end)
+    @account = account
+    @period_start = period_start
+    @period_end = period_end
+  end
+
+  def entries
+    account.entries.where(entry_conditions).
+                    joins(:transaction).
+                    order("created_at ASC")
+  end
+
+  def start_balance
+    account.balance_at(period_start).balance
+  end
+
+  def end_balance
+    account.balance_at(period_end).balance
+  end
+
+private
+  def entry_conditions
+    column = "transactions.created_at"
+    ["#{column} > ? AND #{column} <= ?", period_start, period_end] 
+  end
+
+end

data/app/models/summary_account.rb

@@ -0,0 +1,11 @@
+class SummaryAccount < Account
+  has_and_belongs_to_many :accounts, :join_table => :account_joins
+  has_many :entries, :through => :accounts
+  validate :no_recursion
+
+private
+  def no_recursion
+    errors.add(:base, "Summary account cannot summarize itself") if
+      accounts.include? self
+  end
+end

data/app/models/transaction.rb

@@ -0,0 +1,64 @@
+class Transaction < ActiveRecord::Base
+  has_one :debit
+  has_one :credit
+  has_one :credited_account, :through => :credit, :source => :detail_account
+  has_one :debited_account, :through => :debit, :source => :detail_account
+  belongs_to :auxilliary_model, :polymorphic => true
+
+  validates_presence_of :description, :account_from, :account_to, :amount
+  validate :sufficient_funds, :if => :require_funds?
+
+  attr_accessor :account_from, :account_to, :amount
+
+  def self.belongs_to_auxilliary_model(model)
+    klass = model.to_s.classify
+    belongs_to klass.underscore.to_sym, :foreign_key => :auxilliary_model_id
+  end
+
+  def self.required_auxilliary_model(model)
+    belongs_to_auxilliary_model(model)
+    validates_presence_of model.to_s.classify.underscore.to_sym
+  end
+
+  def completed?
+    !debit.nil? and !credit.nil?
+  end
+
+  def amount
+    completed? ? credit.amount : (@amount or 0)
+  end
+
+  def account_from
+    completed? ? debit.detail_account : @account_from
+  end
+
+  def account_to
+    completed? ? credit.detail_account : @account_to
+  end
+
+  def transaction_date
+    super or created_at
+  end
+
+  def readonly?
+    !new_record?
+  end
+
+private
+  def create
+    # Saving of debit, credit, and transaction should be done in one
+    # atomic commit (the following block is an *SQL* transaction, not related
+    # to our Transaction model)
+    transaction do
+      super
+      create_debit :amount => -amount, :detail_account => account_from
+      create_credit :amount => amount, :detail_account => account_to
+    end
+    completed?
+  end
+
+  def sufficient_funds
+    sufficient = account_from && account_from.current_balance.balance >= amount
+    errors.add :base, "Insufficient funds in debit account" unless sufficient
+  end
+end

data/app/views/layouts/double_booked/application.html.erb

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>DoubleBooked</title>
+  <%= stylesheet_link_tag    "double_booked/application", :media => "all" %>
+  <%= javascript_include_tag "double_booked/application" %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/config/routes.rb

@@ -0,0 +1,2 @@
+# DoubleBooked::Engine.routes.draw do
+# end

data/lib/double_booked/engine.rb

@@ -0,0 +1,5 @@
+module DoubleBooked
+  class Engine < ::Rails::Engine
+    
+  end
+end

data/lib/double_booked/version.rb

@@ -0,0 +1,3 @@
+module DoubleBooked
+  VERSION = "0.0.2"
+end

data/lib/double_booked.rb

@@ -0,0 +1,4 @@
+require "double_booked/engine"
+
+module DoubleBooked
+end

data/lib/generators/double_booked/migrations/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Explain the generator
+
+Example:
+    ./script/generate double_booked Thing
+
+    This will create:
+        what/will/it/create

data/lib/generators/double_booked/migrations/migrations_generator.rb

@@ -0,0 +1,22 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+module DoubleBooked
+  class MigrationsGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+
+    # Implement the required interface for Rails::Generators::Migration.
+    # taken from http://github.com/rails/rails/blob/master/activerecord/lib/generators/active_record.rb
+    def self.next_migration_number(dirname)
+      Time.now.utc.strftime("%Y%m%d%H%M%S")
+    end
+  
+    source_root File.expand_path("../templates", __FILE__)
+  
+    desc "Creates migrations."
+    
+    def create_migrations
+      migration_template "double_booked.rb.erb", "db/migrate/create_double_booked.rb"
+    end
+  end
+end

data/lib/generators/double_booked/migrations/templates/double_booked.rb.erb

@@ -0,0 +1,70 @@
+class CreateDoubleBookedModels < ActiveRecord::Migration
+  def self.up
+
+    create_table :accounts do |t|
+      t.string :type
+      t.string :name
+      t.references :owner, :polymorphic => true
+    end
+    add_index :accounts, [:owner_id, :owner_type]
+
+    create_table :account_joins, :id => false do |t|
+      t.integer :detail_account_id, :references => :accounts
+      t.integer :summary_account_id, :references => :accounts
+    end
+    add_index :account_joins, :detail_account_id
+    add_index :account_joins, :summary_account_id
+
+    create_table :balances do |t|
+      t.integer :account_id
+      t.datetime :evaluated_at
+      t.decimal :balance, :precision => 14, :scale => 2
+    end
+    add_index :balances, :account_id
+
+    create_table :transactions do |t|
+      t.string :type
+      t.string :description
+      t.datetime :transaction_date
+      t.references :auxilliary_model, :polymorphic => true
+      t.boolean :require_funds
+      t.timestamps
+    end
+    add_index :transactions, :transaction_date
+    add_index :transactions, [:auxilliary_model_id, :auxilliary_model_type], :name => :index_transactions_on_auxilliary_model
+
+    create_table :entries do |t|
+      t.string :type
+      t.integer :detail_account_id, :references => :accounts
+      t.references :transaction
+      t.decimal :amount, :precision => 14, :scale => 2
+    end
+    add_index :entries, :detail_account_id
+    add_index :entries, :transaction_id
+
+    create_table :invoices do |t|
+      t.integer :buyer_account_id, :references => :accounts
+      t.integer :seller_account_id, :references => :accounts
+      t.boolean :closed, :default => false
+    end
+    add_index :invoices, :buyer_account_id
+    add_index :invoices, :seller_account_id
+
+    create_table :invoice_lines do |t|
+      t.references :invoice
+      t.integer :line_item_id, :references => :entries
+    end
+    add_index :invoice_lines, :invoice_id
+    add_index :invoice_lines, :line_item_id
+  end
+
+  def self.down
+    drop_table :invoice_lines
+    drop_table :invoices
+    drop_table :entries
+    drop_table :transactions
+    drop_table :balances
+    drop_table :account_joins
+    drop_table :accounts
+  end
+end

data/lib/tasks/double_booked_tasks.rake

@@ -0,0 +1,8 @@
+namespace :double_booked do
+  desc "Cache balances for all DetailAccounts"
+  task :update_balances => :environment do
+   DetailAccount.all.each do |a|
+     a.balance_at(Date.today).save
+   end
+  end
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: double_booked
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Jay McAliley
+- John McAliley
+- Jim Van Fleet
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: &70271980125640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70271980125640
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: &70271980125020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70271980125020
+description: Double-entry accounting issues credits and debits, calculates balances,
+  allows for summary accounts and more.
+email:
+- jay@logicleague.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- app/assets/javascripts/double_booked/application.js
+- app/assets/stylesheets/double_booked/application.css
+- app/controllers/double_booked/application_controller.rb
+- app/helpers/double_booked/application_helper.rb
+- app/models/account.rb
+- app/models/balance.rb
+- app/models/blank_transaction.rb
+- app/models/credit.rb
+- app/models/debit.rb
+- app/models/detail_account.rb
+- app/models/entry.rb
+- app/models/invoice.rb
+- app/models/invoice_line.rb
+- app/models/invoice_payment.rb
+- app/models/statement.rb
+- app/models/summary_account.rb
+- app/models/transaction.rb
+- app/views/layouts/double_booked/application.html.erb
+- config/routes.rb
+- lib/double_booked/engine.rb
+- lib/double_booked/version.rb
+- lib/double_booked.rb
+- lib/generators/double_booked/migrations/migrations_generator.rb
+- lib/generators/double_booked/migrations/templates/double_booked.rb.erb
+- lib/generators/double_booked/migrations/USAGE
+- lib/tasks/double_booked_tasks.rake
+- MIT-LICENSE
+- Rakefile
+- README.md
+homepage: https://github.com/logicleague/double_booked
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Flexible double-entry accounting engine for Rails apps
+test_files: []