subledger 0.7.7

data/lib/subledger.rb

@@ -0,0 +1,234 @@
+# encoding: UTF-8
+
+Encoding.default_internal = Encoding.default_external = 'UTF-8'
+
+require 'bigdecimal'
+require 'logger'
+
+require 'time'
+
+require 'rubygems'
+
+require 'multi_json'
+
+require 'subledger/exception_handler'
+
+module Subledger
+  class Error < StandardError; end
+end
+
+require 'subledger/collection_name'
+require 'subledger/domain'
+require 'subledger/interface'
+require 'subledger/path'
+require 'subledger/rest'
+require 'subledger/uuid'
+require 'subledger/version'
+
+# additional requires at bottom
+
+SUBLEDGER = 'SUBLEDGER'
+
+module Subledger
+  class DateError < Error; end
+
+  ROOT = File.expand_path __FILE__ + '../../..'
+
+  ROOT_CONFIG = ROOT + '/config'
+  ROOT_LIB    = ROOT + '/lib'
+  ROOT_SPEC   = ROOT + '/spec'
+
+  LOG = ::Logger.new '/tmp/subledger.log', 10, 102_400_000
+  LOG.sev_threshold = Logger::DEBUG
+
+  case ::ENV['SUBLEDGER_ENV']
+    when nil
+      ENV    = 'production'
+      COVER  = ::ENV['SUBLEDGER_COVER' ] || false
+      FORMAT = ::ENV['SUBLEDGER_FORMAT'] || 'pride'
+      SCHEME = ::ENV['SUBLEDGER_SCHEME'] || 'https://'
+      DOMAIN = ::ENV['SUBLEDGER_DOMAIN'] || 'api.subledger.com'
+
+      STORE  = ( ::ENV['SUBLEDGER_STORE'] || :api ).to_sym
+      AWS_CRED_FILE = nil
+
+      LOG.sev_threshold = Logger::WARN
+
+    when 'test'
+      ENV    = 'test'
+      COVER  = ::ENV['SUBLEDGER_COVER' ] || false
+      FORMAT = ::ENV['SUBLEDGER_FORMAT'] || 'pride'
+      SCHEME = ::ENV['SUBLEDGER_SCHEME'] || 'http://'
+      DOMAIN = ::ENV['SUBLEDGER_DOMAIN'] || 'api.subledger.dev'
+
+      STORE  = ( ::ENV['SUBLEDGER_STORE'] || :memory ).to_sym
+      AWS_CRED_FILE = 'aws_creds_dev.yml'
+
+    when 'test_single'
+      ENV    = 'test'
+      COVER  = ::ENV['SUBLEDGER_COVER' ] || false
+      FORMAT = ::ENV['SUBLEDGER_FORMAT'] || 'turn'
+      SCHEME = ::ENV['SUBLEDGER_SCHEME'] || 'http://'
+      DOMAIN = ::ENV['SUBLEDGER_DOMAIN'] || 'api.subledger.dev'
+
+      STORE  = ( ::ENV['SUBLEDGER_STORE'] || :memory ).to_sym
+      AWS_CRED_FILE = 'aws_creds_dev.yml'
+
+    when 'ci'
+      ENV    = 'ci'
+      COVER  = ::ENV['SUBLEDGER_COVER' ] || false
+      FORMAT = ::ENV['SUBLEDGER_FORMAT'] || 'normal'
+      SCHEME = ::ENV['SUBLEDGER_SCHEME'] || 'http://'
+      DOMAIN = ::ENV['SUBLEDGER_DOMAIN'] || 'localhost:9292'
+
+      STORE  = ( ::ENV['SUBLEDGER_STORE'] || :memory ).to_sym
+      AWS_CRED_FILE = 'aws_creds_dev.yml'
+
+    when 'production'
+      ENV    = 'production'
+      COVER  = ::ENV['SUBLEDGER_COVER' ] || false
+      FORMAT = ::ENV['SUBLEDGER_FORMAT'] || 'pride'
+      SCHEME = ::ENV['SUBLEDGER_SCHEME'] || 'https://'
+      DOMAIN = ::ENV['SUBLEDGER_DOMAIN'] || 'api.subledger.com'
+
+      STORE  = ( ::ENV['SUBLEDGER_STORE'] || :aws ).to_sym
+      AWS_CRED_FILE = 'aws_creds_prod.yml'
+  end
+
+  case STORE
+    when :memory
+      SLOW_POST_DELAY      = ::ENV['SUBLEDGER_SLOW_POST_DELAY']      || 0.5
+      PROGRESS_INITIAL     = ::ENV['SUBLEDGER_PROGRESS_INITIAL']     || 0.075
+      PROGRESS_RETRY       = ::ENV['SUBLEDGER_PROGRESS_RETRY']       || 0.05
+      PROGRESS_FAIL        = ::ENV['SUBLEDGER_PROGRESS_FAIL']        || 4
+      BALANCE_SETTLE_DELAY = ::ENV['SUBLEDGER_BALANCE_SETTLE_DELAY'] || 0
+    when :api
+      SLOW_POST_DELAY      = ::ENV['SUBLEDGER_SLOW_POST_DELAY']      || 0.5
+      PROGRESS_INITIAL     = ::ENV['SUBLEDGER_PROGRESS_INITIAL']     || 0.075
+      PROGRESS_RETRY       = ::ENV['SUBLEDGER_PROGRESS_RETRY']       || 0.05
+      PROGRESS_FAIL        = ::ENV['SUBLEDGER_PROGRESS_FAIL']        || 4
+      BALANCE_SETTLE_DELAY = ::ENV['SUBLEDGER_BALANCE_SETTLE_DELAY'] || 0
+    when :aws
+      SLOW_POST_DELAY      = ::ENV['SUBLEDGER_SLOW_POST_DELAY']      || 10
+      PROGRESS_INITIAL     = ::ENV['SUBLEDGER_PROGRESS_INITIAL']     || 1.5
+      PROGRESS_RETRY       = ::ENV['SUBLEDGER_PROGRESS_RETRY']       || 0.5
+      PROGRESS_FAIL        = ::ENV['SUBLEDGER_PROGRESS_FAIL']        || 20
+      BALANCE_SETTLE_DELAY = ::ENV['SUBLEDGER_BALANCE_SETTLE_DELAY'] || 3
+  end
+
+  unless AWS_CRED_FILE.nil?
+    AWS_PATH = File.expand_path( File.dirname( __FILE__ ) + '/../config/' + AWS_CRED_FILE )
+  end
+
+  RENDERED_REPORTS_BUCKET           = "subledger_#{ENV}_rendered_reports"
+  RENDERED_REPORT_CATEGORIES_BUCKET = "subledger_#{ENV}_rendered_report_categories"
+  BACKUP_BUCKET                     = "subledger_#{ENV}_backups"
+
+  def self.new args = { }
+    args = args.dup
+
+    # auth args
+
+    identity    = args[:identity]
+    identity_id = args[:identity_id]
+
+    if identity.nil? and not identity_id.nil?
+      args.merge! :identity => Domain::Identity.
+                                 new( :id => identity_id )
+
+      args.delete :identity_id
+    end
+
+    key    = args[:key]
+    key_id = args[:key_id]
+
+    if key.nil? and not key_id.nil?
+      args.merge! :auth_key => Domain::Key.
+                                 new( :id       => key_id,
+                                      :identity => args[:identity],
+                                      :secret   => args[:secret] )
+
+      args.delete :key_id
+      args.delete :secret
+    end
+
+    # instance args
+
+    org    = args[:org]
+    org_id = args[:org_id]
+
+    if org.nil? and not org_id.nil?
+      args.merge! :org => Domain::Org.
+                            new( :id => org_id )
+
+      args.delete :org_id
+    end
+
+    book    = args[:book]
+    book_id = args[:book_id]
+
+    if book.nil? and not book_id.nil?
+      args.merge! :book => Domain::Book.
+                             new( :id  => book_id,
+                                  :org => args[:org] )
+
+      args.delete :book_id
+    end
+
+    args.merge! :store => store( args )
+
+    Interface::Client.new args
+  end
+
+  def self.store args = { }
+    store_sym = args[:store] || STORE
+
+    begin
+      require "subledger/store/#{store_sym}"
+    rescue LoadError => e
+      raise Error, "Store: #{store_sym}: #{e}"
+    end
+
+    Object.const_get(       'Subledger'          ).
+             const_get(     'Store'                ).
+               const_get(    store_sym.capitalize    ).
+                 const_get( 'Store'                    ).new args
+  end
+
+  # Thanks to Jan Goyvaerts, Steven Levithan, O'Reilly Media, Inc.
+  ISO8601_REGEXP = /^(?<year>[0-9]{4})-?(?<month>1[0-2]|0[1-9])-?(?<day>3[0-1]|0[1-9]|[1-2][0-9])T(?<hour>2[0-3]|[0-1][0-9]):?(?<minute>[0-5][0-9]):?(?<second>[0-5][0-9])(?<ms>\.[0-9]{1,3})??(?<timezone>Z|[+-](?:2[0-3]|[0-1][0-9]):?[0-5][0-9])$/
+  # http://my.safaribooksonline.com/book/programming/regular-expressions/9780596802837/4dot-validation-and-formatting/id2983571
+  # Modified to accept optional punctuation and fractional seconds of 1 to 3 digits
+
+  EARLIEST_TIME = Time.utc 1970, 1, 1, 0, 0, 0, 0
+  LATEST_TIME   = EARLIEST_TIME + 2 ** 32
+
+  def self.parse_time parameter_name, time_string
+    if time_string.nil?
+      raise DateError, "#{parameter_name} is required"
+    end
+
+    unless time_string.match ISO8601_REGEXP
+      raise DateError, "#{parameter_name} must be ISO 8601 datetime with timezone, optional punctuation, optional fractional seconds (1-3 digits)"
+    end
+
+    time = begin
+             Time.parse( time_string ).utc
+           rescue ArgumentError => e
+             raise DateError, "#{parameter_name}: not a parsable time"
+           end
+
+    unless time >= EARLIEST_TIME and time <= LATEST_TIME
+      raise DateError, "#{parameter_name} must be between #{EARLIEST_TIME.iso8601(3)} and #{LATEST_TIME.iso8601(3)} inclusive"
+    end
+
+    time
+  end
+
+  def self.log_environment
+    LOG.info "SUBLEDGER_STORE: #{STORE}"
+    LOG.info "SUBLEDGER_ENV:   #{ENV}"
+  end
+end
+
+require 'subledger/store'

data/spec/spec_helper.rb

@@ -0,0 +1,77 @@
+# encoding: UTF-8
+
+Encoding.default_internal = Encoding.default_external = 'UTF-8'
+
+require 'pp'
+
+require 'rubygems'
+
+require 'subledger'
+require 'subledger/server'
+
+require 'minitest/autorun'
+require 'minitest/mock'
+require 'minitest/pride' unless Subledger::ENV == 'ci'
+
+require 'rack/test'
+
+require Subledger::ROOT_SPEC + '/support/minitest'
+require Subledger::ROOT_SPEC + '/support/factory'
+
+module Subledger
+  def self.scenarios
+    [
+      { :before    => ['l', 'k'] },
+      { :ending    => ['m', 'l'] },
+      { :starting  => ['m', 'n'] },
+      { :after     => ['n', 'o'] },
+      { :preceding => ['l', 'k'] },
+      { :following => ['n', 'o'] }
+    ]
+  end
+
+  def self.scenarios_order
+    [
+      { :before    => ['l', 'k'] },
+      { :ending    => ['m', 'l'] },
+      { :starting  => ['m', 'n'] },
+      { :after     => ['n', 'o'] }
+    ]
+  end
+
+  def self.scenarios_id
+    [
+      { :preceding => ['l', 'k'] },
+      { :following => ['n', 'o'] }
+    ]
+  end
+end
+
+# Factory namespace setup
+
+ActiveBook           = Subledger::Domain::ActiveBook
+ArchivedBook         = Subledger::Domain::ArchivedBook
+ActiveJournalEntry   = Subledger::Domain::ActiveJournalEntry
+PostingJournalEntry  = Subledger::Domain::PostingJournalEntry
+PostedJournalEntry   = Subledger::Domain::PostedJournalEntry
+ArchivedJournalEntry = Subledger::Domain::PostingJournalEntry
+ActiveAccount        = Subledger::Domain::ActiveAccount
+ArchivedAccount      = Subledger::Domain::ArchivedAccount
+ActiveLine           = Subledger::Domain::ActiveLine
+Debit                = Subledger::Domain::Debit
+Credit               = Subledger::Domain::Credit
+Zero                 = Subledger::Domain::Zero
+
+module Kernel
+  private
+
+  def this_method
+    caller[0] =~ /`([^']*)'/ and $1
+  end
+
+  def calling_method
+    caller[1] =~ /`([^']*)'/ and $1
+  end
+end
+
+Minitest.autorun

data/spec/subledger_account_spec.rb

@@ -0,0 +1,354 @@
+require 'spec_helper'
+
+Test 'Subledger' do
+
+  let(:factory   ) { Subledger::Factory.create }
+  let(:amount    ) { '1' }
+
+  balances_order = { :before   => [ Subledger::Domain::Debit.new( '3' ),
+                                    Subledger::Domain::Debit.new( '1' ) ],
+                     :ending   => [ Subledger::Domain::Debit.new( '6' ),
+                                    Subledger::Domain::Debit.new( '3' ) ],
+                     :starting => [ Subledger::Domain::Debit.new( '6' ),
+                                    Subledger::Domain::Debit.new( '10' ) ],
+                     :after    => [ Subledger::Domain::Debit.new( '10' ),
+                                    Subledger::Domain::Debit.new( '15' ) ] }
+
+  balances_id = { :preceding => [ Subledger::Domain::Debit.new( '3' ),
+                                  Subledger::Domain::Debit.new( '1' ) ],
+                  :following => [ Subledger::Domain::Debit.new( '10' ),
+                                  Subledger::Domain::Debit.new( '15' ) ] }
+
+  Instance do
+    subject { factory.client }
+
+    Test 'Account' do
+
+      # POST /books/:book_id/accounts
+      RespondsTo 'account.create' do
+        ByReturning 'an instance of Subledger::Domain::ActiveAccount' do
+          subject.account.create( factory.account_args ).
+                     must_be_instance_of Subledger::Domain::ActiveAccount
+        end
+      end
+
+      # GET /books/:book_id/accounts/:id/first_and_last_line
+      [ :archived, :active ].each do |state|
+        RespondsTo 'account.first_and_last_line' do
+          let(:account) { factory.create_account state }
+
+          When 'the account has no lines' do
+            ByReturning "an empty array" do
+              subject.
+                account.
+                  first_and_last_line( :id => account.id ).must_be_instance_of Array
+
+              subject.
+                account.
+                  first_and_last_line( :id => account.id ).empty?.must_equal true
+            end
+          end
+
+          When 'the account has lines' do
+            before { factory.create_posted_line_collection account }
+
+            ByReturning "an empty array" do
+              subject.
+                account.
+                  first_and_last_line( :id => account.id ).must_be_instance_of Array
+
+              subject.
+                account.
+                  first_and_last_line( :id => account.id ).
+                    length.must_equal 2
+
+              subject.
+                account.
+                  first_and_last_line( :id => account.id ).
+                    first.must_be_instance_of Subledger::Domain::PostedLine
+
+              subject.
+                account.
+                  first_and_last_line( :id => account.id ).
+                    last.must_be_instance_of Subledger::Domain::PostedLine
+            end
+          end
+        end
+      end
+
+      [ :archived, :active ].each do |state|
+        RespondsTo 'account.read when description has a / in it' do
+          let(:description) { 'this has a / in it' }
+          let(:args       ) { factory.account_args.
+                                        merge :description => description }
+          let(:account    ) { subject.account.create args }
+
+          ByReturning "an instance of #{state} account" do
+            subject.account.read( :id => account.id ).id.must_equal account.id
+            subject.account.read( :id => account.id ).description.must_equal description
+          end
+        end
+      end
+
+      # PATCH /books/:book_id/accounts/:id
+      [ :archived, :active ].each do |state|
+        RespondsTo 'accounts.update' do
+          let(:account    ) { factory.create_account state }
+          let(:args       ) { account.attributes }
+          let(:description) { 'updated description' }
+          let(:update_args) { args.merge :description => description,
+                                         :version     => 2 }
+
+          ByReturning "an instance of #{state} account" do
+            patched = subject.accounts.update update_args
+
+            patched.must_be_instance_of account.class
+            patched.description.must_equal description
+          end
+        end
+      end
+
+      # GET /books/:book_id/accounts ? before   = :description & limit = :limit & state = :state
+      #                                ending
+      #                                starting
+      #                                after
+      [ :active, :archived ].each do |state|
+        Subledger.scenarios_order.each do |scenario|
+          action       = scenario.keys.first
+          expectations = scenario[action]
+
+          RespondsTo "accounts.collect :action => #{action}, :state => #{state}" do
+            let(:accounts) { factory.create_account_collection state }
+            let(:item    ) { accounts[2] }
+            let(:limit   ) { 2 }
+            let(:klass   ) { item.class }
+
+            let(:args) { { :action      => action,
+                           :description => item.description,
+                           :state       => state,
+                           :limit       => limit } }
+
+            When 'not given a block' do
+              ByReturning "a list of #{state} accounts" do
+                subject.accounts.collect( args ).length.must_equal limit
+              end
+            end
+
+            When 'given a block' do
+              ByYielding "a list of #{state} accounts" do
+                count = 0
+
+                subject.accounts.collect args do |account|
+                  expectation = expectations[count]
+
+                  account.description.must_equal expectation
+
+                  account.must_be_instance_of klass
+
+                  count += 1
+                end
+
+                count.must_equal limit
+              end
+            end
+          end
+        end
+      end
+
+      # GET /accounts ? preceding = :book_id & limit = :limit & state = :state
+      #                 following = :book_id & limit = :limit & state = :state
+      [ :active, :archived ].each do |state|
+        Subledger.scenarios_id.each do |scenario|
+          action       = scenario.keys.first
+          expectations = scenario[action]
+
+          RespondsTo "accounts.collect :action => #{action}" do
+            let(:accounts) { factory.create_account_collection state }
+            let(:item    ) { accounts[2] }
+            let(:limit   ) { 2 }
+            let(:klass   ) { item.class }
+
+            let(:args) { { :action => action,
+                           :id     => item.id,
+                           :state  => state,
+                           :limit  => limit } }
+
+            When 'not given a block' do
+              ByReturning "a list of #{state} accounts" do
+                subject.accounts.collect( args ).length.must_equal limit
+              end
+            end
+
+            When 'given a block' do
+              ByYielding "a list of #{state} accounts" do
+                count = 0
+
+                subject.accounts.collect args do |account|
+                  expectation = expectations[count]
+
+                  account.description.must_equal expectation
+
+                  account.must_be_instance_of klass
+
+                  count += 1
+                end
+
+                count.must_equal limit
+              end
+            end
+          end
+        end
+      end
+
+      # GET /books/:book_id/accounts/:id/lines ? before   = :effective_at & limit = :limit
+      #                                          ending
+      #                                          starting
+      #                                          after
+      Subledger.scenarios_order.each do |scenario|
+        action       = scenario.keys.first
+        expectations = scenario[action]
+        balances     = balances_order[action]
+
+        RespondsTo "account.read(:id => id).lines action => #{action}" do
+          let(:account) { factory.create_account :active }
+          let(:lines  ) { factory.create_posted_line_collection account }
+          let(:item   ) { lines[2] }
+          let(:limit  ) { 2 }
+
+          let(:args) { { :action       => action,
+                         :effective_at => item.effective_at,
+                         :limit        => limit } }
+
+          When 'not given a block' do
+            ByReturning 'a list of account lines' do
+              account.lines( args ).length.must_equal expectations.length
+            end
+          end
+
+          When 'given a block' do
+            ByYielding 'a list of account lines' do
+              count = 0
+
+              account.lines args do |line|
+                expectation = expectations[count]
+                line.description.must_equal expectation
+
+                line.must_be_instance_of Subledger::Domain::PostedLine
+
+                line.posted_at.wont_be_nil
+                line.effective_at.wont_be_nil
+
+                line.balance.must_be_instance_of Subledger::Domain::Balance
+
+                line.balance.must_equal balances[count]
+
+                count += 1
+              end
+
+              count.must_equal expectations.length
+            end
+          end
+        end
+      end
+
+      # GET /books/:book_id/accounts/:id/lines ? preceding = :line_id & limit = :limit
+      #                                          following = :line_id & limit = :limit
+      Subledger.scenarios_id.each do |scenario|
+        action       = scenario.keys.first
+        expectations = scenario[action]
+        balances     = balances_id[action]
+
+        RespondsTo "account_instance.lines action => #{action}" do
+          let(:account) { factory.create_account :active }
+          let(:lines  ) { factory.create_posted_line_collection account }
+          let(:item   ) { lines[2] }
+          let(:limit  ) { 2 }
+
+          let(:args) { { :action => action,
+                         :id     => item.id,
+                         :limit  => limit } }
+
+          When 'not given a block' do
+            ByReturning 'a list of account lines' do
+              account.lines( args ).length.must_equal expectations.length
+            end
+          end
+
+          When 'given a block' do
+            ByYielding 'a list of account lines' do
+              count = 0
+
+              account.lines args do |line|
+                expectation = expectations[count]
+
+                line.description.must_equal expectation
+
+                line.must_be_instance_of Subledger::Domain::PostedLine
+
+                line.posted_at.wont_be_nil
+                line.effective_at.wont_be_nil
+
+                line.balance.must_be_instance_of Subledger::Domain::Balance
+
+                line.balance.must_equal balances[count]
+
+                count += 1
+              end
+
+              count.must_equal expectations.length
+            end
+          end
+        end
+      end
+
+      # GET /books/:book_id/accounts/:account_id/lines/:id
+
+      RespondsTo 'account.line.read' do
+        let(:account) { factory.create_account :active }
+        let(:lines  ) { factory.create_posted_line_collection account }
+        let(:line   ) { lines[2] }
+
+        ByReturning 'Subledger::Domain::PostedLine' do
+          posted_line = account.line( :id => line.id ).read
+          posted_line.must_be_instance_of Subledger::Domain::PostedLine
+          posted_line.posted_at.must_be_instance_of Time
+          posted_line.effective_at.must_be_instance_of Time
+
+          if Subledger::STORE == :api
+            posted_line.balance.must_be_instance_of Subledger::Domain::Balance
+            posted_line.balance.must_equal factory.
+                                             client.
+                                               debit( '6' )
+          end
+        end
+      end
+
+      # POST /books/:book_id/accounts/:id/archive
+      RespondsTo 'account_instance.archive' do
+        ByReturning 'an instance of Subledger::Domain::ArchivedAccount' do
+          factory.create_account(:active).archive.
+                     must_be_instance_of Subledger::Domain::ArchivedAccount
+        end
+      end
+
+      # POST /books/:book_id/archived_accounts/:id/activate
+      RespondsTo 'archived_account_instance.activate' do
+        ByReturning 'an instance of Subledger::Domain::ActiveAccount' do
+          factory.create_account(:archived).activate.
+                     must_be_instance_of Subledger::Domain::ActiveAccount
+        end
+      end
+
+      # GET /books/:book_id/accounts/:id/balance/:at
+      [ :archived, :active ].each do |state|
+        RespondsTo 'account_instance.balance' do
+          let(:account) { factory.create_account state }
+
+          ByReturning 'a Subledger::Domain::Balance' do
+            account.balance( :at => Time.now ).must_be_instance_of Subledger::Domain::Balance
+          end
+        end
+      end
+    end
+  end
+end