when_exe 0.3.7 → 0.3.8

data/lib/when_exe/region/zoroastrian.rb

@@ -185,14 +185,16 @@ module When
     Fasli =  [{'Epoch'=>{
                  'ZRE'=>{'origin_of_MSC'=>1737},
                  'YZ' =>{'origin_of_MSC'=>-630}
-              }}, Bahai, {
+              }}, TableBasedWithSunset, {
       'label'   => 'Zoroastrian::Fasli',
       'indices' => [
          When.Index('ZoroastrianNotes::month::Month', {:unit =>13}),
          When::Coordinates::DefaultDayIndex
       ],
       'origin_of_MSC' => -630,
-      'epoch_in_CE'   =>  0,
+      'diff_to_CE'    =>    0,
+      'engine_month'  =>    3,
+      'engine_day'    =>   21,
       'rule_table'    => {
         365 => {'Length'=>[30] * 12 + [5]},
         366 => {'Length'=>[30] * 12 + [6]}

data/lib/when_exe/tmobjects.rb

@@ -569,7 +569,12 @@ module When::TM
         value    = @current
         @current = (@count_limit.kind_of?(Numeric) && @count >= @count_limit) ? nil :
                    (@current==:first) ? @first :
-                   (@direction==:forward) ? @first + @parent * @count : @first - @parent * @count
+                   (@direction==:reverse) ? @first - @parent * @count : @first + @parent * @count
+        if @last
+          sign     = @parent.sign
+          sign     = -sign if @direction==:reverse
+          @current = nil if (sign * (@current <=> @last)) > 0
+        end
         @count  += 1
         return value
       end
@@ -735,7 +740,7 @@ module When::TM
       end
       interval = self.dup
       interval.duration = @duration + diff
-      internal.value    = interval.duration / (@radix ** (-@factor) * @unit_quantity)
+      interval.value    = interval.duration / (@radix ** (-@factor) * @unit_quantity)
       return interval
     end
 
@@ -750,7 +755,7 @@ module When::TM
     def -(other)
       interval = self.dup
       interval.duration = @duration - (other.kind_of?(Duration) ? other.duration : other * SECOND)
-      internal.value    = interval.duration / (@radix ** (-@factor) * @unit_quantity)
+      interval.value    = interval.duration / (@radix ** (-@factor) * @unit_quantity)
       return interval
     end
 
@@ -1097,11 +1102,16 @@ module When::TM
     # @return [Integer] 0 との比較により、負,0,正の値を返す
     #
     def sign
+      @sign ||= _sign
+    end
+
+    def _sign
      ((@week || @date || []) + (@time || [])).each do |v|
        return -1 if +v < 0
      end
      return +1
     end
+    private :_sign
 
     # 比較
     #
@@ -1293,7 +1303,7 @@ module When::TM
     # 属性 @duration の計算
     #
     def _duration
-      @duration = nil
+      @duration = @sign = nil
 
       if @time
         @duration  = +@time[HOUR  ] * Duration::HOUR

data/lib/when_exe/tmposition.rb

@@ -207,6 +207,9 @@ module When::TM
     # @private
     HashProperty = Position::HashProperty
 
+    # @private
+    DateTimeInstanceMethods = ::Object.const_defined?(:Date) && ::Date.method_defined?(:+) ? ::DateTime.instance_methods : []
+
     # この時間位置の意味づけ
     #
     # @return [When::TM::IndeterminateValue]
@@ -306,34 +309,17 @@ module When::TM
       #
       def _instance(specification, options={})
 
-        # Suffix - Frame specification
-        rfc5545form, frame, *rest = specification.split(/\^{1,2}/)
-        return rest.inject(_instance(rfc5545form + '^' + frame, options)) {|p,c| When.Resource(c, '_c:').jul_trans(p)} if rest.size > 0
-
-        options[:frame] = When.Resource(frame, '_c:') if (frame)
-
-        # Prefix - RFC 5545 Options
-        if (rfc5545form =~ /\A([^:]+[^-:\d]{2}):([^:].+)\z/)
-          rfc5545option, iso8601form = $~[1..2]
-          rfc5545option.split(/;/).each do |eq|
-            key, value = eq.split(/=/, 2)
-            case key
-            when 'VALUE' ; options[:precision] = value
-            when 'TZID'  ; options[:clock] = 
-              case When::V::Timezone[value]
-              when Array ; When::V::Timezone[value][-1]
-              when nil   ; When::Parts::Timezone.new(value)
-              else       ; When::V::Timezone[value]
-              end
-            else         ; options[key]    = value
-            end
-          end
-        else
-          iso8601form = rfc5545form
-        end
-        options = options.dup
+        # prefix - RFC 5545 Options
+        iso8601form = When::Parts::Resource::ContentLine.extract_rfc5545_Property(specification, options)
+
+        # suffix - Frame specification
+        iso8601form, frame, *rest = iso8601form.split(/\^{1,2}/)
+        return rest.inject(_instance(iso8601form + '^' + frame, options)) {|p,c| When.Resource(c, '_c:').jul_trans(p)} unless rest.empty?
 
-        # IndeterminateValue
+        # add frame to options
+        options = options.merge({:frame=>When.Resource(frame, '_c:')}) if frame
+
+        # indeterminateValue
         if (iso8601form.sub!(/\/After$|^Before\/|^Now$|^Unknown$|^[-+]Infinity\z/i, ''))
           options[:indeterminated_position] = When::TimeValue::S[$&.sub(/\//,'')]
           case options[:indeterminated_position]
@@ -433,6 +419,77 @@ module When::TM
         end
       end
 
+      # When::TM::TemporalPosition の生成
+      #
+      # @see When.TemporalPosition
+      #
+      def _temporal_position(*args)
+        # 引数の解釈
+        options  = args[-1].kind_of?(Hash) ? args.pop.dup : {}
+        validate = options.delete(:invalid)
+        options  = TemporalPosition._options(options)
+        options[:frame]  ||= 'Gregorian'
+        options[:frame]    = When.Resource(options[:frame], '_c:') if options[:frame].kind_of?(String)
+        case args[0]
+        when String
+          options[:era_name]    = When::EncodingConversion.to_internal_encoding(args.shift)
+        when Array
+          options[:era_name]    = args.shift
+          options[:era_name][0] = When::EncodingConversion.to_internal_encoding(options[:era_name][0])
+        end
+
+        # 時間位置の生成
+        res   = []
+        abbrs = Array(options[:abbr])
+        date  = Array.new(options[:frame].indices.length-1) {
+          element = args.shift
+          abbr    = abbrs.shift
+          res    << element.to('year') if element.kind_of?(When::Coordinates::Residue)
+          element.kind_of?(Numeric) ? element : (abbr || 1)
+        }
+        date += Array.new(2) {
+          element = args.shift
+          abbr    = abbrs.shift
+          res    << element.to('day') if element.kind_of?(When::Coordinates::Residue)
+          case element
+          when Numeric ; element
+          when nil     ; abbr
+          else         ; nil
+          end
+        }
+        if args.length > 0
+          options[:clock] ||= Clock.local_time
+          options[:clock]   = When.Clock(options[:clock])
+          time = Array.new(options[:clock].indices.length) {args.shift}
+          position = DateAndTime.new(date, time.unshift(0), options)
+        else
+          position = CalDate.new(date, options)
+        end
+        res.each do |residue|
+          position  = position.succ if residue.carry < 0
+          position &= residue
+        end
+
+        return position unless [:raise, :check].include?(validate)
+
+        # 時間位置の存在確認
+        date[0] = -date[0] if position.calendar_era_name && position.calendar_era_name[2] # 紀元前
+        date.each_index do |i|
+          break unless date[i]
+          next if When::Coordinates::Pair._force_pair(date[i]) == When::Coordinates::Pair._force_pair(position.cal_date[i])
+          return nil if validate == :check
+          raise ArgumentError, "Specified date not found: #{date}"
+        end
+        return position unless time
+        time.each_index do |i|
+          break unless time[i]
+          next if When::Coordinates::Pair._force_pair(time[i]) == When::Coordinates::Pair._force_pair(position.clk_time.clk_time[i])
+          return nil if validate == :check
+          raise ArgumentError, "Specified time not found: #{time}"
+        end
+        return position
+      end
+
       # option の正規化
       # @private
       def _options(options)
@@ -484,13 +541,13 @@ module When::TM
         # TemporalPosition
         specification =~ /(.+?)(?:\[([-+]?\d+)\])?\z/
         options[:sdn] = $2.to_i if $2
-        f, d, t, z, e = When::BasicTypes::DateTime._to_array($1, options)
+        f, d, t, z, e, r = When::BasicTypes::DateTime._to_array($1, options)
         raise ArgumentError, "Timezone conflict: #{z} - #{options[:clock]}" if (z && options[:clock])
         options.delete(:abbr)
         z ||= options[:clock]
         z = When.Clock(z) if (z =~ /\A[A-Z]+\z/)
 
-        unless (d)
+        unless d
           # ClockTime
           raise ArgumentError, "Timezone conflict: #{z} - #{options[:clock]}" if (z && options[:frame])
           options[:frame] ||= z
@@ -512,6 +569,17 @@ module When::TM
                      PeriodDuration.new((w[0]-1)*7 + (w[1]||1)-1, DAY)
           position = When::Parts::GeometricComplex.new(position...(position+P1W)) unless w[1]
         end
+        if r
+          r.keys.sort.each do |count|
+            residue = When.Residue(r[count])
+            if count == 0
+              residue = residue.to('year')
+            else
+              position = position.succ if residue.carry < 0
+            end
+            position &= residue
+          end
+        end
         return position
       end
     end
@@ -552,6 +620,7 @@ module When::TM
       else     ; raise NameError, "Temporal Reference System is not defined"
       end
     end
+    alias :local_time :universal_time
 
     # 外部時間
     #
@@ -565,7 +634,7 @@ module When::TM
         case @indeterminated_position
         when Max ; +Float::MAX/4
         when Min ; -Float::MAX/4
-        else     ; time_standard.to_dynamical_time(universal_time)
+        else     ; time_standard.to_dynamical_time(local_time)
         end
     end
 
@@ -635,8 +704,8 @@ module When::TM
     #
     # @return [::DateTime]
     #
-    def to_date_time(option={:frame=>When::UTC}, start=_default_start)
-      return JulianDate.dynamical_time(dynamical_time, option).to_date_time unless time_standard.rate_of_clock == 1.0
+    def to_datetime(option={:frame=>When::UTC}, start=_default_start)
+      return JulianDate.dynamical_time(dynamical_time, option).to_datetime unless time_standard.rate_of_clock == 1.0
       raise TypeError, "Clock not assigned" unless clock
       Rational
       offset   = Rational(-(clock.universal_time/Duration::SECOND).to_i, (Duration::DAY/Duration::SECOND).to_i)
@@ -657,6 +726,7 @@ module When::TM
       return JulianDate.dynamical_time(dynamical_time, option).to_date unless time_standard.rate_of_clock == 1.0
       ::Date.jd(to_i, start)
     end
+    alias :to_date_or_datetime :to_date
 
     # 組み込みライブラリの Time オブジェクトへの変換
     #
@@ -961,7 +1031,7 @@ module When::TM
       @query         = options[:query]         if (options.key?(:query))
       @location      = options[:location]      if (options.key?(:location))
       @time_standard = options[:time_standard] if (options.key?(:time_standard))
-      @sdn = @universal_time = @dynamical_time = @period = nil
+      @sdn = @universal_time = @local_time = @dynamical_time = @period = nil
       _normalize(options)
       return self
     end
@@ -999,22 +1069,37 @@ module When::TM
 
     # 指定の日を探す
     def _force_euqal_day(diff)
-      jdn  = self.to_i + diff
-      date = self
-      done = {}
-      loop do
-        case
-        when date.to_i == jdn
-          return date
-        when date.to_i > jdn
-          next_date = date - When::P1D
-          date = (date.to_i == next_date.to_i) ? date - When::P2D : next_date
-        when date.to_i < jdn
-          next_date = date + When::P1D
-          date = (date.to_i == next_date.to_i) ? date + When::P2D : next_date
+      return self if diff == 0
+      date = self + When::P1D * diff
+      return date if date.to_i - to_i == diff
+      if @calendar_era
+        options = _attr
+        options.delete(:era_name)
+        era = @calendar_era
+        jdn = (clock ? to_f : to_i)+diff
+        while era
+          date = era.^(jdn, options)
+          return date if date
+          era = diff > 0 ? era.succ : era.prev
+        end
+        raise RangeError, "can't find target date: #{self} -> #{jdn}"
+      else
+        done = {}
+        jdn  = to_i + diff
+        loop do
+          case
+          when date.to_i == jdn
+            return date
+          when date.to_i > jdn
+            next_date = date - When::P1D
+            date = (date.to_i == next_date.to_i) ? date - When::P2D : next_date
+          when date.to_i < jdn
+            next_date = date + When::P1D
+            date = (date.to_i == next_date.to_i) ? date + When::P2D : next_date
+          end
+          raise RangeError, "can't find target date: #{self} -> #{jdn}" if done.key?(date.to_i)
+          done[date.to_i] = true
         end
-        raise RangeError, "can't find target date: #{self} -> #{jdn}" if done.key?(date.to_i)
-        done[date.to_i] = true
       end
     end
 
@@ -1030,17 +1115,27 @@ module When::TM
     #
     # @note
     #   When::TM::TemporalPosition で定義されていないメソッドは
-    #   処理を @frame (type: When::TM::Calendar or When::TM::Clock) に委譲する
+    #   処理を @frame(class: When::TM::Calendar or When::TM::Clock)
+    #   または to_date_or_datetime(class: ::Date or ::DateTime) に委譲する
     #
     def method_missing(name, *args, &block)
       
       return _method_missing(name, *args, &block) if When::Parts::MethodCash::Escape.key?(name)
-      self.class.module_eval %Q{
-        def #{name}(*args, &block)
-          @frame.send("#{name}", self, *args, &block)
-        end
-      } unless When::Parts::MethodCash.escape(name)
-      @frame.send(name, self, *args, &block)
+      if DateTimeInstanceMethods.include?(name) && ! @frame.respond_to?(name)
+        self.class.module_eval %Q{
+          def #{name}(*args, &block)
+            self.to_date_or_datetime.send("#{name}", *args, &block)
+          end
+        } unless When::Parts::MethodCash.escape(name)
+        self.to_date_or_datetime.send(name, *args, &block)
+      else
+        self.class.module_eval %Q{
+          def #{name}(*args, &block)
+            @frame.send("#{name}", self, *args, &block)
+          end
+        } unless When::Parts::MethodCash.escape(name)
+        @frame.send(name, self, *args, &block)
+      end
     end
   end
 
@@ -1095,7 +1190,7 @@ module When::TM
           options[:frame] ||= time.clock
           universal_time    = time.universal_time
         else
-          if ::Object.const_defined?(:Date) && time.respond_to?(:ajd)
+          if ::Object.const_defined?(:Date) && ::Date.method_defined?(:+) && time.respond_to?(:ajd)
             case time
             when ::DateTime
               options[:frame] ||= When.Clock((time.offset * 86400).to_i)
@@ -1130,6 +1225,16 @@ module When::TM
     alias :coordinateValue :universal_time
     protected :universal_time=
 
+    # 内部時間(ローカル)
+    #
+    # @return [Numeric]
+    #
+    #   1970-01-01T00:00:00(ローカル) からの Universal Coordinated Time の経過時間 / 128秒
+    #
+    def local_time
+      @universal_time
+    end
+
     # CoordinateSystem による時間座標値
     #
     # @return [Numeric]
@@ -1177,7 +1282,7 @@ module When::TM
   #
   # ユリウス日
   #
-  # see {http://schemas.opengis.net/gml/3.1.1/base/temporalAppendix.xsd#JulianDateType gml schema}
+  # see {http://schemas.opengis.net/gml/3.1.1/base/temporalAppendix.xsd#JulianDateType CALENdeRsign}
   #
   class JulianDate < Coordinate
 
@@ -1185,6 +1290,16 @@ module When::TM
     #   19700101T120000Z
     JD19700101 = 2440588
 
+    # Modified Julian Date
+    # 
+    # see {http://en.wikipedia.org/wiki/Julian_day#Variants MJD}
+    JDN_of_MJD = 2400000.5
+
+    # Countdown to Equinoctial Planetconjunction 
+    # 
+    # see {http://www.calendersign.com/en/cs_cep-pec.php CEP}
+    JDN_of_CEP = 2698162
+
     class << self
 
       JD19700100_5 = JD19700101 - 0.5
@@ -1219,8 +1334,12 @@ module When::TM
       # @return [When::TM::TemporalPosition, When::TM::Duration, When::Parts::GeometricComplex or Array<them>]
       #
       def parse(specification, options={})
-        jdn, *calendars = specification.split(/\^{1,2}/)
-        jdn   = jdn.sub!(/[.@]/, '.') ? jdn.to_f : jdn.to_i
+        num, *calendars = specification.split(/\^{1,2}/)
+        jdn   = num.sub!(/[.@]/, '.') ? num.to_f : num.to_i
+        case num
+        when/MJD/i ; jdn += JDN_of_MJD
+        when/CEP/i ; jdn += JDN_of_CEP
+        end
         frame = calendars.shift || options[:frame]
         return self.new(jdn, options) unless frame
         calendars.unshift(frame).inject(jdn) {|date, calendar| When.Calendar(calendar).jul_trans(date, options)}
@@ -1340,15 +1459,32 @@ module When::TM
 
     # 内部時間
     #
+    # @param [Integer] sdn 参照事象の通し番号
+    #
     # @return [Numeric]
     #
     #   T00:00:00Z からの Universal Coordinated Time の経過時間 / 128秒
     #
     #   時法によっては、異なる意味を持つことがある
     #
-    def universal_time
+    def universal_time(sdn=nil)
+      raise NameError, "Temporal Reference System is not defined" unless @frame
+      @universal_time ||= @frame.to_universal_time(@clk_time, sdn)
+    end
+
+    # 内部時間(ローカル)
+    #
+    # @param [Integer] sdn 参照事象の通し番号
+    #
+    # @return [Numeric]
+    #
+    #   T00:00:00(ローカル) からの Universal Coordinated Time の経過時間 / 128秒
+    #
+    #   時法によっては、異なる意味を持つことがある
+    #
+    def local_time(sdn=nil)
       raise NameError, "Temporal Reference System is not defined" unless @frame
-      @universal_time ||= @frame.to_universal_time(@clk_time)
+      @local_time ||= @frame.to_local_time(@clk_time, sdn)
     end
 
     # 繰り上がり
@@ -1506,6 +1642,7 @@ module When::TM
       return super if [Now, Max, Min].include?(@indeterminated_position)
       @universal_time ||= JulianDate._d_to_t(to_i)
     end
+    alias :local_time :universal_time
 
     # ユリウス日
     #
@@ -1589,17 +1726,18 @@ module When::TM
       when 'day'
       # 指定の剰余となる日
         sdn      = other & to_i
-        date     = @frame.to_cal_date(sdn)
-        date[0] -= @calendar_era_name[1] if @calendar_era_name
-        result   = self.dup._copy({:events=>nil, :query=>@query, :validate=>:done, :date=>date})
+        options  = {:date=>_date_with_era(@frame.to_cal_date(sdn)), :events=>nil, :query=>@query, :validate=>:done}
+        options[:precision] = When::DAY if precision < When::DAY
+        result   = self.dup._copy(options)
         result.send(:_force_euqal_day, sdn-result.to_i)
 
       when 'year'
       # 指定の剰余となる年
-        date = @cal_date.dup
-        date[0]  = (other & (most_significant_coordinate + @frame._diff_to_CE)) - @frame._diff_to_CE
-        date[0] -= @calendar_era_name[1] if @calendar_era_name
-        return self.dup._copy({:date=>date, :events=>nil, :query=>@query})
+        date     = @frame.send(:_decode, _date_without_era)
+        date[0]  = (other & (date[0] + @frame.diff_to_CE)) - @frame.diff_to_CE
+        options  = {:date=>_date_with_era(@frame.send(:_encode, date)), :events=>nil, :query=>@query}
+        options[:precision] = When::YEAR if precision < When::YEAR
+        return self.dup._copy(options)
 
       else
         raise ArgumentError,"The right operand should have a unit 'day' or 'year'"
@@ -1615,11 +1753,11 @@ module When::TM
     def %(other)
       raise TypeError,"The right operand should be When::Coordinates::Residue" unless other.kind_of?(Residue)
       if precision <= When::YEAR && other.units['year'] && other.event != 'year'
-        other.to('year') % (most_significant_coordinate + @frame._diff_to_CE)
+        other.to('year') % (most_significant_coordinate + @frame.epoch_in_CE)
       else
         case other.event
         when 'day'  ; other % least_significant_coordinate
-        when 'year' ; other % (most_significant_coordinate + @frame._diff_to_CE)
+        when 'year' ; other % (most_significant_coordinate + @frame.epoch_in_CE)
         else        ; raise ArgumentError,"The right operand should have a unit 'day' or 'year'"
         end
       end
@@ -1863,7 +2001,21 @@ module When::TM
     def universal_time
       return super if [Now, Max, Min].include?(@indeterminated_position)
       raise NameError, "Temporal Reference System is not defined" unless (@frame && clock)
-      @universal_time ||= (to_i - JulianDate::JD19700101) * Duration::DAY + @clk_time.universal_time
+      @universal_time ||= (to_i - JulianDate::JD19700101) * Duration::DAY + @clk_time.universal_time(to_i)
+    end
+
+    # 内部時間(ローカル)
+    #
+    # @return [Numeric]
+    #
+    #   1970-01-01T00:00:00(ローカル) からの Universal Coordinated Time の経過時間 / 128秒
+    #
+    #   暦法によっては、異なる意味を持つことがある
+    #
+    def local_time
+      return super if [Now, Max, Min].include?(@indeterminated_position)
+      raise NameError, "Temporal Reference System is not defined" unless (@frame && clock)
+      @local_time ||= (to_i - JulianDate::JD19700101) * Duration::DAY + @clk_time.local_time(to_i)
     end
 
     # 要素の参照
@@ -1888,19 +2040,21 @@ module When::TM
       case other.event
       when 'day'
         # 指定の剰余となる日
-        sdn    = other & to_i
-        result = self.dup._copy({:events=>nil, :query=>@query, :validate=>:done,
-                                 :date=>_date_with_era(@frame.to_cal_date(sdn)),
-                                 :time=>@clk_time.clk_time.dup})
+        sdn     = other & to_i
+        options = {:date=>_date_with_era(@frame.to_cal_date(sdn)), :time=>@clk_time.clk_time.dup,
+                   :events=>nil, :query=>@query, :validate=>:done}
+        options[:precision] = When::DAY if precision < When::DAY
+        result  = self.dup._copy(options)
         result.send(:_force_euqal_day, sdn-result.to_i)
 
       when 'year'
         # 指定の剰余となる年
-        date = @cal_date.dup
-        date[0] = (other & (most_significant_coordinate + @frame._diff_to_CE)) - @frame._diff_to_CE
-        return self.dup._copy({:events=>nil, :query=>@query,
-                               :date=>_date_with_era(date),
-                               :time=>@clk_time.clk_time.dup})
+        date     = @frame.send(:_decode, _date_without_era)
+        date[0]  = (other & (date[0] + @frame.diff_to_CE)) - @frame.diff_to_CE
+        options  = {:date=>_date_with_era(@frame.send(:_encode, date)), :time=>@clk_time.clk_time.dup,
+                    :events=>nil, :query=>@query}
+        options[:precision] = When::YEAR if precision < When::YEAR
+        return self.dup._copy(options)
 
       else
         raise ArgumentError,"The right operand should have a unit 'day' or 'year'"
@@ -1972,6 +2126,10 @@ module When::TM
     end
     alias :to_CalDate :to_cal_date
 
+    # 標準ライブラリの DateTime オブジェクトへの変換
+    #
+    alias :to_date_or_datetime :to_datetime
+
     #protected
 
     # 属性の Hash
@@ -2084,7 +2242,7 @@ module When::TM
             @clk_time = zero.clk_time
             @clk_time.clk_time[-1] += second
             leap                   /= clock.second
-            @universal_time  = When::Coordinates::LeapSeconds.new(@universal_time-leap, leap, 1/clock.second)
+            @universal_time = @local_time = When::Coordinates::LeapSeconds.new(@local_time-leap, leap, 1/clock.second)
             @dynamical_time -= leap
           end
         end