when_exe 0.3.4 → 0.3.5

data/lib/when_exe/calendartypes.rb

@@ -88,6 +88,15 @@ module When::CalendarTypes
       time = When::TM::JulianDate._d_to_t(sdn-0.5)
       @time_standard.to_dynamical_time(time) - When::TimeStandard.to_dynamical_time(time)
     end
+
+    #
+    # Zone 名
+    #
+    # @return [String]
+    #
+    def zone
+      iri.split('/')[-1]
+    end
   end
 
   #
@@ -351,7 +360,7 @@ module When::CalendarTypes
         rule['Offset'] << (k == 0 ? 0 : rule['Offset'][k-1]+rule['Length'][k-1])
         trunk  = key.upcase[k]
         branch = (trunk == key.upcase[k-1]) ? 1 : 0
-        trunk  = trunk.ord if (trunk.kind_of?(String))
+        trunk  = trunk.ord if trunk.kind_of?(String)
         trunk -= 64
         rule['IDs'] << ((branch==0) ? trunk : When::Coordinates::Pair.new(trunk, branch))
       end
@@ -379,23 +388,28 @@ module When::CalendarTypes
     #      Rule   =>  Array of sub rules' key and offset
     def _make_rule(key, rule, unit=nil)
 
-      mm, dd = 0, 0
+      offsets = [0, 0]
       rule['Rule'].each_index do |k|
         subkey = rule['Rule'][k]
-        case subkey
-        when String ; rule['Rule'][k] = [subkey, dd, mm]
-        when Array  ; subkey, dd, mm  = rule['Rule'][k]
-        else        ; raise TypeError, "Irregal subkey type"
+        if subkey.kind_of?(Array)
+          subkey, *offsets = rule['Rule'][k]
+        else
+          rule['Rule'][k] = [subkey] + offsets
         end
-        mm += subkey.length
-        dd += subkey.length * 29 + subkey.gsub(/[a-z]/,'').length
+        _increment_offsets(offsets, subkey)
       end
 
-      rule['Years']  ||= rule['Rule'].length
-      rule['Months'] ||= mm
-      rule['Days']   ||= dd
+      rule['Years']  ||= rule['Rule'].length # 年数
+      rule['Months'] ||= offsets[1]          # 月数
+      rule['Days']   ||= offsets[0]          # 日数
+
+      @entry_key     ||= key
+    end
 
-      @entry_key ||= key
+    # オフセットの更新
+    def _increment_offsets(offsets, subkey)
+      offsets[1] += subkey.length                                       # 月のオフセットを月数分進める
+      offsets[0] += subkey.length * 29 + subkey.gsub(/[a-z]/,'').length # 日のオフセットを日数分進める
     end
 
     # 年初の通日によるセットアップ
@@ -449,6 +463,27 @@ module When::CalendarTypes
     end
   end
 
+  # 表引きにより実現する太陰太陽暦(29,30日以外の月がある場合)
+  #
+  #   Luni-Solar calendar which uses year / month /day table
+  #
+  class PatternTableBasedLuniSolarExtended < PatternTableBasedLuniSolar
+
+    private
+
+    # rule の遅延生成
+    def _rule_(key)
+      key.kind_of?(Hash) ? key : super
+    end
+
+    # オフセットの更新
+    def _increment_offsets(offsets, subkey)
+      return super unless subkey.kind_of?(Hash)
+      offsets[1] += subkey['Months'] # 月のオフセットを月数分進める
+      offsets[0] += subkey['Days']   # 日のオフセットを日数分進める
+    end
+  end
+
   # 年の配当パターンが限定されている暦
   #
   #   Calendar which has some fixed arrangement rules of year pattern
@@ -727,9 +762,10 @@ module When::CalendarTypes
     #
     def _normalize(args=[], options={})
       @months_in_year ||= 12
+      @formula = When::Parts::Resource._instantiate(@formula)
       super
     end
- end
+  end
 
   # 月日の配当が太陽の位置によって決定される太陽暦
   #
@@ -1101,465 +1137,4 @@ module When::CalendarTypes
       @height ||= '0'
     end
   end
-
-  #
-  # 暦注 - Calendar Note
-  #
-  class CalendarNote < When::TM::ReferenceSystem
-
-    #
-    # 暦注要素への名前アクセス機能提供
-    #
-    module LabelAccess
-      attr_reader :_pool
-
-      #
-      # 暦注要素への名前(label)によるアクセス
-      #
-      # @param [Numeric] key 配列インデックスと見なしてアクセス
-      # @param [String]  key 名前(label)と見なしてアクセス
-      #
-      # @return [Object] 暦注要素
-      #
-      def [](key)
-        return super if key.kind_of?(Numeric)
-        @_pool ||= Hash[*(inject([]) {|pair, v| pair << v.label.to_s << v})]
-        @_pool[key]
-      end
-    end
-
-    #
-    # 暦注要素のひな形クラス
-    #
-    class NoteElement < When::BasicTypes::Object
-      #
-      # _m17n_form のための要素生成
-      #
-      # @param [Hash] options 未使用
-      #
-      def _to_hash_value(options={})
-        label
-      end
-    end
-
-    # デフォルトイベント名
-    #
-    # @return [String]
-    #
-    # @note イベント名の後ろに数字が使われている場合、数字部分以降はイベントメソッドの引数になります。
-    #        SolarTermsクラスで 'term180' は、太陽黄経180度のイベントすなわち秋分を意味します。
-    #
-    attr_accessor :event
-    protected :event=
-
-    # デフォルトイベントの指定
-    #
-    # @param  [String] event 指定値を@eventとした新しいオブジェクトを作る
-    #
-    # @return [When::CalendarTypes::CalendarNote]
-    #
-    def copy(event)
-      c = self.clone
-      c.event = event
-      c
-    end
-
-    # 典型的なイベントの発生間隔
-    #
-    # @param  [String] event
-    #
-    # @return [When::TM::PeriodDuration]
-    #
-    def duration(event=@event)
-      void, event, parameter = event.split(/^([^\d]+)/)
-      send((event+'_delta').downcase.to_sym, parameter)
-    end
-
-    # 指定の日時が指定イベントに該当するか?
-    #
-    # @param  [When::TM::TemporalPosition] date チェックされる日時
-    # @param  [String] event チェックするイベント名
-    #
-    # @return [Boolean]
-    #   [ true  - 該当する   ]
-    #   [ false - 該当しない ]
-    #
-    def include?(date, event=@event)
-      enum_for(date, :forward, event.downcase).next.include?(date)
-    end
-
-    # Enumeratorの生成
-    #
-    # @param [When::TM::TemporalPosition] first 始点
-    # @param [Symbol] direction
-    #   [:forward] 昇順
-    #   [:reverse] 降順
-    # @param [String] event イベント名
-    # @param [Integer] count_limit 繰り返し回数(デフォルトは指定なし)
-    #
-    # @return [Enumerator]
-    #
-    def enum_for(first, direction=:forward, event=@event, count_limit=nil)
-      Enumerator.new(self, first, direction, event, count_limit)
-    end
-    alias :to_enum :enum_for
-
-    # 暦注の計算
-    #
-    # @param [When::TM::TemporalPosition] date 暦注を計算する日時
-    # @param [When::TM::TemporalPosition 以外] date When::TM::TemporalPosition に変換して使用する
-    # @param [String]  options { :notes => String } という Hash の指定と等価
-    # @param [Integer] options { :indices => Integer} という Hash の指定と等価
-    # @param [Hash] options 下記のとおり
-    # @option options [Integer]              :indices    Integerで指定した暦座標の暦注を計算
-    #   [ When::DAY  ( 0) - 日 ]
-    #   [ When::MONTH(-1) - 月 ]
-    #   [ When::YEAR (-2) - 年 ]
-    #
-    # @option options [Array<Integer>]       :indices    Integerで指定したすべて暦座標の暦注を計算
-    # @option options [nil]                  :indices    すべての暦座標の暦注を計算(デフォルト)
-    # @option options [String]               :notes      計算する暦注名(日の暦注)
-    # @option options [Integer]              :notes      計算する暦注のビット配列(日の暦注)
-    # @option options [Array<Array<String>>] :notes      計算する暦注名の Array の Array
-    # @option options [Array<Integer>]       :notes      計算する暦注のビット配列の Array
-    # @option options [:all]                 :notes      すべての暦注を計算
-    # @option options [:prime, nil]          :notes      @prime に登録した暦注を計算、@prime未登録なら :all と同じ(デフォルト)
-    # @option options [Hash]                 :conditions 暦注計算の条件
-    #     [ :location    => 暦注計算の基準となる場所(String or When::Coordinates::Spatial) ]
-    #     [ その他のキー => 個々の暦注クラスごとにその他のキーを使用できる ]
-    #
-    # @option options [Hash]                 その他のキー date を When::TM::TemporalPosition に変換するために使用する
-    #                                        see {When::TM::TemporalPosition._instance}
-    #
-    # @note CalendarNoteオブジェクト生成時に _normalize メソッド内で @prime 変数を設定しておけば、
-    #       本メソッドの :prime オプションで参照される。(BalineseNote#_normalize等参照)
-    #
-    # @note 暦注のビットアドレスは、暦注サブクラスのNoteObjects定数の中の定義順序による。
-    #       When::CalendarTypes::CalendarNote クラスの場合 new の引数とした暦注要素リストの定義順序による。
-    #       ビットアドレスの値が 1 の暦注が計算対象となる。
-    #
-    # @return [Hash]               :notes が String の場合、指定の暦注の計算結果を返す。
-    # @return [Array<Hash>]        上記に該当せず、:indices が Integer の場合、指定の暦座標の暦注計算結果を返す。
-    # @return [Array<Array<Hash>>] 上記のいずれにも該当しない場合、暦注計算結果を返す。
-    #     [ :note  => 暦注要素 (When::Coordinates::Residue, String, When::BasicTypes::M17n) ]
-    #     [ :value => 暦注の値 (When::Coordinates::Residue, String, When::BasicTypes::M17n, When::TM::TemporalPosition) ]
-    #
-    # @note
-    #   戻り値の :value が When::TM::TemporalPosition の場合、その日時オブジェクトの events[0] に暦注名の入った
-    #   暦注に該当する日付である。(例) Christian クラス で easter を計算した場合、当該年の復活祭の日付オブジェクトが返る。
-    # @note
-    #   暦注サブクラスの場合、暦注要素が増えたり、:note の暦注要素の型が変わったりすることがある。
-    #
-    def notes(date, options={})
-      dates, indices, notes, conditions, options = _parse_note(date, options)
-      _result(indices.map {|i|
-        next [] unless i <= date.precision
-        _note_values(dates, notes[i-1], _all_keys[i-1], _elements[i-1]) do |dates, focused_notes, notes_hash|
-          focused_notes.each do |note|
-            unless notes_hash[note]
-              void, event, *parameter = note.split(/^([^\d]+)/)
-              method = event.downcase
-              parameter << conditions unless conditions.empty?
-              notes_hash[note] = 
-                if respond_to?(method)
-                  send(method, dates, *parameter)
-                else
-                  _elements[i-1][note].send(When::Coordinates::PRECISION_NAME[i].downcase, dates)
-                end
-            end
-          end
-          notes_hash
-        end
-      }, options)
-    end
-
-    #
-    # 暦注の一致 or 不一致
-    #
-    # @param [When::TM::TemporalPosition] date 暦注を確認する日時
-    # @param [When::TM::TemporalPosition 以外] date When::TM::TemporalPosition に変換して使用する
-    # @param [String]  options { :notes   => String } または { :value => String } という Hash の指定と等価
-    #                 (指定の notes が存在する場合は前者、しない場合は後者)
-    # @param [Integer] options { :indices => Integer } という Hash の指定と等価
-    # @param [Hash]    options 下記のとおり
-    # @option options [暦注の値] :value 確認する暦注の値
-    # @option options [それぞれ] その他 {When::CalendarTypes::CalendarNote#notes} を参照
-    #
-    # @return [Boolean]
-    #   [ true  - 暦注が一致   ]
-    #   [ false - 暦注が不一致 ]
-    #
-    def note?(date, options={})
-      options = _find_note(options)    if options.kind_of?(String)
-      value   = options.delete(:value) if options.kind_of?(Hash)
-      result  = notes(date, options)
-      result  = [result] unless result.kind_of?(Array)
-      result  = result.flatten.compact
-      return false unless result.size > 0
-      return true unless value
-      result.each do |hash|
-        return true if value == hash[:value]
-      end
-      return false
-    end
-
-    # 年の名前を暦注として返す
-    # @method year
-    #   @return [When::BasicTypes::M17n]
-
-    # 月の名前を暦注として返す
-    # @method month
-    #   @return [When::BasicTypes::M17n]
-
-    # 日の名前を暦注として返す
-    # @method day
-    #   @return [When::BasicTypes::M17n]
-
-    #
-    # 標準的な暦注として、暦座標の値の名前を暦注として返すメソッドを登録
-    #
-    # @private
-    ['year', 'month', 'day'].each do |c|
-      module_eval %Q{
-        def #{c}(date)
-          date.name('#{c}')
-        end
-      }
-    end
-
-    private
-
-    #
-    # オブジェクトの正規化
-    #
-    def _normalize(args=[], options={})
-      @_elements = (args.size == 0 && self.class.const_defined?(:NoteObjects)) ?
-        When::Parts::Resource.base_uri + self.class.to_s.split(/::/)[1..-1].join('/') + '/NoteObjects' :
-        _to_iri(args, options[:prefix] || '_co:')
-      if @_elements.kind_of?(Array)
-        @_elements.each do |e|
-          e.extend LabelAccess
-        end
-      end
-    end
-
-    # 暦注要素
-    #
-    # @return [Array<Array<When::Parts::Resource>>]
-    #
-    def _elements
-      @_elements = When.Resource(@_elements) if @_elements.kind_of?(String)
-      @_elements
-    end
-
-    #
-    # [[暦注名]](全暦注)
-    #
-    # @return [Array<Array<String, When::BasicTypes::M17n>>]
-    #
-    def _all_keys
-      @_all_keys ||= _elements.map { |c|
-        c.map {|n|
-          n.label.to_s
-        }
-      }
-    end
-
-    #
-    # [[暦注名]](主要暦注)
-    #
-    # @return [Array<Array<When::Parts::Resource>>]
-    #
-    def _prime_keys
-      @prime ||= _all_keys
-    end
-
-    #
-    # notes メソッドの引数を parse する
-    #
-    # @return [Array] dates, indices, notes
-    #
-    def _parse_note(date, options)
-      options = 
-        case options
-        when Hash    ; options
-        when String  ; {:notes   => options}
-        when Integer ; {:indices => options}
-        else         ; {}
-        end
-      conditions = options.delete(:conditions) || {}
-      _opt       = options.dup
-      notes      = _notes(_opt.delete(:notes)  || :prime)
-      indices    = _indices(_opt.delete(:indices), notes)
-      date       = When.when?(date, _opt) unless date.kind_of?(When::TM::TemporalPosition)
-      [_to_date_for_note(date), indices, notes, conditions, options]
-    end
-
-    #
-    # notes メソッドの 文字列引数の意味を解釈する
-    #
-    # @return [Hash] options for note String
-    #
-    def _find_note(note)
-      _elements.each_index do |index|
-        return {:notes=>note, :indices => [-index]} if _elements[-1-index]._pool[note]
-      end
-      {:value => note}
-    end
-
-    #
-    # 計算する暦注
-    #
-    # @return [Array<Array<String>, Integer>]
-    #
-    def _notes(notes)
-      case notes
-      when :all    ; _all_keys
-      when :prime  ; _prime_keys
-      when Integer ; [notes]
-      when String  ; [[notes]]
-      else         ; notes
-      end
-    end
-
-    #
-    # 暦注を計算する暦座標の配列
-    #
-    # @return [Array<Integer>]
-    #
-    def _indices(indices, notes)
-      case indices
-      when nil   ; (0...notes.size).to_a.reverse.map {|i| -i}
-      when Range ; indices.to_a
-      when Array ; indices
-      else       ; [indices.to_i]
-      end
-    end
-
-    #
-    # notes メソッドの結果を後処理する
-    #
-    # @return [Array<Array>, Array, String]
-    #
-    def _result(result, options)
-      return result[0][0] if options[:notes].kind_of?(String)
-      return result[0]    if options[:indices].kind_of?(Numeric)
-      return result
-    end
-
-    #
-    # 年月日暦注計算の共通処理 - コールバック元
-    #
-    def _note_values(dates, focused_notes, all_notes, note_objects)
-      return [] unless dates && all_notes
-
-      # prepare focused notes
-      case focused_notes
-      when Integer
-        bits = ~focused_notes << 1
-        focused_notes = all_notes.dup.delete_if { (bits>>=1)[0] == 1 }
-      when []
-        focused_notes = all_notes
-      when nil
-        focused_notes = []
-      end
-      focused_notes = focused_notes.dup
-      not_focused_notes = all_notes - focused_notes
-      notes = {}
-      not_focused_notes.each do |note|
-        notes[note] = true
-      end
-      focused_notes.each do |note|
-        notes[note] = nil
-      end
-
-      # update notes
-      notes = yield(dates, focused_notes, notes)
-      notes.keys.each do |note|
-        notes.delete(note) unless focused_notes.include?(note)
-      end
-
-      # return Array of Hash
-      focused_notes.map {|note|
-        next nil unless notes[note]
-        if note_objects[note].respond_to?(:to_note_hash)
-          note_objects[note].to_note_hash(notes[note], dates)
-        else
-          {:note=>note_objects[note].label, :value=>notes[note]}
-        end
-      }.compact
-    end
-
-    #
-    # 再帰的に配列の中を Resource化する
-    #
-    def _to_iri(args, prefix)
-      args.map {|arg|
-        case arg
-        when String
-          arg, method = $1, $2 if (arg =~ /^(.+)#([_A-Z0-9]+)$/i)
-          obj = When.Resource(arg, prefix)
-          obj = obj.copy(method) if method
-          obj
-        when Array
-          _to_iri(arg, prefix)
-        else
-          arg
-        end
-      }
-    end
-
-    #
-    # 暦日を当該暦注計算用クラスに変換
-    #
-    #   基底クラスである本クラスでは何もしないで、引数をそのまま返す
-    #
-    def _to_date_for_note(date)
-      date
-    end
-
-    #
-    # イベントを取得する Enumerator
-    #
-    class Enumerator < When::Parts::Enumerator
-
-      #
-      # 次のイベントを得る
-      #
-      # @return [When::TM::TemporalPosition]
-      #
-      def _succ
-        @current = (@current==:first) ? @first : event_eval(@current + @delta)
-      end
-
-      # オブジェクトの生成
-      #
-      # @param [When::CalendarTypes::CalendarNote] parent 暦注アルゴリズム
-      # @param [When::TM::TemporalPosition] first 始点
-      # @param [Symbol] direction
-      #   [:forward] 昇順
-      #   [:reverse] 降順
-      # @param [String] event イベント名
-      # @param [Integer] count_limit 繰り返し回数(デフォルトは指定なし)
-      #
-      def initialize(parent, first, direction, event, count_limit=nil)
-        @parent = parent
-        void, @event, @parameter = event.split(/^([^\d]+)/)
-        @delta = @parent.send((@event+'_delta').to_sym, @parameter)
-        instance_eval %Q{
-          def event_eval(date)
-            @parent.#{@event}(date, @parameter)
-          end
-        }
-        date = event_eval(first)
-        if direction == :reverse
-          @delta = -@delta
-          date   = event_eval(first + @delta) if first.to_i < date.to_i
-        else
-          date   = event_eval(first + @delta) if first.to_i > date.to_i
-        end
-        super(@parent, date, direction, count_limit)
-      end
-    end
-  end
 end