et-orbi 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b59057ba3391277520b52cedaaca8c8beca1805f
-  data.tar.gz: 8c2100802014372e3b7cf7c8a1ca9a4c4baff5fe
+  metadata.gz: 4c7c982477f7068d7be62fbb84846f81de496a87
+  data.tar.gz: ec767fc4ce7efd5413d17b5cd90f69f9cc1dc6cd
 SHA512:
-  metadata.gz: 573c6898345ba811080c7975045ddd87ca8ddc5a65d0c2893475d15eb829c60e343ced79dc20823ea676bc440999c61b6d8e395d5c10aa9ee35f085a73ecfda0
-  data.tar.gz: c48b752e6e0ccc717d9a1103b63f075f2e80cd0837d3494fb1e03d3083c6c3db637919cda3d85ae3b05b72a10f30d266ec97bc7fef78fb6c16b3acfb1d84fc1f
+  metadata.gz: ea3c1d4c24633d9820a1e9c58b30e9b0e418c91c9eda5308c20782210c4b041500df882a466e327e6110be1323966e64eaaf291aa12288e87cd96619f88bba91
+  data.tar.gz: ee248987a931f7ec23c58048b45f6970d082046656d790a2eb8c4fccec14ee1c58ff56484fba0e9cd0e18ae51ed452579e7909582de9d51c9e664f63b6fda090

data/CHANGELOG.md

@@ -2,6 +2,12 @@
 # et-orbi CHANGELOG.md
 
 
+## et-orbi 1.0.2  released 2017-03-24
+
+- Enhance no zone ArgumentError data
+- Separate module methods from EoTime methods
+
+
 ## et-orbi 1.0.1  released 2017-03-22
 
 - Detail Rails and Active Support info in nozone err

data/README.md

@@ -6,6 +6,54 @@
 
 Time zones for [fugit](https://github.com/floraison/fugit) and for [rufus-scheduler](https://github.com/jmettraux/rufus-scheduler). Urbi et Orbi.
 
+`EtOrbi::EoTime` instances quack like Ruby `Time` instances, but their `#zone` returns a `TZInfo::TimeZone` instance.
+
+Getting `EoTime` instances:
+```ruby
+require 'et-orbi'
+
+EtOrbi.now
+  # => #<EtOrbi::EoTime:0x007f94d94 ...>
+EtOrbi.parse('2017-12-13 13:00:00 America/Jamaica')
+  # => #<EtOrbi::EoTime:0x007f94d90 @zone=#<TZInfo::DataTimezone: America/Jamaica>...>
+EtOrbi.make_time(Time.now)
+  # => #<EtOrbi::EoTime:0x007f94d91 ...>
+
+EtOrbi::EoTime.new(0, 'UTC').to_s
+  # => "1970-01-01 00:00:00 +0000"
+EtOrbi::EoTime.new(0, 'Europe/Moscow').to_s
+  # => "1970-01-01 03:00:00 +0300"
+```
+
+Helper methods:
+```ruby
+require 'et-orbi'
+
+EtOrbi.get_tzone('Europe/Vilnius')
+  # => #<TZInfo::DataTimezone: Europe/Vilnius>
+EtOrbi.local_tzone
+  # => #<TZInfo::TimezoneProxy: Asia/Tokyo>
+
+EtOrbi.platform_info
+  # => "(etz:nil,tnz:\"JST\",tzid:nil,rv:\"2.2.6\",rp:\"x86_64-darwin14\",eov:\"1.0.1\",
+  #      rorv:nil,astz:nil,debian:nil,centos:nil,osx:\"Asia/Tokyo\")"
+    #
+    # etz: ENV['TZ']
+    # tnz: Time.now.zone
+    # tzid: defined?(TZInfo::Data)
+    # rv: RUBY_VERSION
+    # rp: RUBY_PLATFORM
+    # eov: EtOrbi::VERSION
+    # rorv: Rails::VERSION::STRING
+    # astz: ActiveSupport provided Time.zone
+```
+
+### Rails?
+
+If Rails is present, `Time.zone` is provided and EtOrbi will use it.
+
+Rails sets its timezone under `config/application.rb`.
+
 
 ## Related projects
 

data/lib/et-orbi.rb

@@ -7,270 +7,178 @@ require 'tzinfo'
 
 module EtOrbi
 
-  VERSION = '1.0.1'
+  VERSION = '1.0.2'
 
-  class EoTime
+  #
+  # module methods
 
-    #
-    # class methods
-
-    def self.now(zone=nil)
+  def self.now(zone=nil)
 
-      EoTime.new(Time.now.to_f, zone)
-    end
+    EoTime.new(Time.now.to_f, zone)
+  end
 
-    def self.parse(str, opts={})
+  def self.parse(str, opts={})
 
-      if defined?(::Chronic) && t = ::Chronic.parse(str, opts)
-        return EoTime.new(t, nil)
-      end
+    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'
+    #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`
+    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)
+    zone = izone = get_tzone(list_iso8601_zones(str).last)
 
-      list_olson_zones(str).each { |s| break if zone; zone = get_tzone(s) }
+    list_olson_zones(str).each { |s| break if zone; zone = get_tzone(s) }
 
-      zone ||= local_tzone
+    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?
+    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)
+    local = Time.parse(str)
 
-      secs =
-        if izone
-          local.to_f
-        else
-          zone.period_for_local(local).to_utc(local).to_f
-        end
+    secs =
+      if izone
+        local.to_f
+      else
+        zone.period_for_local(local).to_utc(local).to_f
+      end
 
-      EoTime.new(secs, zone)
-    end
+    EoTime.new(secs, zone)
+  end
 
-    def self.time_to_eo_time(t)
+  def self.make_time(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
 
-      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
+    ot = EoTime.new(Time.now.to_f + ot, nil) if ot.is_a?(Numeric)
 
-    def self.make(o)
+    fail ArgumentError.new(
+      "cannot turn #{o.inspect} to a EoTime instance"
+    ) unless ot.is_a?(EoTime)
 
-      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
+  end
 
-      ot = EoTime.new(Time.now.to_f + ot, nil) if ot.is_a?(Numeric)
+  def self.get_tzone(o)
 
-      fail ArgumentError.new(
-        "cannot turn #{o.inspect} to a EoTime instance"
-      ) unless ot.is_a?(EoTime)
+#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'
 
-      ot
-    end
+    o = to_offset(o) if o.is_a?(Numeric)
 
-    def self.to_offset(n)
+    return nil unless o.is_a?(String)
 
-      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)
+    (@custom_tz_cache ||= {})[o] ||
+    get_offset_tzone(o) ||
+    (::TZInfo::Timezone.get(o) rescue nil)
+  end
 
-#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'
+  def self.local_tzone
 
-      o = to_offset(o) if o.is_a?(Numeric)
+    @local_tzone = nil \
+      if @local_tzone_loaded_at && (Time.now > @local_tzone_loaded_at + 1800)
+    @local_tzone = nil \
+      if @local_tzone_tz != ENV['TZ']
 
-      return nil unless o.is_a?(String)
+    @local_tzone ||=
+      begin
+        @local_tzone_tz = ENV['TZ']
+        @local_tzone_loaded_at = Time.now
+        determine_local_tzone
+      end
+  end
 
-      (@custom_tz_cache ||= {})[o] ||
-      get_offset_tzone(o) ||
-      (::TZInfo::Timezone.get(o) rescue nil)
-    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,
+        'rorv' => (Rails::VERSION::STRING rescue nil),
+        'astz' => Time.respond_to?(:zone) ? Time.zone.name : nil,
+          # Active Support Time.zone
+      }.collect(&etos).join(',') + ',' +
+      gather_tzs.collect(&etos).join(',') +
+    ')'
+  end
 
-    def self.get_offset_tzone(str)
+  class << self
 
-      # custom timezones, no DST, just an offset, like "+08:00" or "-01:30"
+    alias make make_time
+  end
 
-      m = str.match(/\A([+-][0-1][0-9]):?([0-5][0-9])?\z/)
-      return nil unless m
+  #
+  # our EoTime class (which quacks like a ::Time)
 
-      hr = m[1].to_i
-      mn = m[2].to_i
+  class EoTime
 
-      hr = nil if hr.abs > 11
-      hr = nil if mn > 59
-      mn = -mn if hr && hr < 0
+    #
+    # class methods
 
-      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
+    def self.now(zone=nil)
 
-      nil
+      EtOrbi.now(zone)
     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']
+    def self.parse(str, opts={})
 
-      @local_tzone ||=
-        begin
-          @local_tzone_tz = ENV['TZ']
-          @local_tzone_loaded_at = Time.now
-          determine_local_tzone
-        end
+      EtOrbi.parse(str, opts)
     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
+    def self.get_tzone(o)
 
-      (etz && tzs.find { |z| z.name == etz }) || tzs.first
+      EtOrbi.get_tzone(o)
     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
+    def self.local_tzone
 
-    # 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)
+      EtOrbi.local_tzone
     end
 
-    def self.list_olson_zones(s)
+    def self.platform_info
 
-      s.scan(
-        %r{
-          (?<=\s|\A)
-          (?:[A-Za-z][A-Za-z0-9+_-]+)
-          (?:\/(?:[A-Za-z][A-Za-z0-9+_-]+)){0,2}
-        }x)
+      EtOrbi.platform_info
     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
-
-    def self.platform_info
+    def self.make(o)
 
-      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,
-          'rorv' => (Rails::VERSION::STRING rescue nil),
-          'astz' => Time.respond_to?(:zone) ? Time.zone.name : nil,
-            # Active Support Time.zone
-        }.collect(&etos).join(',') + ',' +
-        gather_tzs.collect(&etos).join(',') +
-      ')'
+      EtOrbi.make_time(o)
     end
 
     #
@@ -286,7 +194,8 @@ module EtOrbi
 
       fail ArgumentError.new(
         "cannot determine timezone from #{zone.inspect}" +
-        "\n#{self.class.platform_info}" +
+        "\n#{render_nozone_time(s)}" +
+        "\n#{self.class.platform_info.sub(',debian:', ",\ndebian:")}" +
         "\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'")
@@ -446,8 +355,20 @@ module EtOrbi
       strftime("%H:%M:%S.#{'%06d' % usec}")
     end
 
-    #
-    # protected
+    protected
+
+    def render_nozone_time(seconds)
+
+      t =
+        Time.utc(0) + seconds
+      ts =
+        t.strftime('%Y-%m-%d %H:%M:%S') +
+        ".#{(seconds % 1).to_s.split('.').last}"
+      z =
+        EtOrbi.local_tzone.period_for_local(t).abbreviation.to_s
+
+      "(secs:#{seconds},utc~:#{ts.inspect},zo~:#{z.inspect})"
+    end
 
     def strfz(code)
 
@@ -498,48 +419,184 @@ module EtOrbi
 
       o.to_f
     end
+  end
 
-    #
-    # system tz determination
+  #
+  # not so public module methods
+
+  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.debian_tz
+  def self.to_offset(n)
 
-      path = '/etc/timezone'
+    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_offset_tzone(str)
 
-      File.exist?(path) ? File.read(path).strip : nil
-    rescue; nil; end
+    # custom timezones, no DST, just an offset, like "+08:00" or "-01:30"
 
-    def self.centos_tz
+    m = str.match(/\A([+-][0-1][0-9]):?([0-5][0-9])?\z/)
+    return nil unless m
 
-      path = '/etc/sysconfig/clock'
+    hr = m[1].to_i
+    mn = m[2].to_i
 
-      File.open(path, 'rb') do |f|
-        until f.eof?
-          if m = f.readline.match(/ZONE="([^"]+)"/); return m[1]; end
+    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
-      end if File.exist?(path)
+    ) if hr
 
-      nil
-    rescue; nil; end
+    nil
+  end
 
-    def self.osx_tz
+  def self.determine_local_tzone
 
-      path = '/etc/localtime'
+    etz = ENV['TZ']
 
-      File.symlink?(path) ?
-        File.readlink(path).split('/')[4..-1].join('/') :
-        nil
-    rescue; nil; end
+    tz = ::TZInfo::Timezone.get(etz) rescue nil
+    return tz if tz
 
-#    def self.find_tz
-#
-#      debian_tz || centos_tz || osx_tz
-#    end
+    tz = Time.zone.tzinfo \
+      if Time.respond_to?(:zone) && Time.zone.respond_to?(:tzinfo)
+    return tz if tz
+
+    tzs = determine_local_tzones
 
-    def self.gather_tzs
+    (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
 
-      { :debian => debian_tz, :centos => centos_tz, :osx => osx_tz }
+    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 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
+
+  #
+  # 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