double_entry 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e815a7e5aabf260a4697a11f7685d362c017cdfb
-  data.tar.gz: 416041a85f823156b3211c58edcb751a07ea60d1
+  metadata.gz: bee621c780c82e734a95964749650675683f1460
+  data.tar.gz: 326d9d02768905beede8b785215b1eb164a4c8cc
 SHA512:
-  metadata.gz: 0b36f7c934a87f36ec0250d360b043e4a98c033bd74289eaa9cade1e120f35fa438376629bb8d099de122481f28411ecc4a6890641646e56ba49afad52d99312
-  data.tar.gz: 4c8a843ba84218611d2545b161f58cddbb03617c94564027f02e85957e6754d299d5381f37527e5cc0f7b3e58e05a4821fb27c82883b750fe139db61e901cf0c
+  metadata.gz: e98f6f1a3b11a5bd9f8b4e384eb3dff8a6cd56b40ae3f8b430565fdbc601e3532a6cc95f8fdacc469457425533745d99a7b6cc8accaf4a6dd67b0d2b27ed41b0
+  data.tar.gz: 945ba3173e2b170e1cee74fcb89e31f8ce4a2245fa75dbe6efa267850196c7470495ffd3b4f47bae23acef6aa89722e7ca0379a53ff927ca7f8e49d9727fdb48

data/lib/double_entry/account.rb

@@ -3,13 +3,23 @@ module DoubleEntry
   class Account
 
     class << self
-      attr_writer :accounts
+      attr_writer :accounts, :scope_identifier_max_length, :account_identifier_max_length
 
       # @api private
       def accounts
         @accounts ||= Set.new
       end
 
+      # @api private
+      def scope_identifier_max_length
+        @scope_identifier_max_length ||= 23
+      end
+
+      # @api private
+      def account_identifier_max_length
+        @account_identifier_max_length ||= 31
+      end
+
       # @api private
       def account(identifier, options = {})
         account = accounts.find(identifier, options[:scope].present?)
@@ -128,7 +138,12 @@ module DoubleEntry
       private
 
       def ensure_scope_is_valid
-        scope_identity
+        identity = scope_identity
+        if identity && identity.length > Account.scope_identifier_max_length
+          raise ScopeIdentifierTooLongError.new(
+            "scope identifier '#{identity}' is too long. Please limit it to #{Account.scope_identifier_max_length} characters."
+          )
+        end
       end
     end
 
@@ -139,6 +154,11 @@ module DoubleEntry
       @scope_identifier = args[:scope_identifier]
       @positive_only = args[:positive_only]
       @currency = args[:currency] || Money.default_currency
+      if identifier.length > Account.account_identifier_max_length
+        raise AccountIdentifierTooLongError.new(
+          "account identifier '#{identifier}' is too long. Please limit it to #{Account.account_identifier_max_length} characters."
+        )
+      end
     end
 
     def scoped?

data/lib/double_entry/configuration.rb

@@ -3,8 +3,24 @@ module DoubleEntry
   include Configurable
 
   class Configuration
-    delegate :accounts, :accounts=, :to => "DoubleEntry::Account"
-    delegate :transfers, :transfers=, :to => "DoubleEntry::Transfer"
+
+    delegate(
+      :accounts,
+      :accounts=,
+      :scope_identifier_max_length,
+      :scope_identifier_max_length=,
+      :account_identifier_max_length,
+      :account_identifier_max_length=,
+      :to => "DoubleEntry::Account",
+    )
+
+    delegate(
+      :transfers,
+      :transfers=,
+      :code_max_length,
+      :code_max_length=,
+      :to => "DoubleEntry::Transfer",
+    )
 
     def define_accounts
       yield accounts

data/lib/double_entry/errors.rb

@@ -1,8 +1,11 @@
 # encoding: utf-8
 module DoubleEntry
   class UnknownAccount < RuntimeError; end
+  class AccountIdentifierTooLongError < RuntimeError; end
+  class ScopeIdentifierTooLongError < RuntimeError; end
   class TransferNotAllowed < RuntimeError; end
   class TransferIsNegative < RuntimeError; end
+  class TransferCodeTooLongError < RuntimeError; end
   class DuplicateAccount < RuntimeError; end
   class DuplicateTransfer < RuntimeError; end
   class AccountWouldBeSentNegative < RuntimeError; end

data/lib/double_entry/reporting/aggregate.rb

@@ -2,7 +2,7 @@
 module DoubleEntry
  module Reporting
   class Aggregate
-    attr_reader :function, :account, :code, :range, :options, :filter
+    attr_reader :function, :account, :code, :range, :options, :filter, :currency
 
     def initialize(function, account, code, options)
       @function = function.to_s
@@ -13,6 +13,7 @@ module DoubleEntry
       @options = options
       @range = options[:range]
       @filter = options[:filter]
+      @currency = DoubleEntry::Account.currency(account)
     end
 
     def amount(force_recalculation = false)
@@ -24,18 +25,12 @@ module DoubleEntry
       end
     end
 
-    def formatted_amount
-      Aggregate.formatted_amount(function, amount, currency)
-    end
-
-    def self.formatted_amount(function, amount, currency)
-      safe_amount = amount || 0
-
-      case function.to_s
-      when 'count'
-        safe_amount
+    def formatted_amount(amount = amount)
+      amount ||= 0
+      if function == "count"
+        amount
       else
-        Money.new(safe_amount, currency)
+        Money.new(amount, currency)
       end
     end
 
@@ -46,10 +41,6 @@ module DoubleEntry
       aggregate.amount if aggregate
     end
 
-    def currency
-      DoubleEntry::Account.currency(account)
-    end
-
     def clear_old_aggregates
       LineAggregate.delete_all(field_hash)
     end
@@ -75,28 +66,26 @@ module DoubleEntry
       # otherwise they will get excruciatingly slow to calculate
       # as the year progresses.  (I am thinking mainly of the 'current' year.)
       # Combining monthly aggregates will mean that the figure will be partially memoized
-      case function.to_s
-      when 'average'
+      if function == "average"
         calculate_yearly_average
       else
-        zero = Aggregate.formatted_amount(function, 0, currency)
-
+        zero = formatted_amount(0)
         result = (1..12).inject(zero) do |total, month|
-          total += Reporting.aggregate(function, account, code,
-                                      :range => MonthRange.new(:year => range.year, :month => month), :filter => filter)
+          total += Reporting.aggregate(
+            function, account, code,
+            :range => MonthRange.new(:year => range.year, :month => month),
+            :filter => filter,
+          )
         end
-
-        result = result.cents if result.class == Money
-        result
+        result.is_a?(Money) ? result.cents : result
       end
     end
 
     def calculate_yearly_average
       # need this seperate function, because an average of averages is not the correct average
-      sum = Reporting.aggregate(:sum, account, code,
-                               :range => YearRange.new(:year => range.year), :filter => filter)
-      count = Reporting.aggregate(:count, account, code,
-                                 :range => YearRange.new(:year => range.year), :filter => filter)
+      year_range = YearRange.new(:year => range.year)
+      sum = Reporting.aggregate(:sum, account, code, :range => year_range, :filter => filter)
+      count = Reporting.aggregate(:count, account, code, :range => year_range, :filter => filter)
       (count == 0) ? 0 : (sum / count).cents
     end
 

data/lib/double_entry/reporting/aggregate_array.rb

@@ -9,16 +9,17 @@ module DoubleEntry
     #
     # For example, you could request all sales
     # broken down by month and it would return an array of values
-    attr_reader :function, :account, :code, :filter, :range_type, :start, :finish
+    attr_reader :function, :account, :code, :filter, :range_type, :start, :finish, :currency
 
     def initialize(function, account, code, options)
-      @function = function
+      @function = function.to_s
       @account = account
       @code = code
       @filter = options[:filter]
       @range_type = options[:range_type]
       @start = options[:start]
       @finish = options[:finish]
+      @currency = DoubleEntry::Account.currency(account)
 
       retrieve_aggregates
       fill_in_missing_aggregates
@@ -47,15 +48,14 @@ module DoubleEntry
     def retrieve_aggregates
       raise ArgumentError.new("Invalid range type '#{range_type}'") unless %w(year month week day hour).include? range_type
       @aggregates = LineAggregate.
-        where(:function => function.to_s).
+        where(:function => function).
         where(:range_type => 'normal').
         where(:account => account.to_s).
         where(:code => code.to_s).
         where(:filter => filter.inspect).
         where(LineAggregate.arel_table[range_type].not_eq(nil)).
-        inject({}) do |hash, result|
-          hash[result.key] = Aggregate.formatted_amount(function, result.amount, currency)
-          hash
+        each_with_object({}) do |hash, result|
+          hash[result.key] = formatted_amount(result.amount)
         end
     end
 
@@ -63,8 +63,13 @@ module DoubleEntry
       TimeRangeArray.make(range_type, start, finish)
     end
 
-    def currency
-      DoubleEntry::Account.currency(account)
+    def formatted_amount(amount)
+      amount ||= 0
+      if function == "count"
+        amount
+      else
+        Money.new(amount, currency)
+      end
     end
   end
  end

data/lib/double_entry/transfer.rb

@@ -3,13 +3,18 @@ module DoubleEntry
   class Transfer
 
     class << self
-      attr_writer :transfers
+      attr_writer :transfers, :code_max_length
 
       # @api private
       def transfers
         @transfers ||= Set.new
       end
 
+      # @api private
+      def code_max_length
+        @code_max_length ||= 47
+      end
+
       # @api private
       def transfer(amount, options = {})
         raise TransferIsNegative if amount < Money.zero
@@ -54,10 +59,17 @@ module DoubleEntry
       end
     end
 
-    attr_accessor :code, :from, :to, :description
+    attr_reader :code, :from, :to
 
     def initialize(attributes)
-      attributes.each { |name, value| send("#{name}=", value) }
+      @code = attributes[:code]
+      @from = attributes[:from]
+      @to = attributes[:to]
+      if code.length > Transfer.code_max_length
+        raise TransferCodeTooLongError.new(
+          "transfer code '#{code}' is too long. Please limit it to #{Transfer.code_max_length} characters."
+        )
+      end
     end
 
     def process(amount, from, to, code, detail)

data/lib/double_entry/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module DoubleEntry
-  VERSION = "0.8.0"
+  VERSION = "0.9.0"
 end

data/lib/generators/double_entry/install/templates/migration.rb

@@ -2,56 +2,56 @@ class CreateDoubleEntryTables < ActiveRecord::Migration
 
   def self.up
     create_table "double_entry_account_balances", :force => true do |t|
-      t.string   "account",    :null => false
-      t.string   "scope"
-      t.integer  "balance"
+      t.string     "account", :limit => 31, :null => false
+      t.string     "scope",   :limit => 23
+      t.integer    "balance",               :null => false
       t.timestamps
     end
 
-    add_index "double_entry_account_balances", ["account"], :name => "index_account_balances_on_account"
+    add_index "double_entry_account_balances", ["account"],          :name => "index_account_balances_on_account"
     add_index "double_entry_account_balances", ["scope", "account"], :name => "index_account_balances_on_scope_and_account", :unique => true
 
     create_table "double_entry_lines", :force => true do |t|
-      t.string   "account"
-      t.string   "scope"
-      t.string   "code"
-      t.integer  "amount"
-      t.integer  "balance"
-      t.integer  "partner_id"
-      t.string   "partner_account"
-      t.string   "partner_scope"
-      t.integer  "detail_id"
-      t.string   "detail_type"
+      t.string     "account",         :limit => 31, :null => false
+      t.string     "scope",           :limit => 23
+      t.string     "code",            :limit => 47, :null => false
+      t.integer    "amount",                        :null => false
+      t.integer    "balance",                       :null => false
+      t.integer    "partner_id"
+      t.string     "partner_account", :limit => 31, :null => false
+      t.string     "partner_scope",   :limit => 23
+      t.integer    "detail_id"
+      t.string     "detail_type"
       t.timestamps
     end
 
-    add_index "double_entry_lines", ["account", "code", "created_at"], :name => "lines_account_code_created_at_idx"
-    add_index "double_entry_lines", ["account", "created_at"], :name => "lines_account_created_at_idx"
+    add_index "double_entry_lines", ["account", "code", "created_at"],  :name => "lines_account_code_created_at_idx"
+    add_index "double_entry_lines", ["account", "created_at"],          :name => "lines_account_created_at_idx"
     add_index "double_entry_lines", ["scope", "account", "created_at"], :name => "lines_scope_account_created_at_idx"
-    add_index "double_entry_lines", ["scope", "account", "id"], :name => "lines_scope_account_id_idx"
+    add_index "double_entry_lines", ["scope", "account", "id"],         :name => "lines_scope_account_id_idx"
 
     create_table "double_entry_line_aggregates", :force => true do |t|
-      t.string   "function"
-      t.string   "account"
-      t.string   "code"
-      t.string   "scope"
-      t.integer  "year"
-      t.integer  "month"
-      t.integer  "week"
-      t.integer  "day"
-      t.integer  "hour"
-      t.integer  "amount"
-      t.string   "filter"
-      t.string   "range_type"
+      t.string     "function",   :limit => 15, :null => false
+      t.string     "account",    :limit => 31, :null => false
+      t.string     "code",       :limit => 47
+      t.string     "scope",      :limit => 23
+      t.integer    "year"
+      t.integer    "month"
+      t.integer    "week"
+      t.integer    "day"
+      t.integer    "hour"
+      t.integer    "amount",                   :null => false
+      t.string     "filter"
+      t.string     "range_type", :limit => 15, :null => false
       t.timestamps
     end
 
     add_index "double_entry_line_aggregates", ["function", "account", "code", "year", "month", "week", "day"], :name => "line_aggregate_idx"
 
     create_table "double_entry_line_checks", :force => true do |t|
-      t.integer  "last_line_id"
-      t.boolean  "errors_found"
-      t.text     "log"
+      t.integer    "last_line_id", :null => false
+      t.boolean    "errors_found", :null => false
+      t.text       "log"
       t.timestamps
     end
 

data/spec/double_entry/account_spec.rb

@@ -4,21 +4,54 @@ module DoubleEntry
   describe Account do
     let(:identity_scope) { ->(value) { value } }
 
-    it "instances should be sortable" do
-      account = Account.new(:identifier => "savings", :scope_identifier => identity_scope)
-      a = Account::Instance.new(:account => account, :scope => "123")
-      b = Account::Instance.new(:account => account, :scope => "456")
-      expect([b, a].sort).to eq [a, b]
+    describe "::new" do
+      context "given an identifier 31 characters in length" do
+        let(:identifier) { "xxxxxxxx 31 characters xxxxxxxx" }
+        specify do
+          expect { Account.new(:identifier => identifier) }.to_not raise_error
+        end
+      end
+
+      context "given an identifier 32 characters in length" do
+        let(:identifier) { "xxxxxxxx 32 characters xxxxxxxxx" }
+        specify do
+          expect { Account.new(:identifier => identifier) }.to raise_error AccountIdentifierTooLongError, /'#{identifier}'/
+        end
+      end
     end
 
-    it "instances should be hashable" do
-      account = Account.new(:identifier => "savings", :scope_identifier => identity_scope)
-      a1 = Account::Instance.new(:account => account, :scope => "123")
-      a2 = Account::Instance.new(:account => account, :scope => "123")
-      b  = Account::Instance.new(:account => account, :scope => "456")
+    describe Account::Instance do
+      it "is sortable" do
+        account = Account.new(:identifier => "savings", :scope_identifier => identity_scope)
+        a = Account::Instance.new(:account => account, :scope => "123")
+        b = Account::Instance.new(:account => account, :scope => "456")
+        expect([b, a].sort).to eq [a, b]
+      end
+
+      it "is hashable" do
+        account = Account.new(:identifier => "savings", :scope_identifier => identity_scope)
+        a1 = Account::Instance.new(:account => account, :scope => "123")
+        a2 = Account::Instance.new(:account => account, :scope => "123")
+        b  = Account::Instance.new(:account => account, :scope => "456")
+
+        expect(a1.hash).to eq a2.hash
+        expect(a1.hash).to_not eq b.hash
+      end
+
+      describe "::new" do
+        let(:account) { Account.new(:identifier => "x", :scope_identifier => identity_scope) }
+        subject(:initialize_account_instance) { Account::Instance.new(:account => account, :scope => scope) }
+
+        context "given a scope identifier 23 characters in length" do
+          let(:scope) { "xxxx 23 characters xxxx" }
+          specify { expect { initialize_account_instance }.to_not raise_error }
+        end
 
-      expect(a1.hash).to eq a2.hash
-      expect(a1.hash).to_not eq b.hash
+        context "given a scope identifier 24 characters in length" do
+          let(:scope) { "xxxx 24 characters xxxxx" }
+          specify { expect { initialize_account_instance }.to raise_error ScopeIdentifierTooLongError, /'#{scope}'/ }
+        end
+      end
     end
 
     describe "currency" do
@@ -32,27 +65,27 @@ module DoubleEntry
         expect(DoubleEntry::Account::Instance.new(:account => account).currency).to eq("AUD")
       end
     end
-  end
 
-  describe Account::Set do
-    describe "#define" do
-      context "given a 'savings' account is defined" do
-        before { subject.define(:identifier => "savings") }
-        its(:first) { should be_a Account }
-        its("first.identifier") { should eq "savings" }
+    describe Account::Set do
+      describe "#define" do
+        context "given a 'savings' account is defined" do
+          before { subject.define(:identifier => "savings") }
+          its(:first) { should be_an Account }
+          its("first.identifier") { should eq "savings" }
+        end
       end
-    end
 
-    describe "#active_record_scope_identifier" do
-      subject(:scope) { Account::Set.new.active_record_scope_identifier(ar_class) }
+      describe "#active_record_scope_identifier" do
+        subject(:scope) { Account::Set.new.active_record_scope_identifier(ar_class) }
 
-      context "given ActiveRecordScopeFactory is stubbed" do
-        let(:scope_identifier) { double(:scope_identifier) }
-        let(:scope_factory) { double(:scope_factory, :scope_identifier => scope_identifier) }
-        let(:ar_class) { double(:ar_class) }
-        before { allow(Account::ActiveRecordScopeFactory).to receive(:new).with(ar_class).and_return(scope_factory) }
+        context "given ActiveRecordScopeFactory is stubbed" do
+          let(:scope_identifier) { double(:scope_identifier) }
+          let(:scope_factory) { double(:scope_factory, :scope_identifier => scope_identifier) }
+          let(:ar_class) { double(:ar_class) }
+          before { allow(Account::ActiveRecordScopeFactory).to receive(:new).with(ar_class).and_return(scope_factory) }
 
-        it { should eq scope_identifier }
+          it { should eq scope_identifier }
+        end
       end
     end
   end

data/spec/double_entry/configuration_spec.rb

@@ -5,6 +5,35 @@ describe DoubleEntry::Configuration do
   its(:accounts) { should be_a DoubleEntry::Account::Set }
   its(:transfers) { should be_a DoubleEntry::Transfer::Set }
 
+  describe "max lengths" do
+    context "given a max length has not been set" do
+      its(:code_max_length) { should be 47 }
+      its(:scope_identifier_max_length) { should be 23 }
+      its(:account_identifier_max_length) { should be 31 }
+    end
+
+    context "given a code max length of 10 has been set" do
+      before { subject.code_max_length = 10 }
+      its(:code_max_length) { should be 10 }
+    end
+
+    context "given a scope identifier max length of 11 has been set" do
+      before { subject.scope_identifier_max_length = 11 }
+      its(:scope_identifier_max_length) { should be 11 }
+    end
+
+    context "given an account identifier max length of 9 has been set" do
+      before { subject.account_identifier_max_length = 9 }
+      its(:account_identifier_max_length) { should be 9 }
+    end
+
+    after do
+      subject.code_max_length = nil
+      subject.scope_identifier_max_length = nil
+      subject.account_identifier_max_length = nil
+    end
+  end
+
   describe "#define_accounts" do
     it "yields the accounts set" do
       expect { |block|

data/spec/double_entry/line_spec.rb

@@ -6,7 +6,7 @@ describe DoubleEntry::Line do
   end
 
   describe "persistance" do
-    let(:persisted_line) {
+    let(:line_to_persist) {
       DoubleEntry::Line.new(
         :amount => Money.new(10_00),
         :balance => Money.zero,
@@ -18,11 +18,13 @@ describe DoubleEntry::Line do
     let(:account) { DoubleEntry.account(:test, :scope => "17") }
     let(:partner_account) { DoubleEntry.account(:test, :scope => "72") }
     let(:code) { :test_code }
-    subject { DoubleEntry::Line.last }
 
-    describe "attributes" do
-      before { persisted_line.save! }
+    subject(:persisted_line) do
+      line_to_persist.save!
+      line_to_persist.reload
+    end
 
+    describe "attributes" do
       context "given code = :the_code" do
         let(:code) { :the_code }
         its(:code) { should eq :the_code }
@@ -30,7 +32,7 @@ describe DoubleEntry::Line do
 
       context "given code = nil" do
         let(:code) { nil }
-        its(:code) { should eq nil }
+        specify { expect { line_to_persist.save! }.to raise_error }
       end
 
       context "given account = :test, 54 " do
@@ -52,22 +54,20 @@ describe DoubleEntry::Line do
       end
     end
 
-    describe '#save' do
-      context 'when balance is sent negative' do
-        let(:account) {
-          DoubleEntry.account(:savings, :scope => '17', :positive_only => true)
-        }
+    context 'when balance is sent negative' do
+      let(:account) {
+        DoubleEntry.account(:savings, :scope => '17', :positive_only => true)
+      }
 
-        let(:line) {
-          DoubleEntry::Line.new(
-            :balance => Money.new(-1),
-            :account => account,
-          )
-        }
+      let(:line) {
+        DoubleEntry::Line.new(
+          :balance => Money.new(-1),
+          :account => account,
+        )
+      }
 
-        it 'raises AccountWouldBeSentNegative exception' do
-          expect { line.save }.to raise_error DoubleEntry::AccountWouldBeSentNegative
-        end
+      it 'raises AccountWouldBeSentNegative exception' do
+        expect { line.save }.to raise_error DoubleEntry::AccountWouldBeSentNegative
       end
     end
 

data/spec/double_entry/locking_spec.rb

@@ -51,8 +51,20 @@ describe DoubleEntry::Locking do
   end
 
   it "takes the balance for new account balance records from the lines table" do
-    DoubleEntry::Line.create!(:account => @account_a, :partner_account => @account_b, :amount => Money.new(3_00), :balance => Money.new( 3_00), :code => :test)
-    DoubleEntry::Line.create!(:account => @account_a, :partner_account => @account_b, :amount => Money.new(7_00), :balance => Money.new(10_00), :code => :test)
+    DoubleEntry::Line.create!(
+      :account => @account_a,
+      :partner_account => @account_b,
+      :amount => Money.new(3_00),
+      :balance => Money.new(3_00),
+      :code => :test,
+    )
+    DoubleEntry::Line.create!(
+      :account => @account_a,
+      :partner_account => @account_b,
+      :amount => Money.new(7_00),
+      :balance => Money.new(10_00),
+      :code => :test,
+    )
 
     expect do
       DoubleEntry::Locking.lock_accounts(@account_a) { }

data/spec/double_entry/transfer_spec.rb

@@ -1,17 +1,38 @@
 # encoding: utf-8
 require 'spec_helper'
-describe DoubleEntry::Transfer::Set do
-  describe "#define" do
-    before do
-      subject.define(
-        :code => "code",
-        :from => double(:identifier => "from"),
-        :to => double(:identifier => "to"),
-      )
+module DoubleEntry
+  describe Transfer do
+
+    describe "::new" do
+      context "given a code 47 characters in length" do
+        let(:code) { "xxxxxxxxxxxxxxxx 47 characters xxxxxxxxxxxxxxxx" }
+        specify do
+          expect { Transfer.new(:code => code) }.to_not raise_error
+        end
+      end
+
+      context "given a code 48 characters in length" do
+        let(:code) { "xxxxxxxxxxxxxxxx 48 characters xxxxxxxxxxxxxxxxx" }
+        specify do
+          expect { Transfer.new(:code => code) }.to raise_error TransferCodeTooLongError, /'#{code}'/
+        end
+      end
+    end
+
+    describe Transfer::Set do
+      describe "#define" do
+        before do
+          subject.define(
+            :code => "code",
+            :from => double(:identifier => "from"),
+            :to => double(:identifier => "to"),
+          )
+        end
+        its(:first) { should be_a Transfer }
+        its("first.code") { should eq "code" }
+        its("first.from.identifier") { should eq "from" }
+        its("first.to.identifier") { should eq "to" }
+      end
     end
-    its(:first) { should be_a DoubleEntry::Transfer }
-    its("first.code") { should eq "code" }
-    its("first.from.identifier") { should eq "from" }
-    its("first.to.identifier") { should eq "to" }
   end
 end

data/spec/double_entry_spec.rb

@@ -173,9 +173,8 @@ describe DoubleEntry do
           accounts.define(:identifier => :b)
         end
 
-        description = ->(line) { "Money goes #{line.decrease? ? 'out' : 'in'}: #{line.amount.format}" }
         config.define_transfers do |transfers|
-          transfers.define(:code => :xfer, :from => :a, :to => :b, :description => description)
+          transfers.define(:code => :xfer, :from => :a, :to => :b)
         end
       end
 

data/spec/support/schema.rb

@@ -2,68 +2,63 @@ ActiveRecord::Schema.define do
   self.verbose = false
 
   create_table "double_entry_account_balances", :force => true do |t|
-    t.string   "account",    :null => false
-    t.string   "scope"
-    t.integer  "balance"
-    t.datetime "created_at"
-    t.datetime "updated_at"
+    t.string     "account", :limit => 31, :null => false
+    t.string     "scope",   :limit => 23
+    t.integer    "balance",               :null => false
+    t.timestamps
   end
 
-  add_index "double_entry_account_balances", ["account"], :name => "index_account_balances_on_account"
+  add_index "double_entry_account_balances", ["account"],          :name => "index_account_balances_on_account"
   add_index "double_entry_account_balances", ["scope", "account"], :name => "index_account_balances_on_scope_and_account", :unique => true
 
   create_table "double_entry_lines", :force => true do |t|
-    t.string   "account"
-    t.string   "scope"
-    t.string   "code"
-    t.integer  "amount"
-    t.integer  "balance"
-    t.integer  "partner_id"
-    t.string   "partner_account"
-    t.string   "partner_scope"
-    t.integer  "detail_id"
-    t.string   "detail_type"
-    t.datetime "created_at"
-    t.datetime "updated_at"
+    t.string     "account",         :limit => 31, :null => false
+    t.string     "scope",           :limit => 23
+    t.string     "code",            :limit => 47, :null => false
+    t.integer    "amount",                        :null => false
+    t.integer    "balance",                       :null => false
+    t.integer    "partner_id"
+    t.string     "partner_account", :limit => 31, :null => false
+    t.string     "partner_scope",   :limit => 23
+    t.integer    "detail_id"
+    t.string     "detail_type"
+    t.timestamps
   end
 
-  add_index "double_entry_lines", ["account", "code", "created_at"], :name => "lines_account_code_created_at_idx"
-  add_index "double_entry_lines", ["account", "created_at"], :name => "lines_account_created_at_idx"
+  add_index "double_entry_lines", ["account", "code", "created_at"],  :name => "lines_account_code_created_at_idx"
+  add_index "double_entry_lines", ["account", "created_at"],          :name => "lines_account_created_at_idx"
   add_index "double_entry_lines", ["scope", "account", "created_at"], :name => "lines_scope_account_created_at_idx"
-  add_index "double_entry_lines", ["scope", "account", "id"], :name => "lines_scope_account_id_idx"
+  add_index "double_entry_lines", ["scope", "account", "id"],         :name => "lines_scope_account_id_idx"
 
   create_table "double_entry_line_aggregates", :force => true do |t|
-    t.string   "function"
-    t.string   "account"
-    t.string   "code"
-    t.string   "scope"
-    t.integer  "year"
-    t.integer  "month"
-    t.integer  "week"
-    t.integer  "day"
-    t.integer  "hour"
-    t.integer  "amount"
-    t.datetime "created_at"
-    t.datetime "updated_at"
-    t.string   "filter"
-    t.string   "range_type"
+    t.string     "function",   :limit => 15, :null => false
+    t.string     "account",    :limit => 31, :null => false
+    t.string     "code",       :limit => 47
+    t.string     "scope",      :limit => 23
+    t.integer    "year"
+    t.integer    "month"
+    t.integer    "week"
+    t.integer    "day"
+    t.integer    "hour"
+    t.integer    "amount",                   :null => false
+    t.string     "filter"
+    t.string     "range_type", :limit => 15, :null => false
+    t.timestamps
   end
 
   add_index "double_entry_line_aggregates", ["function", "account", "code", "year", "month", "week", "day"], :name => "line_aggregate_idx"
 
   create_table "double_entry_line_checks", :force => true do |t|
-    t.integer  "last_line_id"
-    t.boolean  "errors_found"
-    t.text     "log"
-    t.datetime "created_at"
-    t.datetime "updated_at"
+    t.integer    "last_line_id", :null => false
+    t.boolean    "errors_found", :null => false
+    t.text       "log"
+    t.timestamps
   end
 
   # test table only
   create_table "users", :force => true do |t|
-    t.string   "username"
-    t.datetime "created_at"
-    t.datetime "updated_at"
+    t.string     "username", :null => false
+    t.timestamps
   end
 
   add_index "users", ["username"], :name => "index_users_on_username", :unique => true

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: double_entry
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Anthony Sellitti
@@ -15,7 +15,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-19 00:00:00.000000000 Z
+date: 2014-12-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: money