double_entry 2.0.0.beta1 → 2.0.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd62c2e42e510db804162a1de625cc123d04c65c6183eb1e1004061eef376e46
-  data.tar.gz: ffde728e5768509bd391e4056971dbb63128ad46ef02a9780497facaaa31415e
+  metadata.gz: 278a1d1188105e311363ff13e598a96bd3b2264fd4f2a0ce90ba75044b319f31
+  data.tar.gz: '0915d86b5e811c80920ece162e6901e8dcdafd2f3b170d3b41382302bc53b209'
 SHA512:
-  metadata.gz: 3c30e7b10ebeac99660c122ecedfafccbb115f36ed309e9a7c0b41bc122ea5a86d51baac92c28c0a5bcff4850b752fa7ffd356a94267812cb79fa4c7ef029bfd
-  data.tar.gz: 145104fb048131b5f49d075f9a8e0b94d6e5fd73c5450cad0b4bdf522ecc9f6c311571e809457017383fa4b0d4576859a3a3e4aa991ff45d672189fd9434ff46
+  metadata.gz: 411912d2abe22aa8ac019764cc61ddb001363c01e43dbfe10919081dd0526e7bc6d4c48bbac32316fc0e2bde19a608384b4e1a9675b2c9ec6dcfb9ebc71ef30a
+  data.tar.gz: 957dd450536552f43910024f48421b5af6ccda4ac905773efa447ec8e1e1f7b69231356621b691cab5af564d0472fa0037a4833f26d5bcd7539e71145e92fa06

data/CHANGELOG.md

@@ -7,6 +7,25 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ## [Unreleased]
 
+## [2.0.0.beta2] - 2019-01-27
+
+### Removed
+
+- Extract `DoubleEntry::Reporting` module to a separate gem:
+  [`double_entry-reporting`](https://github.com/envato/double_entry-reporting).
+
+  If this module is in use in your project add the `double_entry-reporting` gem
+  and checkout the
+  [changelog](https://github.com/envato/double_entry-reporting/blob/master/CHANGELOG.md)
+  for more updates.
+
+  If not in use, one can delete the `double_entry_line_aggregates` table using
+  the following migration:
+
+    ```ruby
+    drop_table :double_entry_line_aggregates
+    ```
+
 ## [2.0.0.beta1] - 2018-12-31
 
 ### Added

data/double_entry.gemspec

@@ -11,12 +11,13 @@ Gem::Specification.new do |gem|
   gem.email                 = ['rubygems@envato.com']
   gem.summary               = 'Tools to build your double entry financial ledger'
   gem.homepage              = 'https://github.com/envato/double_entry'
+  gem.license               = 'MIT'
 
   gem.metadata = {
     'bug_tracker_uri'   => 'https://github.com/envato/double_entry/issues',
-    'changelog_uri'     => 'https://github.com/envato/double_entry/blob/master/CHANGELOG.md',
-    'documentation_uri' => 'https://www.rubydoc.info/github/envato/double_entry/',
-    'source_code_uri'   => 'https://github.com/envato/double_entry',
+    'changelog_uri'     => "https://github.com/envato/double_entry/blob/v#{gem.version}/CHANGELOG.md",
+    'documentation_uri' => "https://www.rubydoc.info/gems/double_entry/#{gem.version}",
+    'source_code_uri'   => "https://github.com/envato/double_entry/tree/v#{gem.version}",
   }
 
   gem.files                 = `git ls-files -z`.split("\x0").select do |f|

data/lib/double_entry.rb

@@ -16,7 +16,6 @@ require 'double_entry/locking'
 require 'double_entry/transfer'
 require 'double_entry/line'
 require 'double_entry/line_metadata'
-require 'double_entry/reporting'
 require 'double_entry/validation'
 
 # Keep track of all the monies!

data/lib/double_entry/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module DoubleEntry
-  VERSION = '2.0.0.beta1'
+  VERSION = '2.0.0.beta2'
 end

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

@@ -30,24 +30,6 @@ class CreateDoubleEntryTables < ActiveRecord::Migration<%= migration_version %>
     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",   :limit => 15, :null => false
-      t.string     "account",                  :null => false
-      t.string     "code"
-      t.string     "scope"
-      t.integer    "year"
-      t.integer    "month"
-      t.integer    "week"
-      t.integer    "day"
-      t.integer    "hour"
-      t.bigint     "amount",                   :null => false
-      t.string     "filter"
-      t.string     "range_type", :limit => 15, :null => false
-      t.timestamps                             :null => false
-    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.references "last_line",    :null => false, :index => false
       t.boolean    "errors_found", :null => false
@@ -70,7 +52,6 @@ class CreateDoubleEntryTables < ActiveRecord::Migration<%= migration_version %>
   def self.down
     drop_table "double_entry_line_metadata"
     drop_table "double_entry_line_checks"
-    drop_table "double_entry_line_aggregates"
     drop_table "double_entry_lines"
     drop_table "double_entry_account_balances"
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: double_entry
 version: !ruby/object:Gem::Version
-  version: 2.0.0.beta1
+  version: 2.0.0.beta2
 platform: ruby
 authors:
 - Envato
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-31 00:00:00.000000000 Z
+date: 2019-01-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -243,19 +243,6 @@ files:
 - lib/double_entry/line.rb
 - lib/double_entry/line_metadata.rb
 - lib/double_entry/locking.rb
-- lib/double_entry/reporting.rb
-- lib/double_entry/reporting/aggregate.rb
-- lib/double_entry/reporting/aggregate_array.rb
-- lib/double_entry/reporting/day_range.rb
-- lib/double_entry/reporting/hour_range.rb
-- lib/double_entry/reporting/line_aggregate.rb
-- lib/double_entry/reporting/line_aggregate_filter.rb
-- lib/double_entry/reporting/line_metadata_filter.rb
-- lib/double_entry/reporting/month_range.rb
-- lib/double_entry/reporting/time_range.rb
-- lib/double_entry/reporting/time_range_array.rb
-- lib/double_entry/reporting/week_range.rb
-- lib/double_entry/reporting/year_range.rb
 - lib/double_entry/transfer.rb
 - lib/double_entry/validation.rb
 - lib/double_entry/validation/account_fixer.rb
@@ -264,12 +251,13 @@ files:
 - lib/generators/double_entry/install/install_generator.rb
 - lib/generators/double_entry/install/templates/migration.rb
 homepage: https://github.com/envato/double_entry
-licenses: []
+licenses:
+- MIT
 metadata:
   bug_tracker_uri: https://github.com/envato/double_entry/issues
-  changelog_uri: https://github.com/envato/double_entry/blob/master/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/github/envato/double_entry/
-  source_code_uri: https://github.com/envato/double_entry
+  changelog_uri: https://github.com/envato/double_entry/blob/v2.0.0.beta2/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/double_entry/2.0.0.beta2
+  source_code_uri: https://github.com/envato/double_entry/tree/v2.0.0.beta2
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -285,8 +273,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.2
 signing_key: 
 specification_version: 4
 summary: Tools to build your double entry financial ledger

data/lib/double_entry/reporting.rb

@@ -1,169 +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/line_metadata_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] range Only include transfers in
-    #   the given time range in the calculation.
-    # @param [Symbol] partner_account The symbol identifying the partner account
-    #   to perform the aggregate calculatoin on.  As specified in the account
-    #   configuration.
-    # @param [Array<Hash<Symbol,Hash<Symbol,Object>>>] filter
-    #   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, Integer] Returns a Money object for :sum and :average
-    #   calculations, or a Integer for :count calculations.
-    # @raise [Reporting::AggregateFunctionNotSupported] The provided function
-    #   is not supported.
-    #
-    def aggregate(function:, account:, code:, range:, partner_account: nil, filter: nil)
-      Aggregate.formatted_amount(function: function, account: account, code: code, range: range,
-                                 partner_account: partner_account, filter: filter)
-    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.
-    # @param [Symbol] partner_account The symbol identifying the partner account
-    #   to perform the aggregative calculation on.  As specified in the account
-    #   configuration.
-    # @param [Array<Symbol>, Array<Hash<Symbol, Object>>] filter
-    #   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.
-    # @param [String] range_type 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'
-    # @param [String] start 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'
-    # @param [String] finish 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, Integer>] Returns an array of Money objects for :sum
-    #   and :average calculations, or an array of Integer 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:, partner_account: nil, filter: nil,
-                        range_type: nil, start: nil, finish: nil)
-      AggregateArray.new(function: function, account: account, code: code, partner_account: partner_account,
-                         filter: filter, range_type: range_type, start: start, finish: finish)
-    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,130 +0,0 @@
-# encoding: utf-8
-module DoubleEntry
-  module Reporting
-    class Aggregate
-      attr_reader :function, :account, :partner_account, :code, :range, :filter, :currency
-
-      def self.formatted_amount(function:, account:, code:, range:, partner_account: nil, filter: nil)
-        new(
-          function: function,
-          account: account,
-          code: code,
-          range: range,
-          partner_account: partner_account,
-          filter: filter,
-        ).formatted_amount
-      end
-
-      def initialize(function:, account:, code:, range:, partner_account: nil, filter: nil)
-        @function = function.to_s
-        fail AggregateFunctionNotSupported unless %w(sum count average).include?(@function)
-
-        @account         = account
-        @code            = code.try(:to_s)
-        @range           = range
-        @partner_account = partner_account
-        @filter          = 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: function,
-            account: account,
-            partner_account: partner_account,
-            code: code,
-            range: range,
-            named_scopes: 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: function, account: account, code: code,
-                                  range: MonthRange.new(:year => range.year, :month => month),
-                                  partner_account: partner_account, 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(function: :sum, account: account, code: code, range: year_range,
-                            partner_account: partner_account, filter: filter).formatted_amount
-        count = Aggregate.new(function: :count, account: account, code: code, range: year_range,
-                              partner_account: partner_account, 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,
-          :partner_account => partner_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,79 +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, :partner_account, :code, :filter, :range_type, :start, :finish, :currency
-
-      def initialize(function:, account:, code:, partner_account: nil, filter: nil, range_type: nil, start: nil, finish: nil)
-        @function        = function.to_s
-        @account         = account
-        @code            = code
-        @partner_account = partner_account
-        @filter          = filter
-        @range_type      = range_type
-        @start           = start
-        @finish          = 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: function, account: account, code: code,
-                                                                 range: period, partner_account: partner_account, 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.try(:to_s)).
-                where(:partner_account => partner_account.try(:to_s)).
-                where(:code => code.try(: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

data/lib/double_entry/reporting/day_range.rb

@@ -1,42 +0,0 @@
-# encoding: utf-8
-module DoubleEntry
-  module Reporting
-    class DayRange < TimeRange
-      attr_reader :year, :week, :day
-
-      def initialize(options)
-        super options
-
-        @week = options[:week]
-        @day = options[:day]
-        week_range = WeekRange.new(options)
-
-        @start = week_range.start + (options[:day] - 1).days
-        @finish = @start.end_of_day
-      end
-
-      def self.from_time(time)
-        week_range = WeekRange.from_time(time)
-        DayRange.new(:year => week_range.year, :week => week_range.week, :day => time.wday == 0 ? 7 : time.wday)
-      end
-
-      def previous
-        DayRange.from_time(@start - 1.day)
-      end
-
-      def next
-        DayRange.from_time(@start + 1.day)
-      end
-
-      def ==(other)
-        week == other.week &&
-          year == other.year &&
-          day == other.day
-      end
-
-      def to_s
-        start.strftime('%Y, %a %b %d')
-      end
-    end
-  end
-end

data/lib/double_entry/reporting/hour_range.rb

@@ -1,45 +0,0 @@
-# encoding: utf-8
-module DoubleEntry
-  module Reporting
-    class HourRange < TimeRange
-      attr_reader :year, :week, :day, :hour
-
-      def initialize(options)
-        super options
-
-        @week = options[:week]
-        @day = options[:day]
-        @hour = options[:hour]
-
-        day_range = DayRange.new(options)
-
-        @start = day_range.start + options[:hour].hours
-        @finish = @start.end_of_hour
-      end
-
-      def self.from_time(time)
-        day = DayRange.from_time(time)
-        HourRange.new :year => day.year, :week => day.week, :day => day.day, :hour => time.hour
-      end
-
-      def previous
-        HourRange.from_time(@start - 1.hour)
-      end
-
-      def next
-        HourRange.from_time(@start + 1.hour)
-      end
-
-      def ==(other)
-        week == other.week &&
-          year == other.year &&
-          day == other.day &&
-          hour == other.hour
-      end
-
-      def to_s
-        "#{start.hour}:00:00 - #{start.hour}:59:59"
-      end
-    end
-  end
-end

data/lib/double_entry/reporting/line_aggregate.rb

@@ -1,17 +0,0 @@
-# encoding: utf-8
-module DoubleEntry
-  module Reporting
-    class LineAggregate < ActiveRecord::Base
-      def self.aggregate(function:, account:, partner_account:, code:, range:, named_scopes:)
-        collection_filter = LineAggregateFilter.new(account: account, partner_account: partner_account,
-                                                    code: code, range: range, filter_criteria: named_scopes)
-        collection = collection_filter.filter
-        collection.send(function, :amount)
-      end
-
-      def key
-        "#{year}:#{month}:#{week}:#{day}:#{hour}"
-      end
-    end
-  end
-end

data/lib/double_entry/reporting/line_aggregate_filter.rb

@@ -1,77 +0,0 @@
-# encoding: utf-8
-module DoubleEntry
-  module Reporting
-    class LineAggregateFilter
-
-      def initialize(account:, partner_account:, code:, range:, filter_criteria:)
-        @account         = account
-        @partner_account = partner_account
-        @code            = code
-        @range           = range
-        @filter_criteria = filter_criteria || []
-      end
-
-      def filter
-        @collection ||= apply_filters
-      end
-
-    private
-
-      def apply_filters
-        collection = apply_filter_criteria.
-                     where(:account => @account).
-                     where(:created_at => @range.start..@range.finish)
-        collection = collection.where(:code => @code) if @code
-        collection = collection.where(:partner_account => @partner_account) if @partner_account
-
-        collection
-      end
-
-      # a lot of the trickier reports will use filters defined
-      # in filter_criteria to bring in data from other tables.
-      # For example:
-      #
-      #   filter_criteria = [
-      #     # an example of calling a named scope called with arguments
-      #     {
-      #       :scope => {
-      #         :name => :ten_dollar_purchases_by_category,
-      #         :arguments => [:cat_videos, :cat_pictures]
-      #       }
-      #     },
-      #     # an example of calling a named scope with no arguments
-      #     {
-      #       :scope => {
-      #         :name => :ten_dollar_purchases
-      #       }
-      #     },
-      #     # an example of providing multiple metadatum criteria to filter on
-      #     {
-      #       :metadata => {
-      #         :meme => :business_cat,
-      #         :category => :fun_times,
-      #       }
-      #     }
-      #   ]
-      def apply_filter_criteria
-        @filter_criteria.reduce(DoubleEntry::Line) do |collection, filter|
-          if filter[:scope].present?
-            filter_by_scope(collection, filter[:scope])
-          elsif filter[:metadata].present?
-            filter_by_metadata(collection, filter[:metadata])
-          else
-            collection
-          end
-        end
-      end
-
-      def filter_by_scope(collection, scope)
-        collection.public_send(scope[:name], *scope[:arguments])
-      end
-
-      def filter_by_metadata(collection, metadata)
-        DoubleEntry::Reporting::LineMetadataFilter.filter(collection: collection, metadata: metadata)
-      end
-    end
-  end
-end

data/lib/double_entry/reporting/line_metadata_filter.rb

@@ -1,33 +0,0 @@
-# encoding: utf-8
-module DoubleEntry
-  module Reporting
-    class LineMetadataFilter
-
-      def self.filter(collection:, metadata:)
-        table_alias_index = 0
-
-        metadata.reduce(collection) do |filtered_collection, (key, value)|
-          table_alias = "m#{table_alias_index}"
-          table_alias_index += 1
-
-          filtered_collection.
-            joins("INNER JOIN #{line_metadata_table} as #{table_alias} ON #{table_alias}.line_id = #{lines_table}.id").
-            where("#{table_alias}.key = ? AND #{table_alias}.value = ?", key, value)
-        end
-      end
-
-    private
-
-      def self.line_metadata_table
-        DoubleEntry::LineMetadata.table_name
-      end
-      private_class_method :line_metadata_table
-
-      def self.lines_table
-        DoubleEntry::Line.table_name
-      end
-      private_class_method :lines_table
-
-    end
-  end
-end

data/lib/double_entry/reporting/month_range.rb

@@ -1,94 +0,0 @@
-# encoding: utf-8
-module DoubleEntry
-  module Reporting
-    class MonthRange < TimeRange
-      class << self
-        def from_time(time)
-          new(:year => time.year, :month => time.month)
-        end
-
-        def current
-          from_time(Time.now)
-        end
-
-        # Obtain a sequence of MonthRanges from the given start to the current
-        # month.
-        #
-        # @option options :from [Time] Time of the first in the returned sequence
-        #   of MonthRanges.
-        # @return [Array<MonthRange>]
-        def reportable_months(options = {})
-          month = options[:from] ? from_time(options[:from]) : earliest_month
-          last = current
-          [month].tap do |months|
-            while month != last
-              month = month.next
-              months << month
-            end
-          end
-        end
-
-        def earliest_month
-          from_time(Reporting.configuration.start_of_business)
-        end
-      end
-
-      attr_reader :year, :month
-
-      def initialize(options = {})
-        super options
-
-        if options.present?
-          @month = options[:month]
-
-          month_start = Time.local(year, options[:month], 1)
-          @start = month_start
-          @finish = month_start.end_of_month
-
-          @start = MonthRange.earliest_month.start if options[:range_type] == :all_time
-        end
-      end
-
-      def previous
-        if month <= 1
-          MonthRange.new :year => year - 1, :month => 12
-        else
-          MonthRange.new :year => year, :month => month - 1
-        end
-      end
-
-      def next
-        if month >= 12
-          MonthRange.new :year => year + 1, :month => 1
-        else
-          MonthRange.new :year => year, :month => month + 1
-        end
-      end
-
-      def beginning_of_financial_year
-        first_month_of_financial_year = Reporting.configuration.first_month_of_financial_year
-        year = (month >= first_month_of_financial_year) ? @year : (@year - 1)
-        MonthRange.new(:year => year, :month => first_month_of_financial_year)
-      end
-
-      alias_method :succ, :next
-
-      def <=>(other)
-        start <=> other.start
-      end
-
-      def ==(other)
-        month == other.month &&
-          year == other.year
-      end
-
-      def all_time
-        MonthRange.new(:year => year, :month => month, :range_type => :all_time)
-      end
-
-      def to_s
-        start.strftime('%Y, %b')
-      end
-    end
-  end
-end

data/lib/double_entry/reporting/time_range.rb

@@ -1,59 +0,0 @@
-# encoding: utf-8
-module DoubleEntry
-  module Reporting
-    class TimeRange
-      attr_reader :start, :finish
-      attr_reader :year, :month, :week, :day, :hour, :range_type
-
-      def self.make(options = {})
-        @options = options
-        case
-        when options[:year] && options[:week] && options[:day] && options[:hour]
-          HourRange.new(options)
-        when options[:year] && options[:week] && options[:day]
-          DayRange.new(options)
-        when options[:year] && options[:week]
-          WeekRange.new(options)
-        when options[:year] && options[:month]
-          MonthRange.new(options)
-        when options[:year]
-          YearRange.new(options)
-        else
-          fail "Invalid range information #{options}"
-        end
-      end
-
-      def self.range_from_time_for_period(start_time, period_name)
-        case period_name
-        when 'month'
-          YearRange.from_time(start_time)
-        when 'week'
-          YearRange.from_time(start_time)
-        when 'day'
-          MonthRange.from_time(start_time)
-        when 'hour'
-          DayRange.from_time(start_time)
-        end
-      end
-
-      def include?(time)
-        time >= @start &&
-          time <= @finish
-      end
-
-      def initialize(options)
-        @year = options[:year]
-        @range_type = options[:range_type] || :normal
-        @month = @week = @day = @hour = nil
-      end
-
-      def key
-        "#{@year}:#{@month}:#{@week}:#{@day}:#{@hour}"
-      end
-
-      def human_readable_name
-        self.class.name.gsub('DoubleEntry::Reporting::', '').gsub('Range', '')
-      end
-    end
-  end
-end

data/lib/double_entry/reporting/time_range_array.rb

@@ -1,49 +0,0 @@
-# encoding: utf-8
-module DoubleEntry
-  module Reporting
-    class TimeRangeArray
-      attr_reader :type, :require_start
-      alias_method :require_start?, :require_start
-
-      def initialize(options = {})
-        @type = options[:type]
-        @require_start = options[:require_start]
-      end
-
-      def make(start = nil, finish = nil)
-        start = start_range(start)
-        finish = finish_range(finish)
-        [start].tap do |array|
-          while start != finish
-            start = start.next
-            array << start
-          end
-        end
-      end
-
-      def start_range(start = nil)
-        fail 'Must specify start of range' if start.blank? && require_start?
-        start_time = start ? Time.parse(start) : Reporting.configuration.start_of_business
-        type.from_time(start_time)
-      end
-
-      def finish_range(finish = nil)
-        finish ? type.from_time(Time.parse(finish)) : type.current
-      end
-
-      FACTORIES = {
-        'hour'  => new(:type => HourRange,  :require_start => true),
-        'day'   => new(:type => DayRange,   :require_start => true),
-        'week'  => new(:type => WeekRange,  :require_start => true),
-        'month' => new(:type => MonthRange, :require_start => false),
-        'year'  => new(:type => YearRange,  :require_start => false),
-      }
-
-      def self.make(range_type, start = nil, finish = nil)
-        factory = FACTORIES[range_type]
-        fail ArgumentError, "Invalid range type '#{range_type}'" unless factory
-        factory.make(start, finish)
-      end
-    end
-  end
-end

data/lib/double_entry/reporting/week_range.rb

@@ -1,107 +0,0 @@
-# encoding: utf-8
-module DoubleEntry
-  module Reporting
-    # 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)
-          date = time.to_date
-          week = date.cweek
-          year = date.end_of_week.year
-
-          if date.beginning_of_week.year != year
-            week = 1
-          elsif date.beginning_of_year.cwday > Date::DAYNAMES.index('Thursday')
-            week += 1
-          end
-
-          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 = 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(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)
-        week == other.week &&
-          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
-end

data/lib/double_entry/reporting/year_range.rb

@@ -1,40 +0,0 @@
-# encoding: utf-8
-module DoubleEntry
-  module Reporting
-    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
-        new(:year => Time.now.year)
-      end
-
-      def self.from_time(time)
-        new(:year => time.year)
-      end
-
-      def ==(other)
-        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
-end