double_entry 0.10.0 → 0.10.1

data/lib/double_entry/reporting/time_range.rb

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

data/lib/double_entry/reporting/time_range_array.rb

@@ -2,7 +2,6 @@
 module DoubleEntry
   module Reporting
     class TimeRangeArray
-
       attr_reader :type, :require_start
       alias_method :require_start?, :require_start
 
@@ -14,7 +13,7 @@ module DoubleEntry
       def make(start = nil, finish = nil)
         start = start_range(start)
         finish = finish_range(finish)
-        [ start ].tap do |array|
+        [start].tap do |array|
           while start != finish
             start = start.next
             array << start
@@ -23,7 +22,7 @@ module DoubleEntry
       end
 
       def start_range(start = nil)
-        raise "Must specify start of range" if start.blank? && require_start?
+        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
@@ -42,10 +41,9 @@ module DoubleEntry
 
       def self.make(range_type, start = nil, finish = nil)
         factory = FACTORIES[range_type]
-        raise ArgumentError.new("Invalid range type '#{range_type}'") unless factory
+        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,108 +1,107 @@
 # 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
+  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
 
-      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
+          new(:year => year, :week => week)
         end
 
-        new(:year => year, :week => week)
-      end
-
-      def current
-        from_time(Time.now)
-      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
+        # 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
-      end
 
-    private
+      private
 
-      def start_of_year(year)
-        Time.local(year, 1, 1).beginning_of_week
-      end
+        def start_of_year(year)
+          Time.local(year, 1, 1).beginning_of_week
+        end
 
-      def earliest_week
-        from_time(Reporting.configuration.start_of_business)
+        def earliest_week
+          from_time(Reporting.configuration.start_of_business)
+        end
       end
-    end
 
-    attr_reader :year, :week
+      attr_reader :year, :week
 
-    def initialize(options = {})
-      super options
+      def initialize(options = {})
+        super options
 
-      if options.present?
-        @week = options[:week]
+        if options.present?
+          @week = options[:week]
 
-        @start  = week_and_year_to_time(@week, @year)
-        @finish = @start.end_of_week
+          @start  = week_and_year_to_time(@week, @year)
+          @finish = @start.end_of_week
 
-        @start = earliest_week.start if options[:range_type] == :all_time
+          @start = earliest_week.start if options[:range_type] == :all_time
+        end
       end
-    end
 
-    def previous
-      from_time(@start - 1.week)
-    end
+      def previous
+        from_time(@start - 1.week)
+      end
 
-    def next
-      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 ==(other)
+        week == other.week &&
+          year == other.year
+      end
 
-    def all_time
-      self.class.new(:year => year, :week => week, :range_type => :all_time)
-    end
+      def all_time
+        self.class.new(:year => year, :week => week, :range_type => :all_time)
+      end
 
-    def to_s
-      "#{year}, Week #{week}"
-    end
+      def to_s
+        "#{year}, Week #{week}"
+      end
 
-  private
+    private
 
-    def from_time(time)
-      self.class.from_time(time)
-    end
+      def from_time(time)
+        self.class.from_time(time)
+      end
 
-    def earliest_week
-      self.class.send(:earliest_week)
-    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
+      def week_and_year_to_time(week, year)
+        self.class.send(:start_of_year, year) + (week - 1).weeks
+      end
     end
   end
- end
 end

data/lib/double_entry/reporting/year_range.rb

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

data/lib/double_entry/transfer.rb

@@ -1,7 +1,6 @@
 # encoding: utf-8
 module DoubleEntry
   class Transfer
-
     class << self
       attr_writer :transfers, :code_max_length
 
@@ -17,7 +16,7 @@ module DoubleEntry
 
       # @api private
       def transfer(amount, options = {})
-        raise TransferIsNegative if amount < Money.zero
+        fail TransferIsNegative if amount < Money.zero
         from = options[:from]
         to = options[:to]
         code = options[:code]
@@ -37,14 +36,14 @@ module DoubleEntry
       end
 
       def find!(from, to, code)
-        transfer = find(from, to, code)
-        raise TransferNotAllowed.new([from.identifier, to.identifier, code].inspect) unless transfer
-        return transfer
+        find(from, to, code).tap do |transfer|
+          fail TransferNotAllowed, [from.identifier, to.identifier, code].inspect unless transfer
+        end
       end
 
       def <<(transfer)
         if _find(transfer.from, transfer.to, transfer.code)
-          raise DuplicateTransfer.new
+          fail DuplicateTransfer
         else
           super(transfer)
         end
@@ -54,7 +53,9 @@ module DoubleEntry
 
       def _find(from, to, code)
         detect do |transfer|
-          transfer.from == from and transfer.to == to and transfer.code == code
+          transfer.from == from &&
+            transfer.to == to &&
+            transfer.code == code
         end
       end
     end
@@ -66,18 +67,17 @@ module DoubleEntry
       @from = attributes[:from]
       @to = attributes[:to]
       if code.length > Transfer.code_max_length
-        raise TransferCodeTooLongError.new(
-          "transfer code '#{code}' is too long. Please limit it to #{Transfer.code_max_length} characters."
-        )
+        fail TransferCodeTooLongError,
+             "transfer code '#{code}' is too long. Please limit it to #{Transfer.code_max_length} characters."
       end
     end
 
     def process(amount, from, to, code, detail)
-      if from.scope_identity == to.scope_identity and from.identifier == to.identifier
-        raise TransferNotAllowed.new("from and to are identical")
+      if from.scope_identity == to.scope_identity && from.identifier == to.identifier
+        fail TransferNotAllowed, 'from and to are identical'
       end
       if to.currency != from.currency
-        raise MismatchedCurrencies.new("Missmatched currency (#{to.currency} <> #{from.currency})")
+        fail MismatchedCurrencies, "Missmatched currency (#{to.currency} <> #{from.currency})"
       end
       Locking.lock_accounts(from, to) do
         credit, debit = Line.new, Line.new
@@ -86,7 +86,7 @@ module DoubleEntry
         debit_balance  = Locking.balance_for_locked_account(to)
 
         credit_balance.update_attribute :balance, credit_balance.balance - amount
-        debit_balance.update_attribute  :balance, debit_balance.balance  + amount
+        debit_balance.update_attribute :balance, debit_balance.balance + amount
 
         credit.amount,  debit.amount  = -amount, amount
         credit.account, debit.account = from, to
@@ -102,6 +102,5 @@ module DoubleEntry
         credit.update_attribute :partner_id, debit.id
       end
     end
-
   end
 end