when_exe 0.3.5 → 0.3.6

data/lib/when_exe/basictypes.rb

@@ -27,6 +27,7 @@ module When
         # @option options [String, Array<String, Integer>] :era_name デフォルトの年号(Integerは0年に対応する通年)
         # @option options [Array<Numeric>] :abbr 上位省略形式で使用する上位部分
         # @option options [Integer] :extra_year_digits ISO8601拡大表記のための年の構成要素拡大桁数(省略時 1桁)
+        # @option options [Integer] :ordinal_date_digits ISO8601拡大表記の年内通日の桁数(省略時 3桁)
         #
         # @return [Array] format, date, time, clock, era
         #
@@ -47,7 +48,7 @@ module When
         def _to_array(date_time, options={})
           raise TypeError, "Argument is not ISO 8601 String" unless date_time.kind_of?(String)
           if options[:abbr].kind_of?(When::TimeValue)
-            options[:abbr] = ((options[:frame]||When.Calendar('Gregorian')) ^ options[:abbr]).cal_date
+            options[:abbr] = ((options[:frame]||When::Gregorian) ^ options[:abbr]).cal_date
           end
           date_time = date_time.gsub(/_([\d])/, '\1')
           begin
@@ -93,8 +94,12 @@ module When
 
           case date_time
           # extended date & time format (ISO 8601)
-          when /^([-+*&%@!>=<?\dW.]+)(?:(T([:*=.,\d]+)?)([A-Z]+(\?.+)?|[-+][:\d]+)?)?$/
+          when /^([-+*&%@!>=<?\dW.\(\)]+)(?:(T([:*=.,\d]+)?)([A-Z]+(\?.+)?|[-+][:\d]+)?)?$/
             d, t, time, clock = $~[1..4]
+            if d =~ /[\(\)]/
+              d = When::CalendarTypes::Yerm.parse(d, options[:abbr])
+              options[:frame] ||= 'Yerm'
+            end
             format, date  = Date._to_array_extended_ISO8601(d, options)
 
           # extended date & time format (JIS X0301)
@@ -147,6 +152,11 @@ module When
           end
       }
 
+      # @private
+      Ordinal_Date_Digits = Hash.new {|hash, key|
+        hash[key] = /^(\d{#{(key || 3).to_i}})$/
+      }
+
       class << self
         # ISO 8601 基本形式の表現を分解して配列化する
         def _to_array_basic_ISO8601(date, options={})
@@ -220,7 +230,7 @@ module When
             dd << Coordinates::Pair._en_pair(_completion($1, abbr.shift), $2)
             dd << Coordinates::Pair._en_pair($3, $4)
             return :week, dd
-          when /^(\d{3})$/
+          when Ordinal_Date_Digits[options[:ordinal_date_digits]]
             dd << $1.to_i
             return :day, dd
           when /^(\d+#{abbr[0] ? '|-' : ''})([-+*&%@!>=<?.])?$/
@@ -403,26 +413,82 @@ module When
     #  代表的な authority の URI
     #   @namespace[''] である
     #
-    # see {When::Parts::Locale}, {When::Parts::Resource}
+    # see {When::Locale}, {When::Parts::Resource}
     #
     class M17n < Code
-      include Parts::Locale
+      include When::Locale
       include Parts::Resource
 
       # @private
-      def self._get_locale(locale, access_key)
-        return nil unless access_key
-        access_key = access_key.split(/\//).map {|key| key =~ /^[0-9]+$/ ? key.to_i : key}
-        locale = locale.sub(/\..*/, '').sub(/-/,'_')
-        [locale, locale.sub(/_.*/, '')].each do |loc|
-          symbol = ('Locale_' + loc).to_sym
-          return {loc=>access_key.inject(const_get(symbol)) {|hash, key| hash = hash[key]}} if (const_defined?(symbol))
-        end
-        return nil
-      end
+      HashProperty = [:label, :names, :link, :access_key, :code_space]
 
       # @private
-      HashProperty = [:label, :names, :link, :access_key, :code_space]
+      LabelTypes = {
+        'Residue' => ['Coordinates',      '%s',     '_co:%s%s'     ],
+        'Week'    => ['CalendarNote',     '%sWeek', '_n:%sWeek%s'  ],
+        'Notes'   => ['CalendarNote',     '%s',     '_n:%s/Notes%s'],
+        nil       => ['BasicTypes::M17n', '%s',     '_m:%s%s'      ]
+      }
+
+      class << self
+
+        #
+        # resource の取得
+        #
+        # @param [When::Parts::Resource, String] source
+        #
+        # @return [When::Parts::Resource]
+        #
+        # @private
+        def _label(source)
+          case source
+          when Parts::Resource, nil       ; return source
+          when Parts::Resource::IRIHeader ; return Parts::Resource._instance(source)
+          end
+          iri = Parts::Resource._abbreviation_to_iri(source, LabelTypes)
+          iri ? Parts::Resource._instance(iri) : nil
+        end
+
+        #
+        # label の取得
+        #
+        # @param [When::Parts::Resource, String] source
+        #
+        # @return [When::BasicTypes::M17n, String]
+        #
+        def label(source)
+          resource = _label(source)
+          case resource
+          when nil             ; return source
+          when M17n            ; return resource
+          when Parts::Resource ; return resource.label
+          else                 ; return resource
+          end
+        end
+
+        #
+        # label の Array の取得
+        #
+        # @param [When::Parts::Resource, Array] source
+        #
+        # @return [Array]
+        #
+        def labels(source)
+          array =
+            if source.kind_of?(Array)
+              source
+            else
+              resource = _label(source)
+              return nil unless resource
+              resource.child
+            end
+          case array[0]
+          when M17n            ; return array
+          when Parts::Resource ; return array.map {|v| v.label}
+          else                 ; return array
+          end
+        end
+      end
 
       #
       # 代表名
@@ -447,6 +513,30 @@ module When
         self
       end
 
+      # 
+      # 内部エンコーディング文字列化
+      #
+      def to_internal_encoding
+        _copy({:label      => When::EncodingConversion.to_internal_encoding(to_s),
+               :names      => Hash[*(names.keys.map {|name| [name, When::EncodingConversion.to_internal_encoding(names[name])]}).flatten],
+               :link       => link,
+               :access_key => access_key,
+               :code_space => code_space
+              })
+      end
+
+      # 
+      # 外部エンコーディング文字列化
+      #
+      def to_external_encoding
+        _copy({:label      => When::EncodingConversion.to_external_encoding(to_s),
+               :names      => Hash[*(names.keys.map {|name| [name, When::EncodingConversion.to_external_encoding(names[name])]}).flatten],
+               :link       => link,
+               :access_key => access_key,
+               :code_space => code_space
+              })
+      end
+
       # オブジェクトの生成
       #
       # @overload initialize(names, namespace={}, locale=[])
@@ -512,8 +602,8 @@ module When
         else
           names, namespace, locale = rest
           @names       = names if names
-          @namespace ||= Parts::Locale._namespace(namespace) if namespace
-          @locale    ||= Parts::Locale._locale(locale)       if locale
+          @namespace ||= When::Locale._namespace(namespace) if namespace
+          @locale    ||= When::Locale._locale(locale)       if locale
         end
         @namespace ||= {}
         @locale    ||= []

data/lib/when_exe/calendarnote.rb

@@ -53,7 +53,7 @@ module When
     #
     # 暦注検索結果を保存するコンテナ
     #
-    module Notes
+    module NotesContainer
 
       class << self
         #
@@ -83,6 +83,7 @@ module When
         # @private
         def verify(pattern, value)
           value = value.label if !value.kind_of?(When::BasicTypes::M17n) && value.respond_to?(:label)
+          pattern = When::EncodingConversion.to_internal_encoding(pattern)
           pattern.kind_of?(Regexp) ? value =~ pattern : value == pattern
         end
       end
@@ -91,18 +92,18 @@ module When
       #
       # @param [Boolean] compact 余分な nil や空配列を除去するか否か
       #
-      # @return [Notes]
+      # @return [NotesContainer]
       #
       def simplify(compact=true)
         if kind_of?(Hash) && !key?(:note)
-          # Persistent Notes
+          # Persistent NotesContainer
           simplified = {}
           each_pair do |key, value|
-            value = value.simplify(compact) if value.kind_of?(Notes)
+            value = value.simplify(compact) if value.kind_of?(NotesContainer)
             simplified[key] = value if value
           end
         else
-          # Non-Persistent Notes
+          # Non-Persistent NotesContainer
           simplified = self
           simplified = _compact(simplified) if compact
           simplified = simplified[0] while simplified.kind_of?(Array) && simplified.size <= 1
@@ -121,13 +122,13 @@ module When
       #
       def value(compact=true, symbol=:value)
         if kind_of?(Hash) && !key?(:note)
-          # Persistent Notes
+          # Persistent NotesContainer
           sliced = {}
           each_pair do |key, val|
             sliced[key] = val[symbol]
           end
         else
-          # Non-Persistent Notes
+          # Non-Persistent NotesContainer
           return _bless(slice(symbol)) if symbol.kind_of?(Integer)
           sliced = _dig(self) {|target| target.fetch(symbol, nil)}
         end
@@ -156,16 +157,16 @@ module When
       #
       def subset(condition, compact=true)
         if kind_of?(Hash) && !key?(:note)
-          # Persistent Notes
+          # Persistent NotesContainer
           result = {}
           each_pair do |key, value|
-            value = value.subset(condition, compact) if value.kind_of?(Notes)
+            value = value.subset(condition, compact) if value.kind_of?(NotesContainer)
             result[key] = value if value
           end
         else
-          # Non-Persistent Notes
+          # Non-Persistent NotesContainer
           result = _dig(self) {|target|
-            (condition.each_pair {|key, pattern| break nil unless Notes.verify(pattern, target[key])}) ? target : nil
+            (condition.each_pair {|key, pattern| break nil unless NotesContainer.verify(pattern, target[key])}) ? target : nil
           }
           result = _compact(result) if compact
         end
@@ -175,10 +176,10 @@ module When
       private
 
       #
-      # 対象オブジェクトを Notes にする
+      # 対象オブジェクトを NotesContainer にする
       #
       def _bless(target)
-        target.extend(Notes) if target && !equal?(target)
+        target.extend(NotesContainer) if target && !equal?(target)
         target
       end
 
@@ -201,6 +202,11 @@ module When
       end
     end
 
+    #
+    # 暦法によってイベントの動作を変えるか否か
+    #
+    CalendarDepend = false
+
     # デフォルトイベント名
     #
     # @return [String]
@@ -307,13 +313,13 @@ module When
     #                                        see {When::TM::TemporalPosition._instance}
     #
     # @note CalendarNoteオブジェクト生成時に _normalize メソッド内で @prime 変数を設定しておけば、
-    #       本メソッドの :prime オプションで参照される。(BalineseNote#_normalize等参照)
+    #       本メソッドの :prime オプションで参照される。(Balinese#_normalize等参照)
     #
-    # @note 暦注のビットアドレスは、暦注サブクラスのNoteObjects定数の中の定義順序による。
+    # @note 暦注のビットアドレスは、暦注サブクラスのNotes定数の中の定義順序による。
     #       When::CalendarNote クラスの場合 new の引数とした暦注要素リストの定義順序による。
     #       ビットアドレスの値が 1 の暦注が計算対象となる。
     #
-    # @return [Array<Array<Hash>>] 暦注計算結果(When::CalendarNote::Notesモジュールをextendしている)
+    # @return [Array<Array<Hash>>] 暦注計算結果(When::CalendarNote::NotesContainerモジュールをextendしている)
     #     [ :note  => 暦注要素 (When::Coordinates::Residue, String, When::BasicTypes::M17n) ]
     #     [ :value => 暦注の値 (When::Coordinates::Residue, String, When::BasicTypes::M17n, When::TM::TemporalPosition) ]
     #
@@ -325,23 +331,13 @@ module When
     #
     def notes(date, options={})
       dates, indices, notes, persistence, conditions, options = _parse_note(date, options)
-      retrieved = Notes.retrieve(persistence, date.to_i)
+      retrieved = NotesContainer.retrieve(persistence, date.to_i)
       return retrieved unless retrieved == false
-      Notes.register(indices.map {|i|
+      NotesContainer.register(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
+            notes_hash[note] ||= _note_element(note, i, conditions, dates)
           end
           notes_hash
         end
@@ -365,7 +361,7 @@ module When
     #   [ false - 暦注が不一致 ]
     #
     def note?(date, options={})
-      options = _find_note(options)    if options.kind_of?(String)
+      options = _find_note(options)    if options.kind_of?(String) || options.kind_of?(Regexp)
       pattern = options.delete(:value) if options.kind_of?(Hash)
       result  = notes(date, options)
       result.flatten!
@@ -373,7 +369,7 @@ module When
       return false unless result.size > 0
       return true unless pattern
       result.each do |hash|
-        return true if Notes.verify(pattern, hash[:value])
+        return true if NotesContainer.verify(pattern, hash[:value])
       end
       return false
     end
@@ -404,12 +400,60 @@ module When
 
     private
 
+    #
+    # 年月日暦注計算の共通処理 - コールバック元
+    #
+    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
+      focused_notes_actual = focused_notes.dup
+      notes = yield(dates, focused_notes_actual, notes)
+      notes.keys.each do |note|
+        notes.delete(note) unless focused_notes_actual.include?(note)
+      end
+
+      # return Array of Hash
+      focused_notes.map {|note|
+        case notes[note]
+        when nil, false ; {}
+        when Hash       ; {:note=>note_objects[note].label}.merge(notes[note])
+        else
+          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
+        end
+      }
+    end
+
     #
     # オブジェクトの正規化
     #
     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' :
+      @_elements = (args.size == 0 && self.class.const_defined?(:Notes)) ?
+        When::Parts::Resource.base_uri + self.class.to_s.split(/::/)[1..-1].join('/') + '/Notes' :
         _to_iri(args, options[:prefix] || '_co:')
       if @_elements.kind_of?(Array)
         @_elements.each do |e|
@@ -418,6 +462,34 @@ module When
       end
     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
+
     # 暦注要素
     #
     # @return [Array<Array<When::Parts::Resource>>]
@@ -457,8 +529,8 @@ module When
     def _parse_note(date, options)
       options = 
         case options
-        when Hash    ; options
-        when String  ; {:notes   => options}
+        when Hash    ; When::EncodingConversion.to_internal_encoding(options)
+        when String  ; {:notes   => When::EncodingConversion.to_internal_encoding(options)}
         when Integer ; {:indices => options}
         else         ; {}
         end
@@ -473,12 +545,27 @@ module When
       [_to_date_for_note(date), indices, notes, persistence, conditions, options]
     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 [Hash] options for note String
     #
     def _find_note(note)
+      note = When::EncodingConversion.to_internal_encoding(note)
       _elements.each_index do |index|
         return {:notes=>note, :indices => [-index]} if _elements[-1-index]._pool[note]
       end
@@ -501,88 +588,20 @@ module When
     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
-
-    #
-    # 年月日暦注計算の共通処理 - コールバック元
-    #
-    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 {} 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
-      }
-    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
+    # @return [Object] 暦注の値
+    #
+    def _note_element(note, index, conditions, dates)
+      void, event, *parameter = note.split(/^([^\d]+)/)
+      method = event.downcase
+      parameter << conditions unless conditions.empty?
+      return send(method, dates, *parameter) if respond_to?(method)
+      root = _elements[index-1][note]
+      parent, leaf = root.iri.split('/Notes') if root.kind_of?(When::Parts::Resource)
+      parent = When.Resource(parent) if leaf
+      return parent.send(method, dates, *parameter) if parent.respond_to?(method)
+      root.send(When::Coordinates::PRECISION_NAME[index].downcase, dates)
     end
 
     #
@@ -650,5 +669,133 @@ module When
           super(@parent, date, direction, options)
       end
     end
+
+    #
+    # 暦週
+    #
+    class Week < CalendarNote
+
+      #
+      # 暦週要素
+      #
+      class DayOfWeek < When::BasicTypes::M17n
+
+        # 当該暦週要素の標準的な出現間隔
+        #
+        # @return [Integer]
+        #
+        attr_reader :delta
+
+        # 所属する暦週オブジェクト
+        #
+        # @return [When::CalendarNote]
+        #
+        def week_note
+          @week_note ||= When.CalendarNote(iri.split('/Notes').first)
+        end
+
+        # 当日または直前に当該暦週要素が現れる日付
+        #
+        # @return [When::TM::TemporalPosition]
+        #
+        def just_or_last(date)
+          date = week_note._to_date_for_note(date)
+          ([parent.child.length, @delta[When::DAY]].max*2).times do
+            if equal?(week_note.week(date))
+               date.events ||= []
+               date.events << self
+               return date
+            end
+            date -= When::P1D
+          end
+          raise ArgumentError, "#{self} not found"
+        end
+
+        private
+
+        #
+        # オブジェクトの正規化
+        #
+        def initialize(*args)
+          super
+          @delta = When::P1D * @delta.to_i if @delta && ! @delta.kind_of?(When::TM::Duration)
+        end
+      end
+
+      #
+      # 曜日の名前の一覧
+      #
+      # @param [When::TM::TemporalPosition] date
+      #
+      # @return [Array<When::CalendarNote::Week::DayOfWeek>]
+      #
+      def week_labels(date)
+        @days_of_week.child[0...week(date)[:position].last]
+      end
+
+      # 七曜
+      #
+      # @param [When::TM::TemporalPosition] date
+      #
+      # @return [When::Coordinates::Residue] 七曜
+      #
+      def standard_week(date)
+        When.Residue('Week')[date.to_i % 7]
+      end
+
+      #
+      # オブジェクトの正規化
+      #
+      def _normalize(args=[], options={})
+        super
+        @days_of_week = When.CalendarNote("#{self.class.to_s.split('::').last}/Notes::day::Week")
+        @days_of_week.child.length.times do |index|
+          name = @days_of_week.child[index].label.to_s.downcase.gsub(/[- ]/, '_')
+          self.class.module_eval %Q{
+            def #{name}(date, parameter=nil)
+              @days_of_week.child[#{index}].just_or_last(date)
+            end
+          } unless respond_to?(name)
+          self.class.module_eval %Q{
+            def #{name}_delta(parameter=nil)
+              @days_of_week.child[#{index}].delta
+            end
+          } unless respond_to?(name + '_delta')
+        end
+      end
+
+      #
+      # イベントを取得する Enumerator
+      #
+      class Enumerator < When::CalendarNote::Enumerator
+
+        #
+        # 次のイベントを得る
+        #
+        # @return [When::TM::TemporalPosition]
+        #
+        def succ
+          value = @current
+          plus  = @delta.sign > 0
+          if @current==:first
+            @first   = event_eval(@first) unless plus
+            @current = @first
+          else
+            if plus
+              @current = event_eval(@current + @delta)
+            else
+              @last    = event_eval(@current - When::P1D)
+              @current = event_eval(@current + @delta)
+              unless [@current.to_i, value.to_i].include?(@last.to_i)
+                @current = @last
+                return value
+              end
+            end
+            @current = event_eval(@current + @delta * 2) if @current.to_i == value.to_i
+          end
+          return value
+        end
+      end
+    end
   end
 end