double_entry 1.0.1 → 2.0.0.beta5

data/.gitignore

@@ -1,32 +0,0 @@
-*.gem
-*.rbc
-/.config
-/coverage/
-/InstalledFiles
-/pkg/
-/spec/reports/
-/test/tmp/
-/test/version_tmp/
-/tmp/
-
-## Performance profiling
-/profiles/
-
-## Documentation cache and generated files:
-/.yardoc/
-/_yardoc/
-/doc/
-/rdoc/
-
-## Environment normalisation:
-/.bundle/
-/lib/bundler/man/
-/Gemfile.lock
-/.ruby-version
-/.ruby-gemset
-
-# DoubleEntry specific
-/bin/
-/log/
-/spec/reports/
-/spec/support/database.yml

data/.rspec

@@ -1,2 +0,0 @@
---color
---require spec_helper

data/.travis.yml

@@ -1,29 +0,0 @@
-language: ruby
-sudo: false
-before_script:
-  - cp spec/support/database.travis.yml spec/support/database.yml
-  - mysql -e 'create database double_entry_test;'
-  - psql -c 'create database double_entry_test;' -U postgres
-script:
-  - bundle exec rake spec
-  - ruby script/jack_hammer -t 2000
-matrix:
-  include:
-    - rvm: 2.1
-      gemfile: spec/support/gemfiles/Gemfile.rails-3.2.x
-      env: DB=mysql
-    - rvm: 2.2
-      gemfile: spec/support/gemfiles/Gemfile.rails-4.1.x
-      env: DB=mysql
-    - rvm: 2.2
-      gemfile: spec/support/gemfiles/Gemfile.rails-4.2.x
-      env: DB=mysql
-    - rvm: 2.3
-      gemfile: spec/support/gemfiles/Gemfile.rails-5.0.x
-      env: DB=mysql
-    - rvm: 2.3
-      gemfile: spec/support/gemfiles/Gemfile.rails-5.0.x
-      env: DB=sqlite
-    - rvm: 2.3
-      gemfile: spec/support/gemfiles/Gemfile.rails-5.0.x
-      env: DB=postgres

data/.yardopts

@@ -1,2 +0,0 @@
---markup markdown
-- LICENSE.md

data/Gemfile

@@ -1,2 +0,0 @@
-source 'https://rubygems.org'
-gemspec

data/Rakefile

@@ -1,15 +0,0 @@
-require 'rspec/core/rake_task'
-require 'bundler/gem_tasks'
-
-RSpec::Core::RakeTask.new(:spec) do |t|
-  t.verbose = false
-  t.ruby_opts = '-w'
-end
-
-task :default do
-  %w(mysql postgres sqlite).each do |db|
-    puts "Running tests with `DB=#{db}`"
-    ENV['DB'] = db
-    Rake::Task['spec'].execute
-  end
-end

data/lib/double_entry/reporting.rb

@@ -1,181 +0,0 @@
-# encoding: utf-8
-require 'double_entry/reporting/aggregate'
-require 'double_entry/reporting/aggregate_array'
-require 'double_entry/reporting/time_range'
-require 'double_entry/reporting/day_range'
-require 'double_entry/reporting/hour_range'
-require 'double_entry/reporting/week_range'
-require 'double_entry/reporting/month_range'
-require 'double_entry/reporting/year_range'
-require 'double_entry/reporting/line_aggregate'
-require 'double_entry/reporting/line_aggregate_filter'
-require 'double_entry/reporting/time_range_array'
-
-module DoubleEntry
-  # @api private
-  module Reporting
-    include Configurable
-    extend self
-
-    class Configuration
-      attr_accessor :start_of_business, :first_month_of_financial_year
-
-      def initialize #:nodoc:
-        @start_of_business = Time.new(1970, 1, 1)
-        @first_month_of_financial_year = 7
-      end
-    end
-
-    class AggregateFunctionNotSupported < RuntimeError; end
-
-    # Perform an aggregate calculation on a set of transfers for an account.
-    #
-    # The transfers included in the calculation can be limited by time range
-    # and provided custom filters.
-    #
-    # @example Find the sum for all $10 :save transfers in all :checking accounts in the current month, made by Australian users (assume the date is January 30, 2014).
-    #   time_range = DoubleEntry::Reporting::TimeRange.make(2014, 1)
-    #
-    #   DoubleEntry::Line.class_eval do
-    #     scope :specific_transfer_amount, ->(amount) { where(:amount => amount.fractional) }
-    #   end
-    #
-    #   DoubleEntry::Reporting.aggregate(
-    #     :sum,
-    #     :checking,
-    #     :save,
-    #     time_range,
-    #     :filter => [
-    #       :scope    => {
-    #         :name      => :specific_transfer_amount,
-    #         :arguments => [Money.new(10_00)]
-    #       },
-    #       :metadata => {
-    #         :user_location => 'AU'
-    #       },
-    #     ]
-    #   )
-    # @param [Symbol] function The function to perform on the set of transfers.
-    #   Valid functions are :sum, :count, and :average
-    # @param [Symbol] account The symbol identifying the account to perform
-    #   the aggregate calculation on. As specified in the account configuration.
-    # @param [Symbol] code The application specific code for the type of
-    #   transfer to perform an aggregate calculation on. As specified in the
-    #   transfer configuration.
-    # @param [DoubleEntry::Reporting::TimeRange] Only include transfers in the
-    #   given time range in the calculation.
-    # @option options :filter [Array<Hash<Symbol,Hash<Symbol,Object>>>]
-    #   An array of custom filter to apply before performing the aggregate
-    #   calculation. Filters can be either scope filters, where the name must be
-    #   specified, or they can be metadata filters, where the key/value pair to
-    #   match on must be specified.
-    #   Scope filters must be monkey patched as scopes into the DoubleEntry::Line
-    #   class, as the example above shows. Scope filters may also take a list of
-    #   arguments to pass into the monkey patched scope, and, if provided, must
-    #   be contained within an array.
-    # @return [Money, Fixnum] Returns a Money object for :sum and :average
-    #   calculations, or a Fixnum for :count calculations.
-    # @raise [Reporting::AggregateFunctionNotSupported] The provided function
-    #   is not supported.
-    #
-    def aggregate(function, account, code, range, options = {})
-      Aggregate.formatted_amount(function, account, code, range, options)
-    end
-
-    # Perform an aggregate calculation on a set of transfers for an account
-    # and return the results in an array partitioned by a time range type.
-    #
-    # The transfers included in the calculation can be limited by a time range
-    # and provided custom filters.
-    #
-    # @example Find the number of all $10 :save transfers in all :checking accounts per month for the entire year (Assume the year is 2014).
-    #   DoubleEntry::Reporting.aggregate_array(
-    #     :sum,
-    #     :checking,
-    #     :save,
-    #     :range_type => 'month',
-    #     :start      => '2014-01-01',
-    #     :finish     => '2014-12-31',
-    #   )
-    # @param [Symbol] function The function to perform on the set of transfers.
-    #   Valid functions are :sum, :count, and :average
-    # @param [Symbol] account The symbol identifying the account to perform
-    #   the aggregate calculation on. As specified in the account configuration.
-    # @param [Symbol] code The application specific code for the type of
-    #   transfer to perform an aggregate calculation on. As specified in the
-    #   transfer configuration.
-    # @option options :filter [Array<Symbol>, Array<Hash<Symbol, Object>>]
-    #   A custom filter to apply before performing the aggregate calculation.
-    #   Currently, filters must be monkey patched as scopes into the
-    #   DoubleEntry::Line class in order to be used as filters, as the example
-    #   shows. If the filter requires a parameter, it must be given in a Hash,
-    #   otherwise pass an array with the symbol names for the defined scopes.
-    # @option options :range_type [String] The type of time range to return data
-    #   for.  For example, specifying 'month' will return an array of the resulting
-    #   aggregate calculation for each month.
-    #   Valid range_types are 'hour', 'day', 'week', 'month', and 'year'
-    # @option options :start [String] The start date for the time range to perform
-    #   calculations in.  The default start date is the start_of_business (can
-    #   be specified in configuration).
-    #   The format of the string must be as follows: 'YYYY-mm-dd'
-    # @option options :finish [String] The finish (or end) date for the time range
-    #   to perform calculations in.  The default finish date is the current date.
-    #   The format of the string must be as follows: 'YYYY-mm-dd'
-    # @return [Array<Money, Fixnum>] Returns an array of Money objects for :sum
-    #   and :average calculations, or an array of Fixnum for :count calculations.
-    #   The array is indexed by the range_type.  For example, if range_type is
-    #   specified as 'month', each index in the array will represent a month.
-    # @raise [Reporting::AggregateFunctionNotSupported] The provided function
-    #   is not supported.
-    #
-    def aggregate_array(function, account, code, options = {})
-      AggregateArray.new(function, account, code, options)
-    end
-
-    # Identify the scopes with the given account identifier holding at least
-    # the provided minimum balance.
-    #
-    # @example Find users with at least $1,000,000 in their savings accounts
-    #   DoubleEntry::Reporting.scopes_with_minimum_balance_for_account(
-    #     1_000_000.dollars,
-    #     :savings,
-    #   ) # might return the user ids: [ 1423, 12232, 34729 ]
-    # @param [Money] minimum_balance Minimum account balance a scope must have
-    #   to be included in the result set.
-    # @param [Symbol] account_identifier
-    # @return [Array<Fixnum>] Scopes
-    #
-    def scopes_with_minimum_balance_for_account(minimum_balance, account_identifier)
-      select_values(sanitize_sql_array([<<-SQL, account_identifier, minimum_balance.cents])).map(&:to_i)
-        SELECT scope
-          FROM #{AccountBalance.table_name}
-         WHERE account = ?
-           AND balance >= ?
-      SQL
-    end
-
-    # This is used by the concurrency test script.
-    #
-    # @api private
-    # @return [Boolean] true if all the amounts for an account add up to the final balance,
-    #   which they always should.
-    #
-    def reconciled?(account)
-      scoped_lines = Line.where(:account => "#{account.identifier}")
-      scoped_lines = scoped_lines.where(:scope => "#{account.scope_identity}") if account.scoped?
-      sum_of_amounts = scoped_lines.sum(:amount)
-      final_balance  = scoped_lines.order(:id).last[:balance]
-      cached_balance = AccountBalance.find_by_account(account)[:balance]
-      final_balance == sum_of_amounts && final_balance == cached_balance
-    end
-
-  private
-
-    delegate :connection, :to => ActiveRecord::Base
-    delegate :select_values, :to => :connection
-
-    def sanitize_sql_array(sql_array)
-      ActiveRecord::Base.send(:sanitize_sql_array, sql_array)
-    end
-  end
-end

data/lib/double_entry/reporting/aggregate.rb

@@ -1,110 +0,0 @@
-# encoding: utf-8
-module DoubleEntry
-  module Reporting
-    class Aggregate
-      attr_reader :function, :account, :code, :range, :filter, :currency
-
-      def self.formatted_amount(function, account, code, range, options = {})
-        new(function, account, code, range, options).formatted_amount
-      end
-
-      def initialize(function, account, code, range, options = {})
-        @function = function.to_s
-        fail AggregateFunctionNotSupported unless %w(sum count average).include?(@function)
-
-        @account = account
-        @code = code ? code.to_s : nil
-        @range = range
-        @filter = options[:filter]
-        @currency = DoubleEntry::Account.currency(account)
-      end
-
-      def amount(force_recalculation = false)
-        if force_recalculation
-          clear_old_aggregates
-          calculate
-        else
-          retrieve || calculate
-        end
-      end
-
-      def formatted_amount(value = amount)
-        value ||= 0
-        if function == 'count'
-          value
-        else
-          Money.new(value, currency)
-        end
-      end
-
-    private
-
-      def retrieve
-        aggregate = LineAggregate.where(field_hash).first
-        aggregate.amount if aggregate
-      end
-
-      def clear_old_aggregates
-        LineAggregate.delete_all(field_hash)
-      end
-
-      def calculate
-        if range.class == YearRange
-          aggregate = calculate_yearly_aggregate
-        else
-          aggregate = LineAggregate.aggregate(function, account, code, range, filter)
-        end
-
-        if range_is_complete?
-          fields = field_hash
-          fields[:amount] = aggregate || 0
-          LineAggregate.create! fields
-        end
-
-        aggregate
-      end
-
-      def calculate_yearly_aggregate
-        # We calculate yearly aggregates by combining monthly aggregates
-        # 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
-        if function == 'average'
-          calculate_yearly_average
-        else
-          result = (1..12).inject(formatted_amount(0)) do |total, month|
-            total + Aggregate.new(function, account, code, MonthRange.new(:year => range.year, :month => month), :filter => filter).formatted_amount
-          end
-          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
-        year_range = YearRange.new(:year => range.year)
-        sum = Aggregate.new(:sum, account, code, year_range, :filter => filter).formatted_amount
-        count = Aggregate.new(:count, account, code, year_range, :filter => filter).formatted_amount
-        (count == 0) ? 0 : (sum / count).cents
-      end
-
-      def range_is_complete?
-        Time.now > range.finish
-      end
-
-      def field_hash
-        {
-          :function => function,
-          :account => account,
-          :code => code,
-          :year => range.year,
-          :month => range.month,
-          :week => range.week,
-          :day => range.day,
-          :hour => range.hour,
-          :filter => filter.inspect,
-          :range_type => range.range_type.to_s,
-        }
-      end
-    end
-  end
-end

data/lib/double_entry/reporting/aggregate_array.rb

@@ -1,76 +0,0 @@
-# encoding: utf-8
-module DoubleEntry
-  module Reporting
-    class AggregateArray < Array
-      # An AggregateArray is awesome
-      # It is useful for making reports
-      # It is basically an array of aggregate results,
-      # representing a column of data in a report.
-      #
-      # 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, :currency
-
-      def initialize(function, account, code, options)
-        @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
-        populate_self
-      end
-
-    private
-
-      def populate_self
-        all_periods.each do |period|
-          self << @aggregates[period.key]
-        end
-      end
-
-      def fill_in_missing_aggregates
-        # some aggregates may not have been previously calculated, so we can request them now
-        # (this includes aggregates for the still-running period)
-        all_periods.each do |period|
-          unless @aggregates[period.key]
-            @aggregates[period.key] = Aggregate.formatted_amount(function, account, code, period, :filter => filter)
-          end
-        end
-      end
-
-      # get any previously calculated aggregates
-      def retrieve_aggregates
-        fail ArgumentError, "Invalid range type '#{range_type}'" unless %w(year month week day hour).include? range_type
-        scope = LineAggregate.
-                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))
-        @aggregates = scope.each_with_object({}) do |result, hash|
-          hash[result.key] = formatted_amount(result.amount)
-        end
-      end
-
-      def all_periods
-        TimeRangeArray.make(range_type, start, finish)
-      end
-
-      def formatted_amount(amount)
-        amount ||= 0
-        if function == 'count'
-          amount
-        else
-          Money.new(amount, currency)
-        end
-      end
-    end
-  end
-end