double_entry 0.10.0 → 0.10.1

data/lib/double_entry/reporting/aggregate_array.rb

@@ -1,76 +1,76 @@
 # 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
+  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)
+      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
+        retrieve_aggregates
+        fill_in_missing_aggregates
+        populate_self
+      end
 
     private
 
-    def populate_self
-      all_periods.each do |period|
-        self << @aggregates[period.key]
+      def populate_self
+        all_periods.each do |period|
+          self << @aggregates[period.key]
+        end
       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] = Reporting.aggregate(function, account, code, :filter => filter, :range => period)
+      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] = Reporting.aggregate(function, account, code, :filter => filter, :range => period)
+          end
         end
       end
-    end
 
-    # get any previously calculated aggregates
-    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).
-        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)).
-        each_with_object({}) do |hash, result|
-          hash[result.key] = formatted_amount(result.amount)
-        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
+        @aggregates = 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)).
+                      each_with_object({}) do |hash, result|
+                        hash[result.key] = formatted_amount(result.amount)
+                      end
+      end
 
-    def all_periods
-      TimeRangeArray.make(range_type, start, finish)
-    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)
+      def formatted_amount(amount)
+        amount ||= 0
+        if function == 'count'
+          amount
+        else
+          Money.new(amount, currency)
+        end
       end
     end
   end
- end
 end

data/lib/double_entry/reporting/day_range.rb

@@ -1,40 +1,42 @@
 # 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)
-      (self.week == other.week) and (self.year == other.year) and (self.day == other.day)
-    end
-
-    def to_s
-      start.strftime('%Y, %a %b %d')
+  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
 end

data/lib/double_entry/reporting/hour_range.rb

@@ -1,42 +1,45 @@
 # 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)
-      (self.week == other.week) and (self.year == other.year) and (self.day == other.day) and (self.hour == other.hour)
-    end
-
-    def to_s
-      "#{start.hour}:00:00 - #{start.hour}:59:59"
+  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
 end

data/lib/double_entry/reporting/line_aggregate.rb

@@ -1,38 +1,37 @@
 # encoding: utf-8
 module DoubleEntry
- module Reporting
-  class LineAggregate < ActiveRecord::Base
-
-    def self.aggregate(function, account, code, range, named_scopes)
-      collection = aggregate_collection(named_scopes)
-      collection = collection.where(:account => account)
-      collection = collection.where(:created_at => range.start..range.finish)
-      collection = collection.where(:code => code) if code
-      collection.send(function, :amount)
-    end
+  module Reporting
+    class LineAggregate < ActiveRecord::Base
+      def self.aggregate(function, account, code, range, named_scopes)
+        collection = aggregate_collection(named_scopes)
+        collection = collection.where(:account => account)
+        collection = collection.where(:created_at => range.start..range.finish)
+        collection = collection.where(:code => code) if code
+        collection.send(function, :amount)
+      end
 
-    # a lot of the trickier reports will use filters defined
-    # in named_scopes to bring in data from other tables.
-    def self.aggregate_collection(named_scopes)
-      if named_scopes
-        collection = DoubleEntry::Line
-        named_scopes.each do |named_scope|
-          if named_scope.is_a?(Hash)
-            method_name = named_scope.keys[0]
-            collection = collection.send(method_name, named_scope[method_name])
-          else
-            collection = collection.send(named_scope)
+      # a lot of the trickier reports will use filters defined
+      # in named_scopes to bring in data from other tables.
+      def self.aggregate_collection(named_scopes)
+        if named_scopes
+          collection = DoubleEntry::Line
+          named_scopes.each do |named_scope|
+            if named_scope.is_a?(Hash)
+              method_name = named_scope.keys[0]
+              collection = collection.send(method_name, named_scope[method_name])
+            else
+              collection = collection.send(named_scope)
+            end
           end
+          collection
+        else
+          DoubleEntry::Line
         end
-        collection
-      else
-        DoubleEntry::Line
       end
-    end
 
-    def key
-      "#{year}:#{month}:#{week}:#{day}:#{hour}"
+      def key
+        "#{year}:#{month}:#{week}:#{day}:#{hour}"
+      end
     end
   end
- end
 end

data/lib/double_entry/reporting/month_range.rb

@@ -1,94 +1,94 @@
 # encoding: utf-8
 module DoubleEntry
- module Reporting
-  class MonthRange < TimeRange
-
-    class << self
-      def from_time(time)
-        new(:year => time.year, :month => time.month)
-      end
+  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
+        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 = self.current
-        [month].tap do |months|
-          while month != last
-            month = month.next
-            months << month
+        # 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
-      end
 
-      def earliest_month
-        from_time(Reporting.configuration.start_of_business)
+        def earliest_month
+          from_time(Reporting.configuration.start_of_business)
+        end
       end
-    end
 
-    attr_reader :year, :month
+      attr_reader :year, :month
 
-    def initialize(options = {})
-      super options
+      def initialize(options = {})
+        super options
 
-      if options.present?
-        @month = options[:month]
+        if options.present?
+          @month = options[:month]
 
-        month_start = Time.local(year, options[:month], 1)
-        @start = month_start
-        @finish = month_start.end_of_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
+          @start = MonthRange.earliest_month.start if options[:range_type] == :all_time
+        end
       end
-    end
 
-    def previous
-      if month <= 1
-        MonthRange.new :year => year - 1, :month => 12
-      else
-        MonthRange.new :year => year, :month => month - 1
+      def previous
+        if month <= 1
+          MonthRange.new :year => year - 1, :month => 12
+        else
+          MonthRange.new :year => year, :month => month - 1
+        end
       end
-    end
 
-    def next
-      if month >= 12
-        MonthRange.new :year => year + 1, :month => 1
-      else
-        MonthRange.new :year => year, :month => month + 1
+      def next
+        if month >= 12
+          MonthRange.new :year => year + 1, :month => 1
+        else
+          MonthRange.new :year => year, :month => month + 1
+        end
       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
+      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
+      alias_method :succ, :next
 
-    def <=>(other)
-      self.start <=> other.start
-    end
+      def <=>(other)
+        start <=> other.start
+      end
 
-    def ==(other)
-      (self.month == other.month) and (self.year == other.year)
-    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 all_time
+        MonthRange.new(:year => year, :month => month, :range_type => :all_time)
+      end
 
-    def to_s
-      start.strftime("%Y, %b")
+      def to_s
+        start.strftime('%Y, %b')
+      end
     end
   end
- end
 end