double_entry 1.0.1 → 2.0.0.beta5

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,16 +0,0 @@
-# encoding: utf-8
-module DoubleEntry
-  module Reporting
-    class LineAggregate < ActiveRecord::Base
-      def self.aggregate(function, account, code, range, named_scopes)
-        collection_filter = LineAggregateFilter.new(account, code, range, 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,79 +0,0 @@
-# encoding: utf-8
-module DoubleEntry
-  module Reporting
-    class LineAggregateFilter
-      def initialize(account, code, range, filter_criteria)
-        @account         = 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
-      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 a single metadatum criteria to filter on
-      #     {
-      #       :metadata => {
-      #         :meme => :business_cat
-      #       }
-      #     }
-      #   ]
-      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)
-        metadata.reduce(collection.joins(:metadata)) do |filtered_collection, (key, value)|
-          filtered_collection.where(metadata_table => { :key => key, :value => value })
-        end
-      end
-
-      def metadata_table
-        DoubleEntry::LineMetadata.table_name.to_sym
-      end
-    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