season.rb in edtf-2.1.0

- old
+ new

@@ -1,56 +1,57 @@
 module EDTF
 
   class Season
     extend Forwardable
-    
+
     SEASONS = Hash[21, :spring, 22, :summer, 23, :autumn, 24, :winter].freeze
-    
+
     CODES = Hash.new { |h,k| h.fetch(k.to_sym, nil) }.merge(
       SEASONS.invert).merge({ :fall => 23 }).freeze
-    
+
     NORTHERN = Hash[:spring, [3,4,5], :summer, [6,7,8], :autumn, [9,10,11], :winter, [12,1,2]].freeze
     SOUTHERN = Hash[:autumn, [3,4,5], :winter, [6,7,8], :spring, [9,10,11], :summer, [12,1,2]].freeze
-    
+
     NORTHERN_MONTHS = Hash[*NORTHERN.map { |s,ms| ms.map { |m| [m,s] } }.flatten].freeze
     SOUTHERN_MONTHS = Hash[*SOUTHERN.map { |s,ms| ms.map { |m| [m,s] } }.flatten].freeze
-    
-    
+
+
     include Comparable
     include Enumerable
-    
+
     class << self
       def current
         Date.today.season
       end
     end
 
     attr_reader :season, :year
-    
+
     attr_accessor :qualifier, :uncertain, :approximate
-    
-    def_delegators :to_range,
-      *Range.instance_methods(false).reject { |m| m.to_s =~ /^(each|min|max|cover?|inspect)$|^\W/ }
-    
+
+    def_delegators :to_range, *Range.instance_methods(false).reject { |m|
+      m.to_s =~ /^(each|min|max|cover\?|inspect|to_s)$|^\W/
+    }
+
     SEASONS.each_value do |s|
       define_method("#{s}?") { @season == s }
       define_method("#{s}!") { @season =  s }
     end
-    
+
     alias fall? autumn?
     alias fall! autumn!
-    
+
     [:first, :second, :third, :fourth].zip([:spring, :summer, :autumn, :winter]).each do |quarter, season|
       alias_method("#{quarter}?", "#{season}?")
       alias_method("#{quarter}!", "#{season}!")
     end
 
 
     def initialize(*arguments)
       arguments.flatten!
       raise ArgumentError, "wrong number of arguments (#{arguments.length} for 0..3)" if arguments.length > 3
-      
+
       if arguments.length == 1
         case arguments[0]
         when Date
           @year, @season = arguments[0].year, NORTHERN_MONTHS[arguments[0]]
         when Symbol, String
@@ -65,126 +66,126 @@
         self.qualifier = qualifier
       end
     end
 
 
-		[:uncertain, :approximate].each do |m|
-			
-			define_method("#{m}?") { !!send(m) }
-			
-			define_method("#{m}!") do
-				send("#{m}=", true)
-				self
-			end
-		end
+    [:uncertain, :approximate].each do |m|
 
-		def certain?; !uncertain; end
-		def precise?; !approximate; end
-		
-		def certain!
-			@uncertain = false
-			self
-		end
-		
-		def precise!
-			@approximate = false
-		end
-		
-		# Returns the next season.
-		def succ
-			s = dup
-			s.season = next_season_code
-			s.year = year + 1 if s.first?
-			s
-		end
-		
-		# def next(n = 1)
-		# end
+      define_method("#{m}?") { !!send(m) }
 
-		def cover?(other)
-			return false unless other.respond_to?(:day_precision)
-			other = other.day_precision
-			min.day_precision! <= other && other <= max.day_precision!
-		end
-		
+      define_method("#{m}!") do
+        send("#{m}=", true)
+        self
+      end
+    end
+
+    def certain?; !uncertain; end
+    def precise?; !approximate; end
+
+    def certain!
+      @uncertain = false
+      self
+    end
+
+    def precise!
+      @approximate = false
+    end
+
+    # Returns the next season.
+    def succ
+      s = dup
+      s.season = next_season_code
+      s.year = year + 1 if s.first?
+      s
+    end
+
+    # def next(n = 1)
+    # end
+
+    def cover?(other)
+      return false unless other.respond_to?(:day_precision)
+      other = other.day_precision
+      min.day_precision! <= other && other <= max.day_precision!
+    end
+
     def each
       if block_given?
         to_range.each(&Proc.new)
         self
       else
         to_enum
       end
     end
-    
+
     def year=(new_year)
       @year = new_year.to_i
     end
-    
+
     def season=(new_season)
       @season = SEASONS[new_season] || SEASONS[CODES[new_season]] ||
         raise(ArgumentError, "unknown season/format: #{new_season.inspect})")
     end
 
     def season?; true; end
-    
+
     def qualified?; !!@qualifier; end
-    
+
     def edtf
       '%04d-%2d%s' % [year, CODES[season], qualified? ? "^#{qualifier}" : '']
     end
 
     alias to_s edtf
 
-    
+
     def <=>(other)
       case other
       when Date
         cover?(other) ? 0 : to_date <=> other
-			when Interval, Epoch
-				[min, max] <=> [other.min, other.max]
+      when Interval, Epoch
+        [min, max] <=> [other.min, other.max]
       when Season
         [year, month, qualifier] <=> [other.year, other.month, other.qualifier]
       else
         nil
       end
     rescue
       nil
     end
-    
+
     def ===(other)
       (self <=> other) == 0
     rescue
       false
     end
-    
+
     def to_date
       Date.new(year, month, 1)
     end
 
-		alias min to_date
-		
-		def max
-			to_date.months_since(2).end_of_month
-		end
-		
+    alias min to_date
+
+    def max
+      to_date.months_since(2).end_of_month
+    end
+
     # Returns a Range that covers the season (a three month period).
     def to_range
-			min .. max
+      min .. max
     end
-			
+
     protected
-    
+
     def month
       NORTHERN[@season][0]
     end
-    
-		def season_code
-			CODES[season]
-		end
-		
-		def next_season_code(by = 1)
-			((season_code + by) % 4) + 20
-		end
-		
+
+    def season_code
+      CODES[season]
+    end
+
+    def next_season_code(by = 1)
+      ((season_code + by) % 4) + 20
+    end
+
   end
-  
-end
\ No newline at end of file
+
+end