timesteps 0.9.6 → 0.9.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0feffe90d4bd2fdd8c478624bc78b67e3a7ab1c5905e236767c7734ba8c6b098
-  data.tar.gz: 4e924fa6b145f2b7cb06836d408b05e8bb34e8133797a3b7702ba29033af4400
+  metadata.gz: bac0d24992c8693974390e294212ee592b8b1974486d8ffe95704550810ade9e
+  data.tar.gz: e1da906f7b7e7adc85e597dfc14dc8229ff3625f2be3652c599f56a476a10e95
 SHA512:
-  metadata.gz: 52773368aa3a11f6ac7e6e2e71b56e8ebb84f78b2c6807ac509f77a8342566cae41fb4b93a1c0c03f4fd1fbed07ae698144fb208f433b5a663a08cbf80ff83cb
-  data.tar.gz: 61d67459512fa64a4e7b8967b7300af0c9719b61c2bf4f66c478b5c08a064c38d889f0d2830bb7399d81ba02c516b194ccaab85406855a688204c06347cd6117
+  metadata.gz: e2e1b74b4052d4c16d2c4538c98f7328591a317494c6937a7a48d09c751037693d4235cd4a6cf73fb24f993f8a6d35a24cbcef0f4862b6b7e31ec965e552f725
+  data.tar.gz: c7beea6d38d54bfda596c8f5ea4b77f8ebc68660bc3cf1d7fe7c2305a6a63a7966a925caa8b579538010e14cee370934f7c68a115276a9c64b67d04fa0a69dc5

data/Note.ja.md

@@ -1,4 +1,13 @@
 # メモ
+
+masterブランチ    -> gem リリース最新版
+developブランチ   -> 開発統合版
+topicブランチ     -> Feature開発版
+
+
+
+"XX since YYY" と since: time を同時に指定下場合は、前者が採用される (sinceオプションは無視される)。
+
 ### 時間の単位 (udunits)
     * years, year
     * months,month

data/README.md

@@ -58,9 +58,9 @@ ts.index_at("2001-01-02 00:00:00")  ### => 8
 ts.time_at(0)  ### => #<DateTime 2001-01-01T00:00:00 ...>
 ts.time_at(1)  ### => #<DateTime 2001-01-01T03:00:00 ...>
 ts.time_at(8)  ### => #<DateTime 2001-01-02T00:00:00 ...>
-ts.days_at(0)  ### => 0      [Integer]
-ts.days_at(1)  ### => (1/8)  [Rational]
-ts.days_at(8)  ### => 1      [Integer] 
+ts.duration_at(0)  ### => 0      [Integer]
+ts.duration_at(1)  ### => (1/8)  [Rational]
+ts.duration_at(8)  ### => 1      [Integer] 
 ```
 
 #### Treatment of year and month units
@@ -137,14 +137,14 @@ ts = TimeStep.new("days since 2001-01-01", calendar: "allleap")
 ts.parse("2001-02-29") ### => #<DateTime::AllLeap 2001-02-29T ...>
 ```
 
-In the UDUNITS library, negative years are treated as BCs, and A.D. 0 is treated as non-existent. This is different from how it is handled in Ruby's DateTime class. To parse date-time string of UDUNITS type, `bc` option for `Date.parse_timestamp` method.
+In the UDUNITS library, negative years are treated as BCs, and A.D. 0 is treated as non-existent. This is different from how it is handled in Ruby's DateTime class. 
 
 ```ruby
 DateTime.parse_timestamp("-0001-01-01") 
    # => #<DateTime: -0001-01-01T00:00:00+00:00 ...>
    # B.C. 2
 
-DateTime.parse_timestamp("-0001-01-01", bc: true) 
+DateTime.parse_timestamp("0000-01-01") 
    # => #<DateTime: 0000-01-01T00:00:00+00:00 ...>
    # B.C. 1
 

data/lib/timesteps.rb

@@ -12,3 +12,5 @@ require "timesteps/timestep"
 require "timesteps/timestep_pair"
 require "timesteps/timestep_converter"
 require "timesteps/timeperiod"
+require "timesteps/timestep_range"
+require "timesteps/datetime_timestep"

data/lib/timesteps/datetime_parse_timestamp.rb

@@ -11,11 +11,10 @@ class DateTime
   # `DateTime._parse()` is called internally.
   #
   # @param spec [String]
-  # @option bc [Boolean]
   #
   # @return [DateTimeFixedDPY]
 
-  def self.parse_timestamp (spec, calendar: "standard", bc: false, format: nil)
+  def self.parse_timestamp (spec, format: nil, offset: nil, calendar: "standard", tz: nil)
     case calendar.downcase.intern
     when :standard, :gregorian
       klass = DateTime
@@ -40,27 +39,37 @@ class DateTime
       hash = DateTime._strptime(spec, format)
       raise "date-time string '#{spec}' doesn't match with the given format '#{format}'" unless hash
     else
-      if spec =~ /\A([+\-]?\d{4})(\-(\d{1,2}))?\z/
-        hash = { year: $1.to_i, mon: $3 ? $3.to_i : 1, mday: 1 }
+      if spec =~ /\A([+\-]?\d{1,4})(\-(\d{1,2}))?(\s+(\w{3}|[+\-]\d{1,2}(:?\d{1,2})))?\z/
+        year  = $1.to_i
+        month = $3 ? $3.to_i : 1
+        mday  = 1
+        rest  = $4
+        hash = DateTime._parse("#{year}-#{month}-#{mday} 00:00:00 #{rest}")
       else
         hash = DateTime._parse(spec)
       end
     end
-    year, month, day, hour, minute, second, sec_fraction, offset = 
+    year, month, day, hour, minute, second, sec_fraction, offset_ = 
            hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction, :offset)
-    if bc and year < 0
-      year = year + 1
-    end
     hour   ||= 0
     minute ||= 0
     second ||= 0.0
     sec_fraction ||= 0.0
-    offset ||= 0
-    if hour == 24 && minute == 0 && second == 0.0
-      klass.new(year, month, day, 23, minute, second + sec_fraction, offset.quo(86400), start) + 1.quo(24)
+    if offset_ 
+      offset = offset_.quo(86400)
+    else
+      offset ||= 0
+    end
+    if tz
+      time = tz.local_datetime(year, month, day, hour, minute, second.to_i, sec_fraction.to_r)
     else
-      klass.new(year, month, day, hour, minute, second + sec_fraction, offset.quo(86400), start)
+      if hour == 24 && minute == 0 && second == 0.0
+        time = klass.new(year, month, day, 23, minute, second + sec_fraction, offset, start) + 1.quo(24)
+      else
+        time = klass.new(year, month, day, hour, minute, second + sec_fraction, offset, start)
+      end    
     end
+    return time
   end
 
 end

data/lib/timesteps/datetime_timestep.rb

@@ -0,0 +1,64 @@
+
+class DateTime
+  
+  def timestep (interval_spec, tz: nil)
+    case start
+    when Date::ITALY
+      calendar = "standard"
+    when Date::GREGORIAN
+      calendar = "proleptic_gregorian"
+    when Date::JULIAN
+      calendar = "proleptic_julian"
+    end
+    return TimeStep.new(interval_spec, since: self, calendar: calendar, tz: tz)
+  end
+
+  def timeperiod (interval_spec, tz: nil, ends: "[]")
+    case start
+    when Date::ITALY
+      calendar = "standard"
+    when Date::GREGORIAN
+      calendar = "proleptic_gregorian"
+    when Date::JULIAN
+      calendar = "proleptic_julian"
+    end
+    return TimePeriod.new(interval_spec, since: self, calendar: calendar, ends: ends, tz: tz)
+  end
+
+end
+
+class DateTime::NoLeap
+
+  def timestep (interval_spec, tz: nil)
+    return TimeStep.new(interval_spec, since: self, clanedar: "noleap", tz: tz)
+  end  
+
+  def timeperiod (interval_spec, tz: nil, ends: "[]")
+    return TimePeriod.new(interval_spec, since: self, calendar: "noleap", ends: ends, tz: tz)
+  end
+
+end
+
+class DateTime::AllLeap
+
+  def timestep (interval_spec, tz: nil)
+    return TimeStep.new(interval_spec, since: self, clanedar: "allleap", tz: tz)
+  end  
+
+  def timeperiod (interval_spec, tz: nil, ends: "[]")
+    return TimePeriod.new(interval_spec, since: self, calendar: "allleap", ends: ends, tz: tz)
+  end
+
+end
+
+class DateTime::Fixed360Day
+
+  def timestep (interval_spec, tz: nil)
+    return TimeStep.new(interval_spec, since: self, clanedar: "360day", tz: tz)
+  end  
+
+  def timeperiod (interval_spec, tz: nil, ends: "[]")
+    return TimePeriod.new(interval_spec, since: self, calendar: "360day", ends: ends, tz: tz)
+  end
+
+end

data/lib/timesteps/datetimelike.rb

@@ -398,29 +398,18 @@ class DateTimeLike
   #
   # @return [Integer]
   def difference_in_years (other)
-    extra = 0
-    if self.year > other.year && self.compare_md(other) < 0
-      extra = -1
-    end
-    if self.year < other.year && self.compare_md(other) > 0
-      extra = 1
-    end
-    return self.year - other.year + extra
+    my    = self.new_offset(0)
+    other = other.new_offset(0)
+    return my.year - other.year + my.compare_md(other).quo(2)
   end
   
   # Calculate difference between the object and other object in months.
   #
   # @return [Integer]
   def difference_in_months (other)
-    extra = 0
-    if self.month > other.month && self.compare_d(other) < 0
-      extra = -1
-    end
-    if self.month < other.month && self.compare_d(other) > 0
-      extra = 1
-    end
-    return 12*(self.year - other.year) + self.month - other.month + extra  
+    my    = self.new_offset(0)
+    other = other.new_offset(0)
+    return 12*(my.year - other.year) + my.month - other.month + my.compare_d(other).quo(2)  
   end
-  
 end
 

data/lib/timesteps/grads.rb

@@ -1,6 +1,24 @@
-require_relative "../timesteps"
+require "timesteps"
 
-class TimeStep
+class DateTime
+  
+  def self.parse_grads_time (time_string)
+    if time_string.strip =~ /\A(((\d{2})?(:(\d{2}))?Z)?(\d{2}))?(\w{3})(\d{4})\z/i
+      hour = $3 || "00"
+      min  = $5 || "00"
+      day  = $6 || "01"
+      mon  = $7
+      year = $8
+      time = DateTime.parse("#{year}#{mon}#{day} #{hour}:#{min}:00")
+    else
+      raise "invalid time format"
+    end
+    return time
+  end
+  
+end
+
+class TimeStep::Range
 
   # @private
   REGEXP_GRADS_TDEF = /\A(?:TDEF\s+)?(\d+)\s+LINEAR\s+([^\s]*?)\s+([^\s]*?)\s*\z/i
@@ -13,8 +31,17 @@ class TimeStep
     "mo" => "months",
     "yr" => "years",
   }
-  
-  def self.parse_grads_tdef (tdef_string)
+
+  module GrADSMixin
+
+    def parse_grads_time (time_string)
+      return DateTime.parse_grads_time(time_string)
+    end
+
+  end
+    
+  def self.from_grads_tdef (tdef_string)
+
     if tdef_string.strip =~ REGEXP_GRADS_TDEF
       count = $1.to_i
       time  = $2
@@ -22,22 +49,16 @@ class TimeStep
     else
       raise "invalid grads tdef string"
     end
-    if time =~ /(((\d{2})?(:(\d{2}))?Z)?(\d{2}))?(\w{3})(\d{4})/i
-      hour = $3 || "00"
-      min  = $5 || "00"
-      day  = $6 || "01"
-      mon  = $7
-      year = $8
-      origin = DateTime.parse("#{year}#{mon}#{day} #{hour}:#{min}:00")
-    else
-      raise "invalid time format"
-    end
+
+    origin = DateTime.parse_grads_time(time)
     
     increment = increment.sub(/(mn|hr|dy|mo|yr)/i) {|s| GRADS_INCREMENT[s.downcase]}
-    
-    spec = format("%s since %s", increment, origin.strftime("%F %T"))
-    
-    return TimeStep.new(spec, count: count)
+        
+    range = TimeStep.new(increment, since: origin).range(count)
+    range.extend GrADSMixin
+
+    return range
   end
   
+  
 end

data/lib/timesteps/timeperiod.rb

@@ -1,16 +1,17 @@
 
+
 class TimePeriod < TimeStep
-  
-  def initialize (spec, since: nil, format: nil, calendar: "standard", bc: false, boundary: "[)" )
-    super(spec, since: since, format: format, count: 1, calendar: calendar, bc: bc)
-    raise "invalid boundary specification" unless boundary =~ /\A[\[\(][\]\)]\z/
-    @boundary      = boundary
-    @include_start = ( boundary[0] == "[" ) ? true : false
-    @include_last  = ( boundary[1] == "]" ) ? true : false 
+
+  def initialize (spec, since: nil, format: nil, offset: nil, calendar: "standard", tz: nil, ends: "[]" )
+    super(spec, since: since, format: format, offset: offset, calendar: calendar, tz: tz)
+    raise "invalid ends specification" unless ends =~ /\A[\[\(][\]\)]\z/
+    @ends = ends
+    @include_start = ( ends[0] == "[" ) ? true : false
+    @include_last  = ( ends[1] == "]" ) ? true : false 
     @last = time_at(1)
   end
   
-  attr_reader :last
+  attr_reader :last, :ends
 
   def start
     return @origin
@@ -27,40 +28,40 @@ class TimePeriod < TimeStep
   # Returns the value as a string for inspection.
   #
   def inspect
+    options = ""
+    case @calendar.name
+    when "standard", "gregorian"
+    else
+      options << " calendar='#{calendar.name}'"
+    end
     left_paren = @include_start ? "[" : "("
     right_paren = @include_last ? "]" : ")"
-    "#<TimePeriod '#{interval_spec}' #{left_paren}#{start.to_s}, #{last.to_s}#{right_paren} calendar='#{calendar.name}'>"
-  end
-
-  def boundary
-    left_paren = @include_start ? "[" : "("
-    right_paren = @include_last ? "]" : ")"
-    return left_paren + right_paren
+    "#<TimePeriod '#{interval_spec}' #{left_paren}#{start.to_s}, #{last.to_s}#{right_paren} #{options}>"
   end
 
   def include? (other)
     case other
     when TimePeriod
       if ( other.origin < @origin ) ||
-         ( other.origin == @origin && ( not include_start? ) && other.include_start? )
+         ( other.origin == @origin && ( not @include_start ) && other.include_start? )
         left = false
       else
         left = true
       end
       if ( @last < other.last ) ||
-         ( @last == other.last && ( not include_last? ) && other.include_last? )
+         ( @last == other.last && ( not @include_last ) && other.include_last? )
         right = false
       else
         right = true        
       end        
       return left & right
     else
-      if include_start?
+      if @include_start
         left = @origin <= other
       else
         left = @origin < other
       end
-      if include_last?
+      if @include_last
         right = other <= @last
       else
         right = other < @last
@@ -73,13 +74,13 @@ class TimePeriod < TimeStep
     case other
     when TimePeriod
       if ( @origin < other.last ) ||
-         ( @origin == other.last && include_start? && other.include_last?  )
+         ( @origin == other.last && @include_start && other.include_last?  )
          left = true
        else
          left = false
       end
       if ( other.origin < @last ) ||
-         ( other.origin == @last && include_last? && other.include_start?  )
+         ( other.origin == @last && @include_last && other.include_start?  )
          right = true
        else
          right = false
@@ -116,26 +117,26 @@ class TimePeriod < TimeStep
     if ( other.origin < @origin ) ||
        ( other.origin == @origin && ( not include_start? ) && other.include_start? )
       left = other.origin
-      left_boundary = other.include_start? ? "[" : "("
+      left_end = other.include_start? ? "[" : "("
     else
       left = @origin
-      left_boundary = include_start? ? "[" : "("      
+      left_end = include_start? ? "[" : "("      
     end
     if ( @last < other.last ) ||
        ( @last == other.last && ( not include_last? ) && other.include_last? )
       right = other.last
-      right_boundary = other.include_last? ? "]" : ")"
+      right_end = other.include_last? ? "]" : ")"
     else
       right = @last
-      right_boundary = include_last? ? ")" : "]"      
+      right_end = include_last? ? ")" : "]"      
     end
     ridx = index_at(right)
     lidx = index_at(left)
     numeric = (ridx - lidx) * @numeric
     origin = left
     interval_spec = format("%g %s", numeric, @symbol)
-    boundary = left_boundary + right_boundary
-    return TimePeriod.new(interval_spec, since: origin, calendar: @calendar.name, bc: @bc, boundary: boundary)
+    ends = left_end + right_end
+    return TimePeriod.new(interval_spec, since: origin, calendar: @calendar, ends: ends)
   end
 
   def clip (other)
@@ -143,60 +144,62 @@ class TimePeriod < TimeStep
     if ( @origin < other.origin ) ||
        ( @origin == other.origin && include_start? && ( not other.include_start? ) )
       left = other.origin
-      left_boundary = other.include_start? ? "[" : "("
+      left_end = other.include_start? ? "[" : "("
     else
       left = @origin
-      left_boundary = include_start? ? "[" : "("      
+      left_end = include_start? ? "[" : "("      
     end
     if ( other.last < @last ) ||
        ( other.last == @last && include_last? && ( not other.include_last? ) )
       right = other.last
-      right_boundary = other.include_last? ? "]" : ")"
+      right_end = other.include_last? ? "]" : ")"
     else
       right = @last
-      right_boundary = include_last? ? ")" : "]"      
+      right_end = include_last? ? ")" : "]"      
     end
     ridx = index_at(right)
     lidx = index_at(left)
     numeric = (ridx - lidx) * @numeric
     origin = left
     interval_spec = format("%g %s", numeric, @symbol)
-    bndry = left_boundary + right_boundary
-    return TimePeriod.new(interval_spec, since: origin, calendar: @calendar.name, bc: @bc, boundary: bndry)
+    ends = left_end + right_end
+    return TimePeriod.new(interval_spec, since: origin, calendar: @calendar, ends: ends)
   end
   
-  def split (time, boundary: ")[")
+  def split (time, ends: ")[")
     raise "can't split period without contacted time" unless contact?(time)
     # left
     numeric = index_at(time) * @numeric
     interval_spec = format("%g %s", numeric, @symbol)
-    bndry   = (@include_start ? "[" : "(") + boundary[0]
-    left_period  = TimePeriod.new(interval_spec, since: @origin, calendar: @calendar.name, bc: @bc, boundary: bndry)
+    ends   = (@include_start ? "[" : "(") + ends[0]
+    left_period  = TimePeriod.new(interval_spec, since: @origin, calendar: @calendar, ends: ends)
     # right
     numeric = (1 - index_at(time)) * @numeric
     interval_spec = format("%g %s", numeric, @symbol)
-    bndry   = boundary[1] + (@include_last ? "]" : ")")
-    right_period  = TimePeriod.new(interval_spec, since: @origin, calendar: @calendar.name, bc: @bc, boundary: bndry)
+    ends   = ends[1] + (@include_last ? "]" : ")")
+    right_period  = TimePeriod.new(interval_spec, since: @origin, calendar: @calendar, ends: ends)
     return left_period, right_period
   end
   
   def next
-    return TimePeriod.new(interval_spec, since: @last, calendar: @calendar.name, bc: @bc, boundary: boundary)    
+    return TimePeriod.new(interval_spec, since: @last, calendar: @calendar, ends: ends)    
   end
 
   def prev
     origin = index_at(-1)
-    return TimePeriod.new(interval_spec, since: origin, calendar: @calendar.name, bc: @bc, boundary: boundary)    
+    return TimePeriod.new(interval_spec, since: origin, calendar: @calendar, ends: ends)    
   end
 
-  def shift (index)
-    return TimePeriod.new(interval_spec, since: time_at(index), calendar: @calendar.name, bc: @bc, boundary: boundary)    
-  end
+  def shift_origin (index, with: "index")
+    case with
+    when :index, "index"
+      return TimePeriod.new(interval_spec, since: time_at(index), calendar: @calendar, ends: ends)    
+    when :duration, "duration", :days, "days"
+      time = @origin + index
+      return TimePeriod.new(interval_spec, since: time, calendar: @calendar, ends: ends)
+    end
 
-  def shift_with_duration (duration)
-    time = @origin + duration
-    return TimePeriod.new(interval_spec, since: time, calendar: @calendar.name, bc: @calendar.bc?, boundary: boundary)
   end
-  
+    
 end