when_exe 0.4.2 → 0.5.0

data/lib/when_exe/google_api.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 =begin
-  Copyright (C) 2015 Takashi SUGA
+  Copyright (C) 2015-2021 Takashi SUGA
 
   You may use and/or modify this file according to the license described in the LICENSE.txt file included in this archive.
 =end
@@ -8,7 +8,8 @@
 #
 # GoogleAPI の Calendar API v3 への対応
 #
-#   see {Google Calendar API Reference https://developers.google.com/google-apps/calendar/v3/reference/}
+#   see {Ruby Quickstart https://developers.google.com/calendar/quickstart/ruby}
+#   see {Simple REST client for version V3 of the Calendar API https://googleapis.dev/ruby/google-apis-calendar_v3/v0.1.0/}
 #
 module When::GoogleAPI
 
@@ -17,15 +18,9 @@ module When::GoogleAPI
   #
   class Calendar
 
-    # APIClient のインスタンス
-    #
-    # @return [Google::APIClient]
-    #
-    attr_reader :client
-
     # Calendar API のインスタンス
     #
-    # @return [Google::APIClient::API]
+    # @return [Google::Apis::CalendarV3::CalendarService]
     #
     attr_reader :service
 
@@ -45,24 +40,19 @@ module When::GoogleAPI
       #
       # GoogleAPI の Calendar を生成する
       #
-      # @param [Google::APIClient] client
-      # @param [Google::APIClient::API] service
+      # @param [Google::Apis::CalendarV3::CalendarService] service
       # @param [String] calendar_id
       #
-      def list(client, service, calendar_id)
+      def list(service, calendar_id)
         events = []
-        result = client.execute({:api_method => service.events.list,
-                                 :parameters => {'calendarId' => calendar_id}})
+        result = service.list_events(calendar_id)
         loop do
-          events += result.data.items.map {|event| event.to_hash}
-          page_token = result.data.next_page_token
+          events += result.items.map {|event| event.to_h}
+          page_token = result.next_page_token
           break unless page_token
-          result = client.execute({:api_method => service.events.list,
-                                   :parameters => {'calendarId' => calendar_id,
-                                                   'pageToken'  => page_token}})
+          result = service.list_events(calendar_id, page_token: page_token)
         end
         calendar = new(events)
-        calendar.instance_variable_set(:@client, client)
         calendar.instance_variable_set(:@service, service)
         calendar.instance_variable_set(:@calendar_id, calendar_id)
         calendar
@@ -87,7 +77,7 @@ module When::GoogleAPI
     #
     def initialize(events)
       @events = events.map {|event|
-        next nil unless event['status'] == 'confirmed'
+        next nil unless event[:status] == 'confirmed'
         When::V::Event.new(event)
       }.compact
     end
@@ -114,15 +104,18 @@ class When::V::Event
       iprops = {}
       gprops.each_pair do |key, value|
         case key
-        when 'summary'
-          iprops['summary'] = value
-        when 'start', 'end'
+        when :start, :end
           date  = 'VALUE=DATE'
-          date += '-TIME' if value.key?('dateTime')
-          date += ';TZID=' + value['timeZone'] if value.key?('timeZone')
-          date += ':' + (value['date'] || value['dateTime'])
-          iprops['dt' + key] = date
-        when 'recurrence'
+          if value.key?(:date)
+            date += ':' + value[:date].strftime('%Y%m%d')
+          else
+            date += '-TIME'
+            date += ':' + value[:date_time].strftime('%Y%m%dT%H%M%S')
+            date += value[:date_time].strftime('%z') unless value[:time_zone]
+          end
+          date.sub!(':', ";TZID=#{value[:time_zone]}:") if value.key?(:time_zone)
+          iprops['dt' + key.to_s] = date
+        when :recurrence
           value.map do |line|
             tag, rule = line.split(':', 2)
             tag.downcase!
@@ -132,8 +125,10 @@ class When::V::Event
               iprops[tag] = rule
             end
           end
-        when 'iCalUID'
+        when :i_cal_uid
           iprops['uid'] = value
+        when Symbol
+          iprops[key.to_s] = value
         end
       end
       iprops
@@ -144,7 +139,7 @@ class When::V::Event
 
   # Hash からの属性読み込み
   def _parse_from_code(options)
-    if options.key?('start')
+    if options.key?(:start)
       @google_api_props = options
       options = self.class.gcal2ical(options)
     end

data/lib/when_exe/icalendar.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 =begin
-  Copyright (C) 2011-2015 Takashi SUGA
+  Copyright (C) 2011-2021 Takashi SUGA
 
   You may use and/or modify this file according to the license described in the LICENSE.txt file included in this archive.
 =end
@@ -528,6 +528,17 @@ module When::V
                   'resources', 'rdate']]
     # Classes   = [V::Root, V::Alarm]
 
+    RegisteredNotes = {
+      'term'      => 'SolarTerms',
+      'phase'     => 'LunarPhases',
+      'easter'    => 'Christian',
+      'christmas' => 'Christian'
+    }
+
+    RegisteredNoteMethods = /\A(#{RegisteredNotes.keys.sort.reverse.join('|')})/
+
+    DayOfWeek =  %w(SU MO TU WE TH FR SA)
+
     class << self
       include When::Parts::Resource::Pool
 
@@ -563,7 +574,102 @@ module When::V
       #
       # @return [When::TM::IntervalLength]
       def default_until
-        @default_until ||= 1000*When::TM::Duration::YEAR
+        @default_until ||= 1000*(When::TM::Duration::YEAR / When::TM::Duration::DAY)
+      end
+
+      # ISO8601へ埋め込まれた指定に対応する iterator を生成する
+      #
+      # @param [When::TM::TemporalPosition] base            イベントの始点
+      # @param [When::TM::Duration]         duration        イベントの期間
+      # @param [Hash]                       delayed_options 遅延適用するオブジェクト変換オプション
+      #
+      # @return [When::Parts::Enumerator]
+      #
+      def iterator_for_ISO8601(base, duration, delayed_options)
+        duration.to_s =~ /\A-?P(\d+)([YM])\z/
+        event_options = {'rrule'=>
+          case $2
+          when 'Y' ; {'FREQ'=>'YEARLY',  'INTERVAL'=>$1.to_i}
+          when 'M' ; {'FREQ'=>'MONTHLY', 'INTERVAL'=>$1.to_i}
+          else     ; duration ? {'FREQ'=>duration.set_repeat(false).abs} : {'FREQ'=>'YEARLY'}
+          end
+        }
+        residue_options = delayed_options[:residue]
+        frame_len       = base.frame.indices.length
+        if residue_options
+          event_options['rrule'].update(_byyear(residue_options.delete(frame_len-2))) if residue_options[frame_len-2]
+          event_options['rrule'].update(_byday(residue_options.delete(frame_len) )) if residue_options[frame_len]
+          delayed_options.delete(:residue)
+        end
+        if base.precision == When::MONTH && event_options['rrule']['FREQ'] == 'YEARLY'
+          event_options['rrule'].update({'BYMONTH'=>base[When::MONTH]})
+          base = base.floor if event_options['rrule']['BYMONTHDAY']
+        end
+        case base
+        when When::TM::TemporalPosition ; event_options.update({'dtstart'  =>base})
+        else                            ; event_options.update({'dtstart'  =>base.first,
+                                                                'duration' =>base.last-base.first})
+        end
+        event_options['duration']  = delayed_options.delete(:duration) if delayed_options[:duration]
+        behavior_options           = {'1st'=>delayed_options.delete(:first) || "don't care"}
+        behavior_options[:delayed] = delayed_options unless delayed_options.empty?
+        behavior_options[:direction] = :reverse if duration && duration.sign < 0
+        return new(event_options).enum_for(event_options['dtstart'], behavior_options)
+      end
+
+      private
+
+      # オブジェクト変換オプションの遅延適用のBYYEAR要素
+      #
+      def _byyear(operation)
+        {'BYYEAR'=>_to_ical_hash(When.Residue(operation), 'year', 4)}
+      end
+
+      # オブジェクト変換オプションの遅延適用のBYDAY要素
+      #
+      def _byday(operation)
+        return {'BYDAY'=>_to_ical_hash(operation, 'day', 11)} if operation.kind_of?(When::Coordinates::Residue)
+
+        residues = []
+        result   = {}
+        byday    = {}
+
+        # イベント、日付
+        operation.split('&').each do |element|
+          element.strip!
+          case element
+          when RegisteredNoteMethods ; byday.update({nil=>element})
+          when /\A(.+?)#(.+)\z/      ; byday.update({$1=>$2})
+          when /\A[-+,\d]+\z/        ; result['BYMONTHDAY'] = element
+          else                       ; residues << element
+          end
+        end
+ 
+        # 剰余類
+        unless residues.empty?
+          residue = residues.join('&')
+          if residue =~ /\A[-+]?\d*(MO|TU|WE|TH|FR|SA|SU)\z/
+            result['BYWEEKDAY'] = residue
+          else
+            resource = When.Residue(residue)
+            if resource
+              byday.update(_to_ical_hash(resource, 'day', 11))
+            else
+              result['BYWEEKDAY'] = residue
+            end
+          end
+        end
+
+        result['BYDAY'] = byday unless byday.empty?
+        return result
+      end
+
+      # 剰余のハッシュ化
+      def _to_ical_hash(residue, unit, offset)
+        operation = ''
+        operation << "#{residue.carry < 0 ? residue.carry : residue.carry+1}*" if residue.shifted
+        operation << "#{(residue.remainder-offset+residue.units[unit]) % residue.divisor}"
+        {residue.divisor=>operation}
       end
     end
 
@@ -941,13 +1047,13 @@ module When::V
       super
 
       @child.each do |prop|
-        @dtstart = prop.dtstart if (@dtstart==nil || prop.dtstart < @dtstart)
+        @dtstart = prop.dtstart if (@dtstart.nil? || prop.dtstart < @dtstart)
         @dtstop  = prop.dtstop  unless (prop.dtstop.kind_of?(When::TimeValue) &&
                                         @dtstop.kind_of?(When::TimeValue)     &&
                                         prop.dtstop <= @dtstop)
         [prop.tzoffsetfrom, prop.tzoffsetto].each do |tz|
-          @daylight = tz if (@daylight==nil || tz.universal_time < @daylight.universal_time)
-          @standard = tz if (@standard==nil || tz.universal_time > @standard.universal_time)
+          @daylight = tz if (@daylight.nil? || tz.universal_time < @daylight.universal_time)
+          @standard = tz if (@standard.nil? || tz.universal_time > @standard.universal_time)
         end
       end
       @tz_difference = @standard.universal_time - @daylight.universal_time
@@ -1001,7 +1107,7 @@ module When::V
         date = prop.enum_for(current_time, direction, 1).succ
         if (date)
           diff = (date.universal_time - current_time).abs
-          if (minimum == nil || minimum > diff)
+          if (minimum.nil? || minimum > diff)
             event   = date 
             minimum = diff
           end
@@ -1065,6 +1171,7 @@ module When::V
         @options = When::Parts::Enumerator._options(args)
         @exdate  = @options.delete(:exdate)
         @exevent = @options.delete(:exevent)
+        @delayed = @options.delete(:delayed)
         @parent, @rule, @dtstart, @duration, *rest = args
         @dtstart = When.when?(@dtstart)
         @rule    = self.class._decode_rule(@rule, @dtstart) if (@rule.kind_of?(String))
@@ -1267,7 +1374,7 @@ module When::V
               position = rule[(by_part == 'BYYEAR') ? 'YEARPOS' : 'DAYPOS'][ref]
               start    = rule[(by_part == 'BYYEAR') ? 'YEARST'  : 'DAYST' ][ref]
               rule[by_part][ref] = ((ref.to_i==0) ? Logic::Enumerator :
-                                                    Logic::Residue).new(by_part, list, position, ref, start)
+                                                    Logic::Residue).new(by_part, list, position, ref, start, dtstart)
             end
           end
         end
@@ -1295,7 +1402,7 @@ module When::V
         if (dtstart && dtstart.has_time?)
           ['HOUR', 'MINUTE', 'SECOND'].each do |part|
             by_part = 'BY' + part
-            if (rule[by_part]==nil && freq_index && freq_index < PostFreqIndex[by_part])
+            if (rule[by_part].nil? && freq_index && freq_index < PostFreqIndex[by_part])
               base = dtstart[PostFreqIndex[by_part]]
               rule[by_part] = Logic.const_get(part.capitalize).new(by_part, base) unless (base == 0)
             end
@@ -1457,7 +1564,7 @@ module When::V
           end
 
           # @private
-          def initialize(by_part, list, position, ref, start)
+          def initialize(by_part, list, position, ref, start, dtstart)
             @by_part = by_part
             divisor  = When::Coordinates::Pair._en_number(ref)
             @list    = list.split(/,/).map {|w|
@@ -1497,7 +1604,7 @@ module When::V
               nth, spec, period = ord
               shift = (period[PostFreqIndex[@by_part]] != 0)
               raise ArgumentError, "n*e+/-s format not permitted" if (nth || shift) && @freq_index >= When::DAY
-              if (nth==nil || nth>0)
+              if (nth.nil? || nth>0)
                 enum = @ref.enum_for(lower_bound, :forward, {:event=>spec})
               else
                 enum = @ref.enum_for(higher_bound, :reverse, {:event=>spec})
@@ -1519,9 +1626,19 @@ module When::V
           end
 
           # @private
-          def initialize(by_part, list, position, ref, start)
+          def initialize(by_part, list, position, ref, start, dtstart)
             @by_part = by_part
-            @ref     = When.Resource(ref, '_n:')
+            @ref =
+              if ref
+                When.Resource(ref, '_n:')
+              else
+                method = list[/\A[^-+\d]+/]
+                if dtstart.frame.note.respond_to?(method)
+                  dtstart.frame.note
+                else
+                  When.Resource(When::V::Event::RegisteredNotes[method], '_n:')
+                end
+              end
             @start   = start
             @list    = list.split(/,/).map {|w|
               raise ArgumentError, "The #{by_part} rule format error" unless w =~ /\A(([-+]?\d+)\*)?(.+?)([-+]\d+)?\z/

data/lib/when_exe/inspect.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 =begin
-  Copyright (C) 2011-2015 Takashi SUGA
+  Copyright (C) 2011-2021 Takashi SUGA
 
   You may use and/or modify this file according to the license described in the LICENSE.txt file included in this archive.
 =end
@@ -75,7 +75,7 @@ module When
     # @return [String] to_h 結果を JSON文字列化したもの
     #
     def to_json(options={})
-      options[:method] = :to_m17n unless options.key?(:method)
+      options[:method] = :to_m17n unless options.respond_to?(:key?) && options.key?(:method)
       JSON.dump(to_h(options))
     end
 
@@ -603,7 +603,7 @@ module When
         form_options[:method] = :to_m17n unless form_options.key?(:method)
         persistence = options.delete(:persistence) if options.kind_of?(Hash)
         retrieved   = When::CalendarNote::NotesContainer.retrieve(persistence, self.to_i)
-        return retrieved unless retrieved == false
+        return retrieved if retrieved
         When::CalendarNote::NotesContainer.register(_m17n_form(_notes(options), form_options), persistence, self.to_i)
       end
 
@@ -773,7 +773,7 @@ module When
       # @return [String]
       #
       def _to_uri(date)
-        (date.gsub(/\./, '-').gsub(/%/, '@') + caret_frame).
+        (date.gsub(/%/, '@').sub(/(\d{2}:\d{2}:\d{2})\.(\d+)/, '\1%2E\2').gsub(/\./, '-') + caret_frame).
           gsub(When::Parts::Resource::IRIEncode) {|c| When::Parts::Resource::IRIEncodeTable[c]}
       end
 
@@ -1460,7 +1460,7 @@ module When
       # 出力に使用する clk_time の作成
       def _clk_time_for_inspect(precision)
         return @clk_time unless precision && precision > When::DAY
-        base = self + When::TM::Duration.new(@clk_time.frame._round_value(precision))
+        base = self + When::TM::PeriodDuration.new(0.5, precision)
         base.clk_time.clk_time[When::HOUR] = @clk_time.clk_time[When::HOUR] + 1 unless self.to_i == base.to_i
         return base.clk_time
       end

data/lib/when_exe/linkeddata.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 =begin
-  Copyright (C) 2014-2015 Takashi SUGA
+  Copyright (C) 2014-2021 Takashi SUGA
 
   You may use and/or modify this file according to the license described in the LICENSE.txt file included in this archive.
 =end
@@ -15,6 +15,7 @@ module When
 
     Schema = {
       'reference'       => "Locale#reference-instance_method",
+      'dbpedia'         => "Locale#dbpedia-instance_method",
       'label'           => "BasicTypes/M17n#label-instance_method",
       'prev'            => "TM/TemporalPosition#prev-instance_method",
       'succ'            => "TM/TemporalPosition#succ-instance_method",
@@ -23,7 +24,6 @@ module When
       'coordinate'      => "TM/CalDate#cal_date-instance_method",
       'sdn'             => "TM/CalDate#to_i-instance_method",
       'calendarEra'     => "TM/CalDate#calendar_era-instance_method",
-      'referenceEvent'  => "TM/Clock#reference_event-instance_method",
       'referenceTime'   => "TM/Clock#reference_time-instance_method",
       'utcReference'    => "TM/Clock#utc_reference-instance_method",
       'dateBasis'       => "TM/Clock#date_basis-instance_method",
@@ -40,12 +40,19 @@ module When
       'latitude'        => "Coordinates/Spatial#latitude-instance_method",
       'altitide'        => "Coordinates/Spatial#latitude-instance_method",
       'event'           => "CalendarNote#event-instance_method",
+      'note'            => "CalendarNote/NoteElement",
+      'id'              => "Events/Event#id-instance_method",
+      'group'           => "Events/Event#group-instance_method",
+      'start'           => "Events/Range#start-instance_method",
+      'until'           => "Events/Range#until-instance_method",
+      'west'            => "Coordinates/Spatial/Range#west-instance_method",
+      'east'            => "Coordinates/Spatial/Range#east-instance_method",
+      'south'           => "Coordinates/Spatial/Range#south-instance_method",
+      'north'           => "Coordinates/Spatial/Range#north-instance_method",
+      'bottom'          => "Coordinates/Spatial/Range#bottom-instance_method",
+      'top'             => "Coordinates/Spatial/Range#top-instance_method"
     }
 
-    XSD  = 'http://www.w3.org/2001/XMLSchema'
-    RDFS = 'http://www.w3.org/2000/01/rdf-schema#'
-    RDF  = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#'
-
     #
     # @private
     #
@@ -85,8 +92,9 @@ module When
       def schema(iri=nil)
         ts = base_uri.sub(/When\/$/, 'ts#')
         hash =
-          {'@context'=>{'ts' => ts},
-           '@graph'  => Schema.keys.map {|id| {'@id'=>'ts:'+id, 'ts:reference'=>{'@id'=>DocRoot + Schema[id]}}}
+          {'@context'=>{'rdf'=>When::Namespace::RDF, 'ts' => ts},
+           '@graph'  => Schema.keys.map {|id| {'@id'=>'ts:'+id, 'rdf:type'=>{'@id'=>'rdf:Property'},
+                                               'ts:reference'=>{'@id'=>DocRoot + Schema[id]}}}
           }
         bless(hash, iri || ts[0..-2])
       end
@@ -117,7 +125,7 @@ module When
           JSON.generate(jsonld_hash)
         else
           array = JSON::LD::API.toRdf(jsonld_hash)
-          graph = ::RDF::Graph.new << array
+          graph = RDF::Graph.new << array
           args  = [writer]
           args << {:prefixes=>prefixes} if prefixes
           graph.dump(*args)
@@ -162,13 +170,13 @@ module When
       def namespace_prefixes(*resources)
         base = base_uri.sub(/When\/$/, '')
         resources.inject({
-          'xsd'  => [XSD],
-          'rdf'  => [RDF],
-          'rdfs' => [RDFS],
-          'owl'  => ['http://www.w3.org/2002/07/owl#'],
-          'dc'   => ['http://purl.org/dc/elements/1.1/'],
-          'dcq'  => ['http://purl.org/dc/terms/'],
-          'dct'  => ['http://purl.org/dc/dcmitype/'],
+          'xsd'  => [When::Namespace::XSD ],
+          'rdf'  => [When::Namespace::RDF ],
+          'rdfs' => [When::Namespace::RDFS],
+          'owl'  => [When::Namespace::OWL ],
+          'dc'   => [When::Namespace::DC  ],
+          'dcq'  => [When::Namespace::DCQ ],
+          'dct'  => [When::Namespace::DCT ],
         # 'tp'   => [base + 'tp/'],
           'ts'   => [base + 'ts#']
         }) {|namespace, resource|
@@ -315,6 +323,8 @@ module When
         hash[key] = value if /^@/ =~ key.to_s
       end
       hash[RDF + 'type'] = {'@id'=>base + 'ts/' + self.class.to_s.gsub(/::/, '/')}
+      hash[RDFS + 'subPropertyOf'] = {'@id'=>base + 'ts#note'} if kind_of?(When::CalendarNote::NoteElement) ||
+                                                                  kind_of?(When::Parts::Resource) && /\/notes\// =~ iri && !leaf?
       if options[:context]
         options[:prefixes] ||= When::Parts::Resource.namespace_prefixes
         context = hash['@context'] || {}
@@ -369,18 +379,20 @@ module When
     # namespace を prefix にコンパクト化する
     #
     def compact_namespace_to_prefix(source, prefixes, context=nil)
+      return source.map {|element| compact_namespace_to_prefix(element, prefixes, context)} if source.kind_of?(Array)
       return source unless prefixes
       prefixes.each_pair do |key, value|
-        Array(value).each do |prefix|
-          start = source.index(prefix)
-          body  = source[prefix.length..-1]
+        Array(value).each do |namespace|
+          namespace = namespace.sub(/([a-z0-9])\z/i, '\1#')
+          start     = source.index(namespace)
+          body      = source[namespace.length..-1]
           return key + ':' + body if start == 0 && body !~ /[:#\/]/
         end
       end
       return source unless context
       source =~ /\A((.+)([:#\/]))([^:#\/]+)\z/
       namespace, item = $1.to_s, $4
-      if namespace =~ /^Ahttp:\/\/([^.]+)\.wikipedia\.org/
+      if namespace =~ /^Ahttps?:\/\/([^.]+)\.wikipedia\.org/
         prefix = "wiki_#{$1}"
       elsif namespace && namespace.index(When::Parts::Resource.base_uri) == 0
         label  = begin When.Resource(namespace.sub(/::\z/, '')) rescue return source end
@@ -421,7 +433,8 @@ module When
       hash = {}
       hash[RDFS + 'label'] = names.keys.map {|key| key=='' ? names[key] : {'@language'=>key, '@value'=>names[key]}}
       hash[ts   + 'label'] = label
-      hash[ts   + 'reference'] = link.values.map {|ref| {'@id'=>ref}}
+      hash[ts   + 'reference'] = link.values.uniq.map {|ref| {'@id'=>ref}}
+      hash[ts   + 'dbpedia']   = link.values.uniq.map {|ref| Locale._dbpedia(ref)}.compact.map {|uri| {'@id'=>uri}}
       hash
     end
   end
@@ -458,7 +471,7 @@ module When
     #
     def to_uri_linkeddata(*args)
       date, frame = _to_uri(to_s(*args)).split('^^', 2)
-      frame += '_' if frame =~ /\d\z/
+      frame += '_' if /\d\z/ =~ frame
       date = "#{frame}(#{date})" if frame
       When::Parts::Resource.base_uri.sub(/When\/$/, 'tp/') + date
     end
@@ -562,7 +575,14 @@ module When
           value =_value_str(note[:note], note[:value])
         end
         id    = compact_namespace_to_prefix(value, options[:prefixes], context)
-        hash[compact_namespace_to_prefix(_note_str(note[:note]), options[:prefixes], context)] = (id == value && id !~ /:\/\//) ? id : {'@id'=>id}
+        if id.kind_of?(Array)
+          (0...id.length).each do |i|
+            id[i] = {'@id'=>id[i]} unless id[i] == value[i] && id[i] !~ /:\/\//
+          end
+        else
+          id = {'@id'=>id} unless id == value && id !~ /:\/\//
+        end
+        hash[compact_namespace_to_prefix(_note_str(note[:note]), options[:prefixes], context)] = id
       end
       hash
     end