double_entry 0.0.1.pre → 0.1.0.pre.pre.alpha

data/lib/double_entry/version.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module DoubleEntry
-  VERSION = "0.0.1.pre"
+  VERSION = "0.1.0.pre-alpha"
 end

data/lib/double_entry/week_range.rb

@@ -0,0 +1,99 @@
+# encoding: utf-8
+module DoubleEntry
+  # We use a particularly crazy week numbering system: week 1 of any given year
+  # is the first week with any days that fall into that year.
+  #
+  # So, for example, week 1 of 2011 starts on 27 Dec 2010.
+  class WeekRange < TimeRange
+
+    class << self
+
+      def from_time(time)
+        time = time.to_time if time.is_a? Date
+        year = time.end_of_week.year
+        week = ((time.beginning_of_week - start_of_year(year)) / 1.week).floor + 1
+        new(:year => year, :week => week)
+      end
+
+      def current
+        from_time(Time.now)
+      end
+
+      # Obtain a sequence of WeekRanges from the given start to the current
+      # week.
+      #
+      # @option options :from [Time] Time of the first in the returned sequence
+      #   of WeekRanges.
+      # @return [Array<WeekRange>]
+      def reportable_weeks(options = {})
+        week = options[:from] ? from_time(options[:from]) : earliest_week
+        last_in_sequence = self.current
+        [week].tap do |weeks|
+          while week != last_in_sequence
+            week = week.next
+            weeks << week
+          end
+        end
+      end
+
+    private
+
+      def start_of_year(year)
+        Time.local(year, 1, 1).beginning_of_week
+      end
+
+      def earliest_week
+        from_time(DoubleEntry::Reporting.configuration.start_of_business)
+      end
+    end
+
+    attr_reader :year, :week
+
+    def initialize(options = {})
+      super options
+
+      if options.present?
+        @week = options[:week]
+
+        @start  = week_and_year_to_time(@week, @year)
+        @finish = @start.end_of_week
+
+        @start = earliest_week.start if options[:range_type] == :all_time
+      end
+    end
+
+    def previous
+      from_time(@start - 1.week)
+    end
+
+    def next
+      from_time(@start + 1.week)
+    end
+
+    def ==(other)
+      (self.week == other.week) && (self.year == other.year)
+    end
+
+    def all_time
+      self.class.new(:year => year, :week => week, :range_type => :all_time)
+    end
+
+    def to_s
+      "#{year}, Week #{week}"
+    end
+
+  private
+
+    def from_time(time)
+      self.class.from_time(time)
+    end
+
+    def earliest_week
+      self.class.send(:earliest_week)
+    end
+
+    def week_and_year_to_time(week, year)
+      self.class.send(:start_of_year, year) + (week - 1).weeks
+    end
+  end
+end

data/lib/double_entry/year_range.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+module DoubleEntry
+  class YearRange < TimeRange
+    attr_reader :year
+
+    def initialize(options)
+      super options
+
+      year_start = Time.local(@year, 1, 1)
+      @start = year_start
+      @finish = year_start.end_of_year
+    end
+
+    def self.current
+      YearRange.new(:year => Time.now.year)
+    end
+
+    def self.from_time(time)
+      YearRange.new(:year => time.year)
+    end
+
+    def ==(other)
+      self.year == other.year
+    end
+
+    def previous
+      YearRange.new(:year => year - 1)
+    end
+
+    def next
+      YearRange.new(:year => year + 1)
+    end
+
+    def to_s
+      year.to_s
+    end
+  end
+end

data/lib/generators/double_entry/install/install_generator.rb

@@ -0,0 +1,22 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+require 'rails/generators/active_record'
+
+module DoubleEntry
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+
+      source_root File.expand_path('../templates', __FILE__)
+
+      def self.next_migration_number(path)
+        ActiveRecord::Generators::Base.next_migration_number(path)
+      end
+
+      def copy_migrations
+        migration_template "migration.rb", "db/migrate/create_double_entry_tables.rb"
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+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.timestamps
+    end
+
+    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.string   "meta"
+      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", ["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"
+
+    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.timestamps
+      t.string   "filter"
+      t.string   "range_type"
+    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.timestamps
+    end
+
+  end
+
+  def self.down
+    drop_table "double_entry_line_checks"
+    drop_table "double_entry_line_aggregates"
+    drop_table "double_entry_lines"
+    drop_table "double_entry_account_balances"
+  end
+
+end

data/script/jack_hammer

@@ -0,0 +1,201 @@
+#!/usr/bin/env ruby
+
+# Run a concurrency test on the double_entry code.
+#
+# This spawns a bunch of processes, and does random transactions between a set
+# of accounts, then validates that all the numbers add up at the end.
+#
+# You can also tell out it to flush our the account balances table at regular
+# intervals, to validate that new account balances records get created with the
+# correct balances from the lines table.
+#
+# Run it without arguments to get the usage.
+
+require 'optparse'
+require 'bundler/setup'
+require 'active_record'
+require 'database_cleaner'
+
+support = File.expand_path("../../spec/support/", __FILE__)
+
+ENV['DB'] ||= 'mysql'
+ActiveRecord::Base.establish_connection YAML.load_file(File.join(support, "database.yml"))[ENV['DB']]
+require "#{support}/schema"
+
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'double_entry'
+
+def parse_options
+  $account_count       = 5
+  $process_count       = 20
+  $transfer_count      = 20000
+  $balance_flush_count = 1
+  $use_threads         = false
+
+  options = OptionParser.new
+
+  options.on("-a", "--accounts=COUNT", Integer, "Number of accounts (default: #{$account_count})") do |value|
+    $account_count = value
+  end
+
+  options.on("-p", "--processes=COUNT", Integer, "Number of processes (default: #{$process_count})") do |value|
+    $process_count = value
+  end
+
+  options.on("-t", "--transfers=COUNT", Integer, "Number of transfers (default: #{$transfer_count})") do |value|
+    $transfer_count = value
+  end
+
+  options.on("-f", "--flush-balances=COUNT", Integer, "Flush account balances table COUNT times") do |value|
+    $balance_flush_count = value
+  end
+
+  options.on("-z", "--threads", "Use threads instead of processes") do |value|
+    $use_threads = !!value
+  end
+
+  options.parse(*ARGV)
+end
+
+
+def clean_out_database
+  puts "Cleaning out the database..."
+
+  DatabaseCleaner.clean_with(:deletion)
+end
+
+def create_accounts_and_transfers
+  puts "Setting up #{$account_count} accounts..."
+
+  # Create the accounts.
+  scope = lambda {|x| x }
+  DoubleEntry.accounts = DoubleEntry::Account::Set.new
+  $account_count.times do |i|
+    DoubleEntry.accounts << DoubleEntry::Account.new(:identifier => :"account-#{i}", :scope_identifier => scope)
+  end
+
+  # Create all the possible transfers.
+  DoubleEntry.transfers = DoubleEntry::Transfer::Set.new
+  DoubleEntry.accounts.each do |from|
+    DoubleEntry.accounts.each do |to|
+      DoubleEntry.transfers << DoubleEntry::Transfer.new(:from => from.identifier, :to => to.identifier, :code => :test)
+    end
+  end
+
+  # Find account instances so we have something to work with.
+  $accounts = DoubleEntry.accounts.map do |account|
+    DoubleEntry.account(account.identifier, :scope => 1)
+  end
+end
+
+
+def run_tests
+  puts "Spawning #{$process_count} processes..."
+
+  iterations_per_process = $transfer_count / $process_count / $balance_flush_count
+
+  $balance_flush_count.times do
+    puts "Flushing balances"
+    DoubleEntry::AccountBalance.delete_all
+
+    if $use_threads
+      puts "Using threads as workers"
+      threads = []
+      $process_count.times do |process_num|
+        threads << Thread.new { run_process(iterations_per_process, process_num) }
+      end
+
+      threads.each(&:join)
+    else
+      puts "Using processes as workers"
+      pids = []
+      $process_count.times do |process_num|
+        pids << fork { run_process(iterations_per_process, process_num) }
+      end
+
+      pids.each {|pid| Process.wait2(pid) }
+    end
+
+    ActiveRecord::Base.connection_pool.disconnect!
+  end
+end
+
+
+def run_process(iterations, process_num)
+  ActiveRecord::Base.connection_pool.disconnect!  # Get a unique DB connection for this process.
+  srand  # Seed the random number generator separately for each process.
+
+  puts "Process #{process_num} running #{iterations} transfers..."
+
+  iterations.times do |i|
+    account_a = $accounts.sample
+    account_b = ($accounts - [account_a]).sample
+    amount = rand(1000) + 1
+
+    DoubleEntry.transfer(Money.new(amount), :from => account_a, :to => account_b, :code => :test)
+
+    puts "Process #{process_num} completed #{i+1} transfers" if (i+1) % 100 == 0
+  end
+end
+
+
+def reconcile
+  error_count = 0
+  puts "Reconciling..."
+
+  if DoubleEntry::Line.count == $transfer_count * 2
+    puts "All the Line records were written, FTW!"
+  else
+    puts "Not enough Line records written. :("
+    error_count += 1
+  end
+
+  if $accounts.all? {|account| DoubleEntry.reconciled?(account) }
+    puts "All accounts reconciled, FTW!"
+  else
+    $accounts.each do |account|
+      if !DoubleEntry.reconciled?(account)
+        puts "Account #{account.identifier} failed to reconcile. :("
+
+        # See http://bugs.mysql.com/bug.php?id=51431
+        use_index = if DoubleEntry::Line.connection.adapter_name.match /mysql/i
+                      "USE INDEX (lines_scope_account_id_idx)"
+                    else
+                      ""
+                    end
+
+        rows = ActiveRecord::Base.connection.select_all(<<-SQL)
+             SELECT id, amount, balance
+               FROM #{DoubleEntry::Line.quoted_table_name} #{use_index}
+              WHERE scope   = '#{account.scope_identity}'
+                AND account = '#{account.identifier}'
+           ORDER BY id
+        SQL
+
+        rows.each_cons(2) do |a, b|
+          if a["balance"].to_i + b["amount"].to_i != b["balance"].to_i
+            puts "Bad lines entry id = #{b['id']}"
+            error_count += 1
+          end
+        end
+      end
+    end
+  end
+
+  error_count == 0
+end
+
+
+parse_options
+clean_out_database
+create_accounts_and_transfers
+run_tests
+
+if reconcile
+  puts "Done successfully :)"
+  exit 0
+else
+  puts "Done with errors :("
+  exit 1
+end

data/script/setup.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+
+echo "This command will setup your local dev environment, including"
+echo "  * bundle install"
+echo
+
+echo "Bundling..."
+bundle install --binstubs bin --path .bundle