bean_machine 0.0.0.pre1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Josh Robinson
+
+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.markdown

@@ -0,0 +1,115 @@
+## Bean Machine
+
+Accounting sucks. Well if you are trying to do it right it does. Bean machine gives you the power of an immutable double entry accounting system through the use of a simple transfer method. The idea is to make accounting easy by breaking it into easy to follow steps. Transfer this much from this account to that account.
+
+### Current Status
+
+Bean Machine is very rough right now. The basics work but you will need to do some manual work setting up the db and such. It will change and it will break. But that just means it is an active project and will make rapid progress. Until it gets a couple good point releases you probably shouldn't use it in production. I probably will be using it in production to help figure out the best way to take it but you shouldn't. Just don't.
+
+### Installation
+
+Bean Machine is hosted on GemCutter ... I mean RubyGems, So just install like a normal gem.
+
+    sudo gem install bean_machine --pre
+    
+### Schema
+
+Until nice generators are done you can manually make a migration with the following structure. It will change frequently while the kinks are getting worked out.
+
+    create_table :bean_transfers, :force => true do |t|
+      t.references :user
+      t.references :accountable, :polymorphic => true
+
+      t.string :state
+      t.integer :amount
+      t.string :debit
+      t.string :credit
+      t.string :currency, :null => false, :default => 'USD'
+      t.string :event, :null => false, :default => 'transfer'
+      t.boolean :success
+      t.string :reference
+      t.string :message
+      t.text :params
+      t.boolean :test
+      t.boolean :affect_balance
+    end
+    
+### Overview
+
+Bean Machine is based on the double entry accounting system. Every transfer is moving money from one account to another account. Eventually I will give a nice tutorial on basic accounting principles but it will have to wait.
+    
+### Usage
+
+An example is worth a thousand words so lets do a quick one.
+
+    class User < ActiveRecord::Base
+      # tell it who has the balances
+      include Bean::User
+      
+      has_many :invoices
+    end
+      
+    class Invoice < ActiveRecord::Base
+      # this adds the transfer method
+      include Bean::Machine
+      
+      belongs_to :user
+      
+      # just transfer an amount from a credit account to a debit account.
+      # it doesn't really matter what account you credit and what you
+      # debit as long as you keep it consistant.
+      def pay(amount)
+        transfer amount.to_money, :credit => :payments, :debit => :invoice
+      end
+    end
+    
+    # just make a user
+    @user = User.create
+    
+    # give them a couple invoices
+    @invoice = @user.invoices.create
+    
+    # pay some amount on the invoice
+    @invoice.pay(10)
+    
+    # lookup the balance for a given account
+    @user.balance(:invoice) #=> Money object with value of 1000 cents
+    @user.balance(:invoice).to_s #=> '10.00'
+
+    # pay more on the invoice
+    @invoice.pay(20)
+    
+    # and the balance increases
+    @user.balance(:invoice).to_s #=> '30.00' 
+    @user.balance(:payments).to_s #=> '30.00' 
+
+    
+This example has not been tested yet but is here to give you a basic idea of how it works.
+    
+    
+### ToDo
+
+- Lots and lots
+- Mixins for common accounting transactions (payment, invoice, etc)
+- Integrate ActiveMerchant
+- Pluggable transfer store (noSQL)
+- ORM independent
+
+## Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but
+   bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+## Sponsored By
+
+This gem is sponsored by [Teliax][]. [Teliax][] makes business class Voice, [Centrex][](Including Hosted: IVRs, Ring Groups, Extensions and Day Night Mode) and Data services accessible to anyone. You don't have to be a fortune 500 to sound big!
+
+## Copyright
+
+Copyright (c) 2010 Josh Robinson . See LICENSE for details.

data/Rakefile

@@ -0,0 +1,64 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "bean_machine"
+    gem.summary = %Q{Kick accounting in the mean bean machine!}
+    gem.description = %Q{Accounting sucks. Well if you are trying to do it right it does. Bean machine gives you the power of an immutable double entry accounting system through the use of a simple transfer method. The idea is to make accounting easy by breaking it into easy to follow steps. Transfer this much from this account to that account.}
+    gem.email = "hexorx@gmail.com"
+    gem.homepage = "http://github.com/hexorx/bean_machine"
+    gem.authors = ["hexorx"]
+    
+    gem.add_development_dependency "rspec"
+    gem.add_development_dependency "yard"
+    gem.add_development_dependency "cucumber"
+    gem.add_development_dependency "machinist"
+    gem.add_development_dependency "faker"
+    
+    gem.add_dependency "money"
+    gem.add_dependency "activerecord"
+    gem.add_dependency "activemerchant"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+begin
+  require 'cucumber/rake/task'
+  Cucumber::Rake::Task.new(:features)
+
+  task :features => :check_dependencies
+rescue LoadError
+  task :features do
+    abort "Cucumber is not available. In order to run features, you must: sudo gem install cucumber"
+  end
+end
+
+task :default => :spec
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new
+rescue LoadError
+  task :yardoc do
+    abort "YARD is not available. In order to run yardoc, you must: sudo gem install yard"
+  end
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.0.pre1

data/credit_card.dot

@@ -0,0 +1,9 @@
+digraph CreditCard {  
+  init [shape = square];
+  init -> {authorized declined};
+
+  authorized -> {captured declined};
+  captured -> {refunded};
+
+  {rank=same; authorized declined }
+}

data/dsl.rb

@@ -0,0 +1,44 @@
+class Payment
+  cattr_accessor :gateway
+  
+  def charge
+    authorize!(amount).capture!
+  end
+
+  def authorize
+    transfer :from => :payments, :to => :accounts_recievable
+  end
+
+  def capture
+    transfer :accounts_recievable => :cash do
+      response = gateway.capture(amount, authorization, options)
+      record_response(trans, response)
+    end
+  end
+  
+  def expire
+    transfer :accounts_recievable => :payment
+  end
+  
+  def refund do
+    transfer :cash => :payments
+  end
+
+protected
+
+  def record_response(trans,response)
+    begin
+      trans.success   = response.success?
+      trans.reference = response.authorization
+      trans.message   = response.message
+      trans.params    = response.params
+      trans.test      = response.test?
+    rescue ActiveMerchant::ActiveMerchantError => e
+      trans.success   = false
+      trans.reference = nil
+      trans.message   = e.message
+      trans.params    = {}
+      trans.test      = gateway.test?
+    end
+  end  
+end

data/features/billing.feature

@@ -0,0 +1,9 @@
+Feature: something something
+  In order to something something
+  A user something something
+  something something something
+
+  Scenario: something something
+    Given inspiration
+    When I create a sweet new gem
+    Then everyone should see how awesome I am

data/features/support/env.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'bean_machine'
+
+require 'spec/expectations'

data/lib/bean/machine.rb

@@ -0,0 +1,30 @@
+module Bean
+  module Machine
+    def self.included(base)
+      base.class_eval do
+        include InstanceMethods
+        has_many :transfers, :as => :accountable, :class_name => 'Bean::Transfer', :order => 'id DESC'
+      end
+    end
+    
+    module InstanceMethods
+      def bean
+        transfers.stateful.first
+      end
+      
+      def transfer(*args,&block)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        amount = args.shift.to_money
+        
+        options.reverse_merge!({
+          :amount => amount
+        })
+        
+        xfer = self.transfers.build(options)
+        xfer.instance_eval(&block)
+        xfer.save
+        xfer
+      end
+    end      
+  end
+end

data/lib/bean/payment.rb

@@ -0,0 +1,66 @@
+module Bean
+  class Payment < ActiveRecord::Base
+    include Bean::Machine
+    
+    cattr_accessor :gateway
+    
+    composed_of :amount, :class_name => 'Money', :mapping => [%w(amount cents), %w(currency currency)]
+    
+    attr_accessor :credit_card
+    
+    def authorize(amount=amount, options = {})
+      return false if bean
+      card = options.delete(:on) || (credit_card rescue nil)
+      return false unless card
+      
+      process(amount,{
+        :event => 'authorize',
+        :state => 'authorized',
+        :credit => 'payment',
+        :debit =>'pending'
+      }) do |gw|
+        gw.authorize(amount, card, options)
+      end
+    end
+
+    def capture(options = {})
+      return false unless bean.state == 'authorized'
+      
+      process(amount,{
+        :event => 'capture',
+        :state => 'captured',
+        :credit => 'pending',
+        :debit =>'cash'
+      }) do |gw|
+        gw.capture(amount, bean.reference, options)
+      end
+    end
+
+    private
+
+    def process(*args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      amount = args.shift.to_money
+      
+      transfer(amount, options) do
+        begin
+          response = yield Payment.gateway
+
+          self.success   = response.success?
+          self.reference = response.authorization
+          self.message   = response.message
+          self.params    = response.params
+          self.test      = response.test
+        rescue ActiveMerchant::ActiveMerchantError => e
+          self.state = 'declined'
+          self.success   = false
+          self.reference = nil
+          self.message   = e.message
+          self.params    = {}
+          self.test      = gateway.test?
+        end
+      end
+
+    end
+  end
+end

data/lib/bean/transfer.rb

@@ -0,0 +1,41 @@
+module Bean
+  Accounts = [:asset, :liability, :expense, :income, :payment, :currency]
+  
+  class Transfer < ActiveRecord::Base
+    set_table_name :bean_transfers
+    belongs_to :accountable, :polymorphic => true
+    
+    # before_validation :normalize_accounts
+    
+    composed_of :amount, :class_name => 'Money', :mapping => [%w(amount cents), %w(currency currency)]
+    
+    named_scope :debiting, lambda {|account|
+      {:conditions => {:debit => account.to_s.downcase}}
+    }
+
+    named_scope :crediting, lambda {|account|
+      {:conditions => {:credit => account.to_s.downcase}}
+    }
+
+    named_scope :in_currency, lambda {|currency|
+      {:conditions => {:currency => currency.to_s.upcase}}
+    }
+    
+    named_scope :stateful, :conditions => 'state is not NULL'
+    
+    def before_validation_with_normalizing
+      self[:debit].downcase!
+      self[:credit].downcase!
+      self[:currency].upcase!
+      before_validation_without_normalizing
+    end
+    alias_method_chain :before_validation, :normalizing
+              
+  protected
+  
+    def validate
+      errors.add(:amount, 'must be positive') unless self.amount > Money.new(0,self.currency)
+    end
+    
+  end
+end

data/lib/bean/user.rb

@@ -0,0 +1,25 @@
+module Bean
+  module User
+    def self.included(base)
+      base.class_eval do
+        include InstanceMethods
+        has_many :transfers, :class_name => 'Bean::Transfer'
+      end
+      
+      Bean::Transfer.class_eval do
+        belongs_to :user, :class_name => base.name
+      end
+    end
+    
+    module InstanceMethods
+      def balance(account='asset',currency='USD')
+        debits = transfers.debiting(account).in_currency(currency).sum(:amount)
+        credits = transfers.crediting(account).in_currency(currency).sum(:amount)
+        Money.new(debits - credits, currency.to_s)
+      end
+      
+      def credit_card
+      end
+    end
+  end
+end

data/lib/bean_machine.rb

@@ -0,0 +1,8 @@
+$LOAD_PATH << File.expand_path(File.dirname(__FILE__))
+
+require 'money'
+
+require 'bean/machine'
+require 'bean/user'
+require 'bean/transfer'
+

data/spec/blueprints.rb

@@ -0,0 +1,35 @@
+require 'machinist/active_record'
+require 'machinist/object'
+require 'sham'
+require 'faker'
+
+class User < ActiveRecord::Base
+  include Bean::User
+end
+
+User.blueprint do
+end
+
+Bean::Payment.blueprint do
+  amount {}
+  credit_card { ActiveMerchant::Billing::CreditCard.make }
+end
+
+Bean::Transfer.blueprint do
+  amount {Money.new(rand(100) + 1)}
+  debit {'asset'}
+  credit {'expense'}
+end
+
+ActiveMerchant::Billing::CreditCard.blueprint do
+  number {'1'}
+  month {'8'}
+  year {'2009'}
+  first_name {'Tobias'}
+  last_name {'Luetke'}
+  verification_value {'123'}
+end
+
+ActiveMerchant::Billing::CreditCard.blueprint(:bad) do
+  number {'2'}
+end

data/spec/debug.log

@@ -0,0 +1,87 @@
+# Logfile created on Tue Mar 16 13:14:32 -0700 2010 by /
+  SQL (0.3ms)   select sqlite_version(*)
+  SQL (0.2ms)    SELECT name
+ FROM sqlite_master
+ WHERE type = 'table' AND NOT name = 'sqlite_sequence'
+
+  SQL (0.5ms)   CREATE TABLE "users" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL) 
+  SQL (0.2ms)    SELECT name
+ FROM sqlite_master
+ WHERE type = 'table' AND NOT name = 'sqlite_sequence'
+
+  SQL (0.3ms)   CREATE TABLE "payments" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "amount" integer, "currency" varchar(255) DEFAULT 'USD' NOT NULL, "reference" varchar(255)) 
+  SQL (0.3ms)    SELECT name
+ FROM sqlite_master
+ WHERE type = 'table' AND NOT name = 'sqlite_sequence'
+
+  SQL (6.8ms)   CREATE TABLE "bean_transfers" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "user_id" integer, "accountable_id" integer, "accountable_type" varchar(255), "state" varchar(255), "amount" integer, "debit" varchar(255), "credit" varchar(255), "currency" varchar(255) DEFAULT 'USD' NOT NULL, "event" varchar(255) DEFAULT 'transfer' NOT NULL, "success" boolean, "reference" varchar(255), "message" varchar(255), "params" text, "test" boolean, "affect_balance" boolean) 
+  Bean::Transfer Load (0.2ms)   SELECT * FROM "bean_transfers" 
+  Bean::Transfer Create (0.2ms)   INSERT INTO "bean_transfers" ("reference", "debit", "amount", "credit", "user_id", "event", "success", "affect_balance", "currency", "params", "accountable_type", "message", "test", "accountable_id", "state") VALUES(NULL, 'liability', 41, 'asset', NULL, 'transfer', NULL, NULL, 'MONKEY', NULL, NULL, NULL, NULL, NULL, NULL)
+  Bean::Transfer Load (0.7ms)   SELECT * FROM "bean_transfers" WHERE ("bean_transfers"."id" = 1) 
+  Bean::Transfer Create (0.2ms)   INSERT INTO "bean_transfers" ("reference", "debit", "amount", "credit", "user_id", "event", "success", "affect_balance", "currency", "params", "accountable_type", "message", "test", "accountable_id", "state") VALUES(NULL, 'expense', 31, 'asset', NULL, 'transfer', NULL, NULL, 'USD', NULL, NULL, NULL, NULL, NULL, NULL)
+  Bean::Transfer Load (0.4ms)   SELECT * FROM "bean_transfers" WHERE ("bean_transfers"."id" = 2) 
+  Bean::Transfer Create (0.2ms)   INSERT INTO "bean_transfers" ("reference", "debit", "amount", "credit", "user_id", "event", "success", "affect_balance", "currency", "params", "accountable_type", "message", "test", "accountable_id", "state") VALUES(NULL, 'asset', 12, 'payment', NULL, 'transfer', NULL, NULL, 'USD', NULL, NULL, NULL, NULL, NULL, NULL)
+  Bean::Transfer Load (0.4ms)   SELECT * FROM "bean_transfers" WHERE ("bean_transfers"."id" = 3) 
+  Bean::Transfer Create (0.1ms)   INSERT INTO "bean_transfers" ("reference", "debit", "amount", "credit", "user_id", "event", "success", "affect_balance", "currency", "params", "accountable_type", "message", "test", "accountable_id", "state") VALUES(NULL, 'expense', 19, 'payment', NULL, 'transfer', NULL, NULL, 'USD', NULL, NULL, NULL, NULL, NULL, NULL)
+  Bean::Transfer Load (0.3ms)   SELECT * FROM "bean_transfers" WHERE ("bean_transfers"."id" = 4) 
+  Bean::Transfer Create (0.1ms)   INSERT INTO "bean_transfers" ("reference", "debit", "amount", "credit", "user_id", "event", "success", "affect_balance", "currency", "params", "accountable_type", "message", "test", "accountable_id", "state") VALUES(NULL, 'currency', 60, 'payment', NULL, 'transfer', NULL, NULL, 'USD', NULL, NULL, NULL, NULL, NULL, NULL)
+  Bean::Transfer Load (0.3ms)   SELECT * FROM "bean_transfers" WHERE ("bean_transfers"."id" = 5) 
+  Bean::Transfer Create (0.1ms)   INSERT INTO "bean_transfers" ("reference", "debit", "amount", "credit", "user_id", "event", "success", "affect_balance", "currency", "params", "accountable_type", "message", "test", "accountable_id", "state") VALUES(NULL, 'income', 98, 'currency', NULL, 'transfer', NULL, NULL, 'MONKEY', NULL, NULL, NULL, NULL, NULL, NULL)
+  Bean::Transfer Load (0.3ms)   SELECT * FROM "bean_transfers" WHERE ("bean_transfers"."id" = 6) 
+  SQL (0.1ms)   SELECT count(*) AS count_all FROM "bean_transfers" WHERE ("bean_transfers"."debit" = 'asset') 
+  SQL (0.2ms)   SELECT count(*) AS count_all FROM "bean_transfers" WHERE ("bean_transfers"."debit" = 'liability') 
+  SQL (0.1ms)   SELECT count(*) AS count_all FROM "bean_transfers" WHERE ("bean_transfers"."debit" = 'expense') 
+  SQL (0.1ms)   SELECT count(*) AS count_all FROM "bean_transfers" WHERE ("bean_transfers"."debit" = 'income') 
+  SQL (0.1ms)   SELECT count(*) AS count_all FROM "bean_transfers" WHERE ("bean_transfers"."debit" = 'currency') 
+  SQL (0.2ms)   SELECT count(*) AS count_all FROM "bean_transfers" WHERE ("bean_transfers"."credit" = 'asset') 
+  SQL (0.2ms)   SELECT count(*) AS count_all FROM "bean_transfers" WHERE ("bean_transfers"."credit" = 'payment') 
+  SQL (0.2ms)   SELECT count(*) AS count_all FROM "bean_transfers" WHERE ("bean_transfers"."credit" = 'currency') 
+  SQL (0.2ms)   SELECT count(*) AS count_all FROM "bean_transfers" WHERE ("bean_transfers"."currency" = 'USD') 
+  SQL (0.2ms)   SELECT count(*) AS count_all FROM "bean_transfers" WHERE ("bean_transfers"."currency" = 'MONKEY') 
+  SQL (0.2ms)   select sqlite_version(*)
+  SQL (0.1ms)    SELECT name
+ FROM sqlite_master
+ WHERE type = 'table' AND NOT name = 'sqlite_sequence'
+
+  SQL (0.4ms)   CREATE TABLE "users" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL) 
+  SQL (0.2ms)    SELECT name
+ FROM sqlite_master
+ WHERE type = 'table' AND NOT name = 'sqlite_sequence'
+
+  SQL (0.2ms)   CREATE TABLE "payments" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "amount" integer, "currency" varchar(255) DEFAULT 'USD' NOT NULL, "reference" varchar(255)) 
+  SQL (0.2ms)    SELECT name
+ FROM sqlite_master
+ WHERE type = 'table' AND NOT name = 'sqlite_sequence'
+
+  SQL (0.3ms)   CREATE TABLE "bean_transfers" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "user_id" integer, "accountable_id" integer, "accountable_type" varchar(255), "state" varchar(255), "amount" integer, "debit" varchar(255), "credit" varchar(255), "currency" varchar(255) DEFAULT 'USD' NOT NULL, "event" varchar(255) DEFAULT 'transfer' NOT NULL, "success" boolean, "reference" varchar(255), "message" varchar(255), "params" text, "test" boolean, "affect_balance" boolean) 
+  User Create (0.2ms)   INSERT INTO users VALUES(NULL)
+  User Load (0.4ms)   SELECT * FROM "users" WHERE ("users"."id" = 1) 
+  Bean::Transfer Load (0.1ms)   SELECT * FROM "bean_transfers" 
+  Bean::Transfer Create (0.2ms)   INSERT INTO "bean_transfers" ("reference", "debit", "amount", "credit", "user_id", "event", "success", "affect_balance", "currency", "params", "accountable_type", "message", "test", "accountable_id", "state") VALUES(NULL, 'liability', 100, 'asset', 1, 'transfer', NULL, NULL, 'MONKEY', NULL, NULL, NULL, NULL, NULL, NULL)
+  Bean::Transfer Load (0.4ms)   SELECT * FROM "bean_transfers" WHERE ("bean_transfers"."id" = 1) 
+  Bean::Transfer Create (0.2ms)   INSERT INTO "bean_transfers" ("reference", "debit", "amount", "credit", "user_id", "event", "success", "affect_balance", "currency", "params", "accountable_type", "message", "test", "accountable_id", "state") VALUES(NULL, 'expense', 200, 'asset', 1, 'transfer', NULL, NULL, 'USD', NULL, NULL, NULL, NULL, NULL, NULL)
+  Bean::Transfer Load (0.3ms)   SELECT * FROM "bean_transfers" WHERE ("bean_transfers"."id" = 2) 
+  Bean::Transfer Create (0.1ms)   INSERT INTO "bean_transfers" ("reference", "debit", "amount", "credit", "user_id", "event", "success", "affect_balance", "currency", "params", "accountable_type", "message", "test", "accountable_id", "state") VALUES(NULL, 'asset', 300, 'payment', 1, 'transfer', NULL, NULL, 'USD', NULL, NULL, NULL, NULL, NULL, NULL)
+  Bean::Transfer Load (0.3ms)   SELECT * FROM "bean_transfers" WHERE ("bean_transfers"."id" = 3) 
+  Bean::Transfer Create (0.1ms)   INSERT INTO "bean_transfers" ("reference", "debit", "amount", "credit", "user_id", "event", "success", "affect_balance", "currency", "params", "accountable_type", "message", "test", "accountable_id", "state") VALUES(NULL, 'expense', 400, 'payment', 1, 'transfer', NULL, NULL, 'USD', NULL, NULL, NULL, NULL, NULL, NULL)
+  Bean::Transfer Load (0.3ms)   SELECT * FROM "bean_transfers" WHERE ("bean_transfers"."id" = 4) 
+  Bean::Transfer Create (0.1ms)   INSERT INTO "bean_transfers" ("reference", "debit", "amount", "credit", "user_id", "event", "success", "affect_balance", "currency", "params", "accountable_type", "message", "test", "accountable_id", "state") VALUES(NULL, 'currency', 500, 'payment', 1, 'transfer', NULL, NULL, 'USD', NULL, NULL, NULL, NULL, NULL, NULL)
+  Bean::Transfer Load (0.3ms)   SELECT * FROM "bean_transfers" WHERE ("bean_transfers"."id" = 5) 
+  Bean::Transfer Create (0.1ms)   INSERT INTO "bean_transfers" ("reference", "debit", "amount", "credit", "user_id", "event", "success", "affect_balance", "currency", "params", "accountable_type", "message", "test", "accountable_id", "state") VALUES(NULL, 'income', 600, 'currency', 1, 'transfer', NULL, NULL, 'MONKEY', NULL, NULL, NULL, NULL, NULL, NULL)
+  Bean::Transfer Load (0.3ms)   SELECT * FROM "bean_transfers" WHERE ("bean_transfers"."id" = 6) 
+  SQL (0.2ms)   SELECT sum("bean_transfers".amount) AS sum_amount FROM "bean_transfers" WHERE (((("bean_transfers"."debit" = 'asset' AND "bean_transfers"."currency" = 'USD')) AND ("bean_transfers".user_id = 1)) AND ("bean_transfers".user_id = 1)) 
+  SQL (0.2ms)   SELECT sum("bean_transfers".amount) AS sum_amount FROM "bean_transfers" WHERE (((("bean_transfers"."credit" = 'asset' AND "bean_transfers"."currency" = 'USD')) AND ("bean_transfers".user_id = 1)) AND ("bean_transfers".user_id = 1)) 
+  SQL (0.4ms)   SELECT sum("bean_transfers".amount) AS sum_amount FROM "bean_transfers" WHERE (((("bean_transfers"."debit" = 'asset' AND "bean_transfers"."currency" = 'USD')) AND ("bean_transfers".user_id = 1)) AND ("bean_transfers".user_id = 1)) 
+  SQL (0.2ms)   SELECT sum("bean_transfers".amount) AS sum_amount FROM "bean_transfers" WHERE (((("bean_transfers"."credit" = 'asset' AND "bean_transfers"."currency" = 'USD')) AND ("bean_transfers".user_id = 1)) AND ("bean_transfers".user_id = 1)) 
+  SQL (0.3ms)   SELECT sum("bean_transfers".amount) AS sum_amount FROM "bean_transfers" WHERE (((("bean_transfers"."debit" = 'liability' AND "bean_transfers"."currency" = 'MONKEY')) AND ("bean_transfers".user_id = 1)) AND ("bean_transfers".user_id = 1)) 
+  SQL (0.2ms)   SELECT sum("bean_transfers".amount) AS sum_amount FROM "bean_transfers" WHERE (((("bean_transfers"."credit" = 'liability' AND "bean_transfers"."currency" = 'MONKEY')) AND ("bean_transfers".user_id = 1)) AND ("bean_transfers".user_id = 1)) 
+  SQL (0.2ms)   SELECT sum("bean_transfers".amount) AS sum_amount FROM "bean_transfers" WHERE (((("bean_transfers"."debit" = 'income' AND "bean_transfers"."currency" = 'MONKEY')) AND ("bean_transfers".user_id = 1)) AND ("bean_transfers".user_id = 1)) 
+  SQL (0.2ms)   SELECT sum("bean_transfers".amount) AS sum_amount FROM "bean_transfers" WHERE (((("bean_transfers"."credit" = 'income' AND "bean_transfers"."currency" = 'MONKEY')) AND ("bean_transfers".user_id = 1)) AND ("bean_transfers".user_id = 1)) 
+  SQL (0.2ms)   SELECT sum("bean_transfers".amount) AS sum_amount FROM "bean_transfers" WHERE (((("bean_transfers"."debit" = 'currency' AND "bean_transfers"."currency" = 'MONKEY')) AND ("bean_transfers".user_id = 1)) AND ("bean_transfers".user_id = 1)) 
+  SQL (0.3ms)   SELECT sum("bean_transfers".amount) AS sum_amount FROM "bean_transfers" WHERE (((("bean_transfers"."credit" = 'currency' AND "bean_transfers"."currency" = 'MONKEY')) AND ("bean_transfers".user_id = 1)) AND ("bean_transfers".user_id = 1)) 
+  SQL (0.2ms)   SELECT sum("bean_transfers".amount) AS sum_amount FROM "bean_transfers" WHERE (((("bean_transfers"."debit" = 'currency' AND "bean_transfers"."currency" = 'USD')) AND ("bean_transfers".user_id = 1)) AND ("bean_transfers".user_id = 1)) 
+  SQL (0.2ms)   SELECT sum("bean_transfers".amount) AS sum_amount FROM "bean_transfers" WHERE (((("bean_transfers"."credit" = 'currency' AND "bean_transfers"."currency" = 'USD')) AND ("bean_transfers".user_id = 1)) AND ("bean_transfers".user_id = 1)) 
+  SQL (0.2ms)   SELECT sum("bean_transfers".amount) AS sum_amount FROM "bean_transfers" WHERE (((("bean_transfers"."debit" = 'expense' AND "bean_transfers"."currency" = 'USD')) AND ("bean_transfers".user_id = 1)) AND ("bean_transfers".user_id = 1)) 
+  SQL (0.2ms)   SELECT sum("bean_transfers".amount) AS sum_amount FROM "bean_transfers" WHERE (((("bean_transfers"."credit" = 'expense' AND "bean_transfers"."currency" = 'USD')) AND ("bean_transfers".user_id = 1)) AND ("bean_transfers".user_id = 1)) 
+  SQL (0.2ms)   SELECT sum("bean_transfers".amount) AS sum_amount FROM "bean_transfers" WHERE (((("bean_transfers"."debit" = 'payment' AND "bean_transfers"."currency" = 'USD')) AND ("bean_transfers".user_id = 1)) AND ("bean_transfers".user_id = 1)) 
+  SQL (0.2ms)   SELECT sum("bean_transfers".amount) AS sum_amount FROM "bean_transfers" WHERE (((("bean_transfers"."credit" = 'payment' AND "bean_transfers"."currency" = 'USD')) AND ("bean_transfers".user_id = 1)) AND ("bean_transfers".user_id = 1)) 

data/spec/payment_spec.rb

@@ -0,0 +1,70 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Bean::Payment do
+  before(:all) do
+    Bean::Transfer.destroy_all
+    @user = User.make
+    @payment = Bean::Payment.make(:amount => 10.to_money)
+  end
+  
+  describe 'authorize' do    
+    before(:all) do
+      @transfer = @payment.authorize
+    end
+
+    it 'should add a transfer' do
+      @payment.transfers.size.should == 1
+    end
+    
+    it 'should set the amount on the transfer' do
+      @transfer.amount.should == '$10'.to_money
+    end
+    
+    it 'should set the event to authorize' do
+      @transfer.event.should == 'authorize'
+    end
+    
+    it 'should credit the payment account' do
+      @transfer.credit.should == 'payment'
+    end
+    
+    it 'should debit the authorized account' do
+      @transfer.debit.should == 'pending'
+    end
+    
+    it 'should fail if there is a state' do
+      @payment.authorize.should == false
+    end
+  end
+  
+  describe 'capture' do
+    before(:all) do
+      @authorization = @payment.authorize
+      @transfer = @payment.capture
+    end
+    
+    it 'should add a transfer' do
+      @payment.transfers.size.should == 2
+    end
+    
+    it 'should set the amount on the transfer' do
+      @transfer.amount.should == '$10'.to_money
+    end
+    
+    it 'should set the event to authorize' do
+      @transfer.event.should == 'capture'
+    end
+    
+    it 'should credit the pending account' do
+      @transfer.credit.should == 'pending'
+    end
+    
+    it 'should debit the cash account' do
+      @transfer.debit.should == 'cash'
+    end
+    
+    it 'should fail unless the state is authorized' do
+      @payment.capture.should == false
+    end
+  end
+end

data/spec/schema.rb

@@ -0,0 +1,30 @@
+ActiveRecord::Migration.verbose = false
+
+ActiveRecord::Schema.define do
+  create_table :users, :force => true do |t|
+  end
+  
+  create_table :payments, :force =>  true do |t|
+    t.integer :amount
+    t.string :currency, :null => false, :default => 'USD'
+    t.string :reference
+  end
+  
+  create_table :bean_transfers, :force => true do |t|
+    t.references :user
+    t.references :accountable, :polymorphic => true
+    
+    t.string :state
+    t.integer :amount
+    t.string :debit
+    t.string :credit
+    t.string :currency, :null => false, :default => 'USD'
+    t.string :event, :null => false, :default => 'transfer'
+    t.boolean :success
+    t.string :reference
+    t.string :message
+    t.text :params
+    t.boolean :test
+    t.boolean :affect_balance
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'rubygems'
+# require 'sqlite3'
+require 'active_record'
+require 'active_merchant'
+require 'spec'
+require 'spec/autorun'
+
+require 'bean_machine'
+require 'bean/payment'
+
+ActiveRecord::Base.establish_connection(:adapter  => 'sqlite3', :database => ':memory:')
+
+require File.dirname(__FILE__) + '/spec_helper'
+
+require 'schema'
+require 'blueprints'
+
+Bean::Payment.gateway = ActiveMerchant::Billing::BogusGateway.new
+
+Spec::Runner.configure do |config|
+  config.before(:all)    { Sham.reset(:before_all)  }
+  config.before(:each)   { Sham.reset(:before_each) }
+end

data/spec/transfer_spec.rb

@@ -0,0 +1,47 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Bean::Transfer do
+  describe 'amount' do
+    it 'should be Money' do
+      Bean::Transfer.make_unsaved.amount.should be_a(Money)
+    end
+    
+    it 'should be more than zero' do
+      Bean::Transfer.make_unsaved(:amount => 1.to_money).should be_valid
+      Bean::Transfer.make_unsaved(:amount => 0.to_money).should be_invalid
+      Bean::Transfer.make_unsaved(:amount => -1.to_money).should be_invalid
+    end    
+  end
+    
+  describe 'scopes' do
+    before(:all) do
+      Bean::Transfer.destroy_all
+      Bean::Transfer.make(:credit => 'asset', :debit => 'liability', :amount => Money.new(rand(100)+1, 'MONKEY'))
+      Bean::Transfer.make(:credit => 'asset', :debit => 'expense', :amount => Money.new(rand(100)+1, 'USD'))
+      Bean::Transfer.make(:credit => 'payment', :debit => 'asset', :amount => Money.new(rand(100)+1, 'USD'))
+      Bean::Transfer.make(:credit => 'payment', :debit => 'expense', :amount => Money.new(rand(100)+1, 'USD'))
+      Bean::Transfer.make(:credit => 'payment', :debit => 'currency', :amount => Money.new(rand(100)+1, 'USd'))
+      Bean::Transfer.make(:credit => 'currency', :debit => 'income', :amount => Money.new(rand(100)+1, 'MONKEY'))
+    end
+
+    it 'should scope by debit account' do
+      Bean::Transfer.debiting(:asset).count.should == 1
+      Bean::Transfer.debiting(:liability).count.should == 1
+      Bean::Transfer.debiting(:expense).count.should == 2
+      Bean::Transfer.debiting(:income).count.should == 1
+      Bean::Transfer.debiting(:currency).count.should == 1
+    end
+
+    it 'should scope by credit account' do
+      Bean::Transfer.crediting(:asset).count.should == 2
+      Bean::Transfer.crediting(:payment).count.should == 3
+      Bean::Transfer.crediting(:currency).count.should == 1
+    end
+    
+    it 'should scope by currency' do
+      Bean::Transfer.in_currency(:USD).count.should == 4
+      Bean::Transfer.in_currency(:MONKEY).count.should == 2
+    end
+    
+  end
+end

data/spec/user_spec.rb

@@ -0,0 +1,34 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Bean::User do
+  describe 'balance' do
+    before(:all) do
+      @user = User.make
+      Bean::Transfer.destroy_all
+      @user.transfers.make(:credit => 'asset', :debit => 'liability', :amount => Money.new(100, 'MONKEY'))
+      @user.transfers.make(:credit => 'asset', :debit => 'expense', :amount => Money.new(200, 'USD'))
+      @user.transfers.make(:credit => 'payment', :debit => 'asset', :amount => Money.new(300, 'USD'))
+      @user.transfers.make(:credit => 'payment', :debit => 'expense', :amount => Money.new(400, 'USD'))
+      @user.transfers.make(:credit => 'payment', :debit => 'currency', :amount => Money.new(500, 'USd'))
+      @user.transfers.make(:credit => 'currency', :debit => 'income', :amount => Money.new(600, 'MONKEY'))
+    end
+
+    it 'should return a money object' do
+      @user.balance(:asset).should be_a(Money)
+    end
+    
+    it 'should default to assets in USD' do
+      @user.balance.should == Money.new(100,'USD')
+    end
+    
+    it 'should take the account as the first option and currency as the second' do
+      @user.balance(:liability, :monkey).should == Money.new(100,'MONKEY')
+      @user.balance(:income, :monkey).should == Money.new(600,'MONKEY')
+      @user.balance(:currency, :monkey).should == Money.new(-600,'MONKEY')
+      @user.balance(:currency, :usd).should == Money.new(500,'USD')
+      @user.balance(:expense, :usd).should == Money.new(600,'USD')
+      @user.balance(:payment, :usd).should == Money.new(-1200,'USD')
+    end
+  end
+  
+end

metadata

@@ -0,0 +1,188 @@
+--- !ruby/object:Gem::Specification 
+name: bean_machine
+version: !ruby/object:Gem::Version 
+  prerelease: true
+  segments: 
+  - 0
+  - 0
+  - 0
+  - pre1
+  version: 0.0.0.pre1
+platform: ruby
+authors: 
+- hexorx
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-20 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: yard
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: cucumber
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: machinist
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: faker
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: money
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: activemerchant
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id008
+description: Accounting sucks. Well if you are trying to do it right it does. Bean machine gives you the power of an immutable double entry accounting system through the use of a simple transfer method. The idea is to make accounting easy by breaking it into easy to follow steps. Transfer this much from this account to that account.
+email: hexorx@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.markdown
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.markdown
+- Rakefile
+- VERSION
+- credit_card.dot
+- dsl.rb
+- features/billing.feature
+- features/step_definitions/billing_steps.rb
+- features/support/env.rb
+- lib/bean/machine.rb
+- lib/bean/payment.rb
+- lib/bean/transfer.rb
+- lib/bean/user.rb
+- lib/bean_machine.rb
+- spec/blueprints.rb
+- spec/debug.log
+- spec/payment_spec.rb
+- spec/schema.rb
+- spec/spec_helper.rb
+- spec/transfer_spec.rb
+- spec/user_spec.rb
+has_rdoc: true
+homepage: http://github.com/hexorx/bean_machine
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Kick accounting in the mean bean machine!
+test_files: 
+- spec/blueprints.rb
+- spec/payment_spec.rb
+- spec/schema.rb
+- spec/spec_helper.rb
+- spec/transfer_spec.rb
+- spec/user_spec.rb