et-orbi 0.9.5 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f0b0845026be5ba2ba99cd43c9e91707a5167cc9
-  data.tar.gz: cf5a240deda4fc762680ed76ced5577d60d99f90
+  metadata.gz: 603e93e83b1b3cff5b845a4de08563334e711ab4
+  data.tar.gz: 1c0f23f0b899708d5f38054b934ec72bd79f2411
 SHA512:
-  metadata.gz: 1ea3c04b92874cf22162ae67b80028845ecabb64e582444161b1a088e1dfcc521c60f7fbfce41b664a8054b1b9e807d6174b4a386c88104619f213b350331fa5
-  data.tar.gz: a76d3b266adfabbfc6010b21457d28d80c2a4945c138f791bd931ad999eda0126692ef07771ec3d7929e4d34f64ca3faaaee6446baefb3c8531ba0ce6a9e224f
+  metadata.gz: af80e0afd204638d24c8296335a91c7965ccb8cc63f9ec28c2c4dbc8070e15bb08343d6538fd88e219b8648741c1aed9b8c424b9ee649e2a49218f2df2a2a651
+  data.tar.gz: 3fd429a30a7a0549ced3e301a877eb39b7e4739243506998b1b068d038da7fa3279f4560e2a847bea1183872b2a0bb0b0c35b7fd1c8bb7d71372017ae4108a80

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+
+# et-orbi CHANGELOG.md
+
+
+## et-orbi 1.0.0  not yet released
+
+- First release for rufus-scheduler
+
+
+## et-orbi 0.9.5  released 2017-03-17
+
+- Empty, initial release, 圓さんの家で
+

data/cases.txt

@@ -0,0 +1,15 @@
+
+ZoTime.get_tzone(items.last)
+ZoTime.get_tzone(:current)
+
+t = ZoTime.new(time.to_f, @timezone)
+zt = ZoTime.new(from.to_i + 1, @timezone)
+
+ZoTime.now
+
+stderr.puts("#{pre} local_tzone: #{Rufus::Scheduler::ZoTime.local_tzone.inspect}")
+
+@first_at = ZoTime.make(first)
+@last_at = last ? ZoTime.make(last) : nil
+return Rufus::Scheduler::ZoTime.make(o) if o.is_a?(Time)
+

data/lib/et-orbi.rb

@@ -1,6 +1,552 @@
 
+require 'date' if RUBY_VERSION < '1.9.0'
+require 'time'
+
+require 'tzinfo'
+
+
 module EtOrbi
 
-  VERSION = '0.9.5'
+  VERSION = '1.0.0'
+
+  class EoTime
+
+    #
+    # class methods
+
+    def self.now(zone=nil)
+
+      EoTime.new(Time.now.to_f, zone)
+    end
+
+    def self.parse(str, opts={})
+
+      if defined?(::Chronic) && t = ::Chronic.parse(str, opts)
+        return EoTime.new(t, nil)
+      end
+
+      #rold = RUBY_VERSION < '1.9.0'
+      #rold = RUBY_VERSION < '2.0.0'
+
+#p [ '---', str ]
+      begin
+        DateTime.parse(str)
+      rescue
+        fail ArgumentError, "no time information in #{str.inspect}"
+      end #if rold
+        #
+        # is necessary since Time.parse('xxx') in Ruby < 1.9 yields `now`
+
+      zone = izone = get_tzone(list_iso8601_zones(str).last)
+
+      list_olson_zones(str).each { |s| break if zone; zone = get_tzone(s) }
+
+      zone ||= local_tzone
+
+      str = str.sub(zone.name, '') unless zone.name.match(/\A[-+]/)
+        #
+        # for 'Sun Nov 18 16:01:00 Asia/Singapore 2012',
+        # although where does rufus-scheduler have it from?
+
+      local = Time.parse(str)
+
+      secs =
+        if izone
+          local.to_f
+        else
+          zone.period_for_local(local).to_utc(local).to_f
+        end
+
+      EoTime.new(secs, zone)
+    end
+
+    def self.time_to_eo_time(t)
+
+      z =
+        get_tzone(t.zone) ||
+        (
+          local_tzone.period_for_local(t).abbreviation.to_s == t.zone &&
+          local_tzone
+        ) ||
+        t.zone
+
+      EoTime.new(t.to_f, z)
+    end
+
+    def self.make(o)
+
+      ot =
+        case o
+        when Time
+          time_to_eo_time(
+            o)
+        when Date
+          time_to_eo_time(
+            o.respond_to?(:to_time) ?
+            o.to_time :
+            Time.parse(o.strftime('%Y-%m-%d %H:%M:%S')))
+        when String
+          #Rufus::Scheduler.parse_in(o, :no_error => true) || self.parse(o)
+          parse(o)
+        else
+          o
+        end
+
+      ot = EoTime.new(Time.now.to_f + ot, nil) if ot.is_a?(Numeric)
+
+      fail ArgumentError.new(
+        "cannot turn #{o.inspect} to a EoTime instance"
+      ) unless ot.is_a?(EoTime)
+
+      ot
+    end
+
+    def self.to_offset(n)
+
+      i = n.to_i
+      sn = i < 0 ? '-' : '+'; i = i.abs
+      hr = i / 3600; mn = i % 3600; sc = i % 60
+      (sc > 0 ? "%s%02d:%02d:%02d" : "%s%02d:%02d") % [ sn, hr, mn, sc ]
+    end
+
+    def self.get_tzone(o)
+
+#p [ :gtz, o ]
+      return nil if o == nil
+      return local_tzone if o == :local
+      return o if o.is_a?(::TZInfo::Timezone)
+      return ::TZInfo::Timezone.get('Zulu') if o == 'Z'
+
+      o = to_offset(o) if o.is_a?(Numeric)
+
+      return nil unless o.is_a?(String)
+
+      (@custom_tz_cache ||= {})[o] ||
+      get_offset_tzone(o) ||
+      (::TZInfo::Timezone.get(o) rescue nil)
+    end
+
+    def self.get_offset_tzone(str)
+
+      # custom timezones, no DST, just an offset, like "+08:00" or "-01:30"
+
+      m = str.match(/\A([+-][0-1][0-9]):?([0-5][0-9])?\z/)
+      return nil unless m
+
+      hr = m[1].to_i
+      mn = m[2].to_i
+
+      hr = nil if hr.abs > 11
+      hr = nil if mn > 59
+      mn = -mn if hr && hr < 0
+
+      return (
+        @custom_tz_cache[str] =
+          begin
+            tzi = TZInfo::TransitionDataTimezoneInfo.new(str)
+            tzi.offset(str, hr * 3600 + mn * 60, 0, str)
+            tzi.create_timezone
+          end
+      ) if hr
+
+      nil
+    end
+
+    def self.local_tzone
+
+      @local_tzone = nil \
+        if @local_tzone_loaded_at && (Time.now > @local_tzone_loaded_at + 1800)
+      @local_tzone = nil \
+        if @local_tzone_tz != ENV['TZ']
+
+      @local_tzone ||=
+        begin
+          @local_tzone_tz = ENV['TZ']
+          @local_tzone_loaded_at = Time.now
+          determine_local_tzone
+        end
+    end
+
+    def self.determine_local_tzone
+
+      etz = ENV['TZ']
+
+      tz = ::TZInfo::Timezone.get(etz) rescue nil
+      return tz if tz
+
+      tz = Time.zone.tzinfo \
+        if Time.respond_to?(:zone) && Time.zone.respond_to?(:tzinfo)
+      return tz if tz
+
+      tzs = determine_local_tzones
+
+      (etz && tzs.find { |z| z.name == etz }) || tzs.first
+    end
+
+    def self.determine_local_tzones
+
+      tabbs = (-6..5)
+        .collect { |i| (Time.now + i * 30 * 24 * 3600).zone }
+        .uniq
+        .sort
+
+      t = Time.now
+      tu = t.dup.utc # /!\ dup is necessary, #utc modifies its target
+
+      twin = Time.utc(t.year, 1, 1) # winter
+      tsum = Time.utc(t.year, 7, 1) # summer
+
+      ::TZInfo::Timezone.all.select do |tz|
+
+        pabbs =
+          [
+            tz.period_for_utc(twin).abbreviation.to_s,
+            tz.period_for_utc(tsum).abbreviation.to_s
+          ].uniq.sort
+
+        pabbs == tabbs
+      end
+    end
+
+    # https://en.wikipedia.org/wiki/ISO_8601
+    # Postel's law applies
+    #
+    def self.list_iso8601_zones(s)
+
+      s.scan(
+        %r{
+          (?<=:\d\d)
+          \s*
+          (?:
+            [-+]
+            (?:[0-1][0-9]|2[0-4])
+            (?:(?::)?(?:[0-5][0-9]|60))?
+            (?![-+])
+            |
+            Z
+          )
+        }x
+        ).collect(&:strip)
+    end
+
+    def self.list_olson_zones(s)
+
+      s.scan(
+        %r{
+          (?<=\s|\A)
+          (?:[A-Za-z][A-Za-z0-9+_-]+)
+          (?:\/(?:[A-Za-z][A-Za-z0-9+_-]+)){0,2}
+        }x)
+    end
+
+    def self.platform_info
+
+      etos = Proc.new { |k, v| "#{k}:#{v.inspect}" }
+
+      '(' +
+        {
+          'etz' => ENV['TZ'],
+          'tnz' => Time.now.zone,
+          'tzid' => defined?(TZInfo::Data),
+          'rv' => RUBY_VERSION,
+          'rp' => RUBY_PLATFORM,
+          'eov' => EtOrbi::VERSION,
+        }.collect(&etos).join(',') + ',' +
+        gather_tzs.collect(&etos).join(',') +
+      ')'
+    end
+
+    #def in_zone(&block)
+    #
+    #  current_timezone = ENV['TZ']
+    #  ENV['TZ'] = @zone
+    #
+    #  block.call
+    #
+    #ensure
+    #
+    #  ENV['TZ'] = current_timezone
+    #end
+      #
+      # kept around as a (thread-unsafe) relic
+
+    #
+    # instance methods
+
+    attr_reader :seconds
+    attr_reader :zone
+
+    def initialize(s, zone)
+
+      @seconds = s.to_f
+      @zone = self.class.get_tzone(zone || :local)
+
+      #fail ArgumentError.new(
+      #  "cannot determine timezone from #{zone.inspect}" +
+      #  " (etz:#{ENV['TZ'].inspect},tnz:#{Time.now.zone.inspect}," +
+      #  "tzid:#{defined?(TZInfo::Data).inspect}," +
+      #  "rv:#{RUBY_VERSION.inspect},rp:#{RUBY_PLATFORM.inspect}," +
+      #  "stz:(#{self.class.gather_tzs.map { |k, v| "#{k}:#{v.inspect}"}.join(',')})) \n" +
+      #  "Try setting `ENV['TZ'] = 'Continent/City'` in your script " +
+      #  "(see https://en.wikipedia.org/wiki/List_of_tz_database_time_zones)" +
+      #  (defined?(TZInfo::Data) ? '' : " and adding 'tzinfo-data' to your gems")
+      #) unless @zone
+      fail ArgumentError.new(
+        "cannot determine timezone from #{zone.inspect}" +
+        "\n#{self.class.platform_info}" +
+        "\nTry setting `ENV['TZ'] = 'Continent/City'` in your script " +
+        "(see https://en.wikipedia.org/wiki/List_of_tz_database_time_zones)" +
+        (defined?(TZInfo::Data) ? '' : "\nand adding gem 'tzinfo-data'")
+      ) unless @zone
+
+      @time = nil # cache for #to_time result
+    end
+
+    def seconds=(f)
+
+      @time = nil
+      @seconds = f
+    end
+
+    def zone=(z)
+
+      @time = nil
+      @zone = self.class.get_tzone(zone || :current)
+    end
+
+    def utc
+
+      Time.utc(1970, 1, 1) + @seconds
+    end
+
+    alias getutc utc
+    alias getgm utc
+
+    def to_f
+
+      @seconds
+    end
+
+    def to_i
+
+      @seconds.to_i
+    end
+
+    def strftime(format)
+
+      format = format.gsub(/%(\/?Z|:{0,2}z)/) { |f| strfz(f) }
+
+      to_time.strftime(format)
+    end
+
+    # Returns a Ruby Time instance.
+    #
+    # Warning: the timezone of that Time instance will be UTC.
+    #
+    def to_time
+
+      @time ||= begin; u = utc; @zone.period_for_utc(u).to_local(u); end
+    end
+
+    def is_dst?
+
+      @zone.period_for_utc(utc).std_offset != 0
+    end
+    alias isdst is_dst?
+
+    def to_debug_s
+
+      uo = self.utc_offset
+      uos = uo < 0 ? '-' : '+'
+      uo = uo.abs
+      uoh, uom = [ uo / 3600, uo % 3600 ]
+
+      [
+        'ot',
+        self.strftime('%Y-%m-%d %H:%M:%S'),
+        "%s%02d:%02d" % [ uos, uoh, uom ],
+        "dst:#{self.isdst}"
+      ].join(' ')
+    end
+
+    def utc_offset
+
+      #@zone.period_for_utc(utc).utc_offset
+      #@zone.period_for_utc(utc).utc_total_offset
+      #@zone.period_for_utc(utc).std_offset
+      @zone.period_for_utc(utc).utc_offset
+    end
+
+    %w[
+      year month day wday hour min sec usec asctime
+    ].each do |m|
+      define_method(m) { to_time.send(m) }
+    end
+    def iso8601(fraction_digits=0); to_time.iso8601(fraction_digits); end
+
+    def ==(o)
+
+      o.is_a?(EoTime) && o.seconds == @seconds && o.zone == @zone
+    end
+    #alias eq? == # FIXME see Object#== (ri)
+
+    def >(o); @seconds > _to_f(o); end
+    def >=(o); @seconds >= _to_f(o); end
+    def <(o); @seconds < _to_f(o); end
+    def <=(o); @seconds <= _to_f(o); end
+    def <=>(o); @seconds <=> _to_f(o); end
+
+    def add(t); @time = nil; @seconds += t.to_f; end
+    def subtract(t); @time = nil; @seconds -= t.to_f; end
+
+    def +(t); inc(t, 1); end
+    def -(t); inc(t, -1); end
+
+    WEEK_S = 7 * 24 * 3600
+
+    def monthdays
+
+      date = to_time
+
+      pos = 1
+      d = self.dup
+
+      loop do
+        d.add(-WEEK_S)
+        break if d.month != date.month
+        pos = pos + 1
+      end
+
+      neg = -1
+      d = self.dup
+
+      loop do
+        d.add(WEEK_S)
+        break if d.month != date.month
+        neg = neg - 1
+      end
+
+      [ "#{date.wday}##{pos}", "#{date.wday}##{neg}" ]
+    end
+
+    def to_s
+
+      strftime('%Y-%m-%d %H:%M:%S %z')
+    end
+
+    # Debug current time by showing local time / delta / utc time
+    # for example: "0120-7(0820)"
+    #
+    def to_utc_comparison_s
+
+      per = @zone.period_for_utc(utc)
+      off = per.utc_total_offset
+
+      off = off / 3600
+      off = off >= 0 ? "+#{off}" : off.to_s
+
+      strftime('%H%M') + off + utc.strftime('(%H%M)')
+    end
+
+    def to_time_s
+
+      strftime("%H:%M:%S.#{'%06d' % usec}")
+    end
+
+    #
+    # protected
+
+    def strfz(code)
+
+      return @zone.name if code == '%/Z'
+
+      per = @zone.period_for_utc(utc)
+
+      return per.abbreviation.to_s if code == '%Z'
+
+      off = per.utc_total_offset
+        #
+      sn = off < 0 ? '-' : '+'; off = off.abs
+      hr = off / 3600
+      mn = (off % 3600) / 60
+      sc = 0
+
+      fmt =
+        if code == '%z'
+          "%s%02d%02d"
+        elsif code == '%:z'
+          "%s%02d:%02d"
+        else
+          "%s%02d:%02d:%02d"
+        end
+
+      fmt % [ sn, hr, mn, sc ]
+    end
+
+    def inc(t, dir)
+
+      if t.is_a?(Numeric)
+        nt = self.dup
+        nt.seconds += dir * t.to_f
+        nt
+      elsif t.respond_to?(:to_f)
+        @seconds + dir * t.to_f
+      else
+        fail ArgumentError.new(
+          "cannot call EoTime #- or #+ with arg of class #{t.class}")
+      end
+    end
+
+    def _to_f(o)
+
+      fail ArgumentError(
+        "comparison of EoTime with #{o.inspect} failed"
+      ) unless o.is_a?(EoTime) || o.is_a?(Time)
+
+      o.to_f
+    end
+
+    #
+    # system tz determination
+
+    def self.debian_tz
+
+      path = '/etc/timezone'
+
+      File.exist?(path) ? File.read(path).strip : nil
+    rescue; nil; end
+
+    def self.centos_tz
+
+      path = '/etc/sysconfig/clock'
+
+      File.open(path, 'rb') do |f|
+        until f.eof?
+          if m = f.readline.match(/ZONE="([^"]+)"/); return m[1]; end
+        end
+      end if File.exist?(path)
+
+      nil
+    rescue; nil; end
+
+    def self.osx_tz
+
+      path = '/etc/localtime'
+
+      File.symlink?(path) ?
+        File.readlink(path).split('/')[4..-1].join('/') :
+        nil
+    rescue; nil; end
+
+#    def self.find_tz
+#
+#      debian_tz || centos_tz || osx_tz
+#    end
+
+    def self.gather_tzs
+
+      { :debian => debian_tz, :centos => centos_tz, :osx => osx_tz }
+    end
+  end
 end