et-orbi 1.0.4 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f05057ae10fbf427ca9254d719b8e994e1c67b6e
-  data.tar.gz: 949ba6a94e1fd23125735edfe93b619d6a4ecc96
+  metadata.gz: 69e37c4c31852fc38185e883d9c1cb061080eb6d
+  data.tar.gz: 1862219b63d16c1e79b681bd5f930a419f1da254
 SHA512:
-  metadata.gz: 0de6ce502b9344aff48161a8b32286ee1cd0bf5fd40ba8bed69b1f20d678b0c9ffd30e0868c7da7daba5aaab56df5534fa35aa7ba3dcc2c0422795061b19eb8b
-  data.tar.gz: 01e5291f4e3130ab7f9ca27b25e70f776a4fa942c3e913e68888c6dcd7715b873a420a09db6ea9708565dffc8d5aa3d3103b083212d3be366f6052bc5955a172
+  metadata.gz: 5dcab4f70ec22ef0a7c8303b14042344860df2d26ca93fc27923a52b2a87aa36c671422f73be18d432a15524d60b86945c467c1b6fdda125f8408a8bf6e64f72
+  data.tar.gz: '07203989eedf55dbfbeb40b0433060e03644760d07a8448b78f7c30af1694b173fc67e507360262a316978815cf04181c45c0264634af75f37dd492397e56d01'

data/CHANGELOG.md

@@ -2,6 +2,18 @@
 # et-orbi CHANGELOG.md
 
 
+## et-orbi 1.0.5  released 2017-06-23
+
+- Rework EtOrbi.make_time
+- Let EtOrbi.make_time accept array or array of args
+- Implement EoTime#localtime(zone=nil)
+- Move Fugit#wday_in_month into EoTime
+- Clarify #add, #subtract, #- and #+ contracts
+- Ensure #add and #subtract return `self`
+- Make #inc(seconds, direction) public
+- Implement EoTime#utc?
+
+
 ## et-orbi 1.0.4  released 2017-05-10
 
 - Survive older versions of TZInfo with poor `<=>` impl, gh-1

data/README.md

@@ -19,6 +19,9 @@ EtOrbi.parse('2017-12-13 13:00:00 America/Jamaica')
 EtOrbi.make_time(Time.now)
   # => #<EtOrbi::EoTime:0x007f94d91 ...>
 
+EtOrbi.make_time(2017, 1, 31, 12, 'Europe/Moscow').to_debug_s
+  # => 'ot 2017-01-31 12:00:00 +03:00 dst:false'
+
 EtOrbi::EoTime.new(0, 'UTC').to_s
   # => "1970-01-01 00:00:00 +0000"
 EtOrbi::EoTime.new(0, 'Europe/Moscow').to_s

data/lib/et-orbi.rb

@@ -7,137 +7,178 @@ require 'tzinfo'
 
 module EtOrbi
 
-  VERSION = '1.0.4'
+  VERSION = '1.0.5'
 
   #
   # module methods
 
-  def self.now(zone=nil)
-
-    EoTime.new(Time.now.to_f, zone)
-  end
+  class << self
 
-  def self.parse(str, opts={})
+    def now(zone=nil)
 
-    if defined?(::Chronic) && t = ::Chronic.parse(str, opts)
-      return EoTime.new(t, nil)
+      EoTime.new(Time.now.to_f, zone)
     end
 
-    #rold = RUBY_VERSION < '1.9.0'
-    #rold = RUBY_VERSION < '2.0.0'
+    def parse(str, opts={})
 
-#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`
+      if defined?(::Chronic) && t = ::Chronic.parse(str, opts)
+        return EoTime.new(t, nil)
+      end
 
-    zone = izone = get_tzone(list_iso8601_zones(str).last)
+      #rold = RUBY_VERSION < '1.9.0'
+      #rold = RUBY_VERSION < '2.0.0'
+      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`
 
-    list_olson_zones(str).each { |s| break if zone; zone = get_tzone(s) }
+      str_zone = get_tzone(list_iso8601_zones(str).last)
 
-    zone ||= local_tzone
+      zone =
+        opts[:zone] ||
+        str_zone ||
+        find_olson_zone(str) ||
+        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 str_zone
+          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 make_time(*a)
 
-  def self.make_time(o)
+#p a
+      zone = a.length > 1 ? get_tzone(a.last) : nil
+      a.pop if zone
+#p [ :mt, zone ]
+
+      o = a.length > 1 ? a : a.first
+#p 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
+      when Time then make_from_time(o, zone)
+      when Date then make_from_date(o, zone)
+      when Array then make_from_array(o, zone)
+      when String then make_from_string(o, zone)
+      when Numeric then make_from_numeric(o, zone)
+      when ::EtOrbi::EoTime then make_from_eotime(o, zone)
+      else fail ArgumentError.new(
+        "cannot turn #{o.inspect} to a ::EtOrbi::EoTime instance")
       end
+    end
+
+    def make_from_time(t, zone)
+
+      z =
+        zone ||
+        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 make_from_date(d, zone)
 
-    fail ArgumentError.new(
-      "cannot turn #{o.inspect} to a EoTime instance"
-    ) unless ot.is_a?(EoTime)
+      make_from_time(
+        d.respond_to?(:to_time) ?
+        d.to_time :
+        Time.parse(d.strftime('%Y-%m-%d %H:%M:%S')),
+        zone)
+    end
 
-    ot
-  end
+    def make_from_array(a, zone)
 
-  def self.get_tzone(o)
+      t = Time.utc(*a)
+      s = t.strftime("%Y-%m-%d %H:%M:%S.#{'%06d' % t.usec}")
 
-    return o if o.is_a?(::TZInfo::Timezone)
-    return nil if o == nil
-    return local_tzone if o == :local
-    return ::TZInfo::Timezone.get('Zulu') if o == 'Z'
+      make_from_string(s, zone)
+    end
 
-    o = to_offset(o) if o.is_a?(Numeric)
+    def make_from_string(s, zone)
 
-    return nil unless o.is_a?(String)
+      parse(s, zone: zone)
+    end
 
-    (@custom_tz_cache ||= {})[o] ||
-    get_offset_tzone(o) ||
-    (::TZInfo::Timezone.get(o) rescue nil)
-  end
+    def make_from_numeric(f, zone)
 
-  def self.local_tzone
+      EoTime.new(Time.now.to_f + f, zone)
+    end
 
-    @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 make_from_eotime(eot, zone)
 
-    @local_tzone ||=
-      begin
-        @local_tzone_tz = ENV['TZ']
-        @local_tzone_loaded_at = Time.now
-        determine_local_tzone
-      end
-  end
+      return eot if zone == nil || zone == eot.zone
+      EoTime.new(eot.to_f, zone)
+    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 get_tzone(o)
 
-  class << self
+      return o if o.is_a?(::TZInfo::Timezone)
+      return nil if o == nil
+      return local_tzone if o == :local
+      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 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 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
 
     alias make make_time
   end
@@ -150,34 +191,37 @@ module EtOrbi
     #
     # class methods
 
-    def self.now(zone=nil)
+    class << self
 
-      EtOrbi.now(zone)
-    end
+      def now(zone=nil)
 
-    def self.parse(str, opts={})
+        EtOrbi.now(zone)
+      end
 
-      EtOrbi.parse(str, opts)
-    end
+      def parse(str, opts={})
+
+        EtOrbi.parse(str, opts)
+      end
 
-    def self.get_tzone(o)
+      def get_tzone(o)
 
-      EtOrbi.get_tzone(o)
-    end
+        EtOrbi.get_tzone(o)
+      end
 
-    def self.local_tzone
+      def local_tzone
 
-      EtOrbi.local_tzone
-    end
+        EtOrbi.local_tzone
+      end
 
-    def self.platform_info
+      def platform_info
 
-      EtOrbi.platform_info
-    end
+        EtOrbi.platform_info
+      end
 
-    def self.make(o)
+      def make(o)
 
-      EtOrbi.make_time(o)
+        EtOrbi.make_time(o)
+      end
     end
 
     #
@@ -220,6 +264,15 @@ module EtOrbi
       Time.utc(1970, 1, 1) + @seconds
     end
 
+    def utc?
+
+      %w[ zulu utc gmt ].include?(@zone.canonical_identifier.downcase)
+
+      #t = Time.now
+      #@zone.period_for_local(t).utc_offset == 0 &&
+      #@zone.period_for_local(t + 183 * 24 * 3600).utc_offset == 0
+    end
+
     alias getutc utc
     alias getgm utc
 
@@ -297,8 +350,8 @@ module EtOrbi
     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 add(t); @time = nil; @seconds += t.to_f; self; end
+    def subtract(t); @time = nil; @seconds -= t.to_f; self; end
 
     def +(t); inc(t, 1); end
     def -(t); inc(t, -1); end
@@ -354,8 +407,47 @@ module EtOrbi
       strftime("%H:%M:%S.#{'%06d' % usec}")
     end
 
+    def inc(t, dir=1)
+
+      case t
+      when Numeric
+        nt = self.dup
+        nt.seconds += dir * t.to_f
+        nt
+      when ::Time, ::EtOrbi::EoTime
+        fail ArgumentError.new(
+          "cannot add #{t.class} to EoTime") if dir > 0
+        @seconds + dir * t.to_f
+      else
+        fail ArgumentError.new(
+          "cannot call add or subtract #{t.class} to EoTime instance")
+      end
+    end
+
+    def localtime(zone=nil)
+
+      EoTime.new(self.to_f, zone)
+    end
+
+    def wday_in_month
+
+      [ count_weeks(-1), - count_weeks(1) ]
+    end
+
     protected
 
+    def count_weeks(dir)
+
+      c = 0
+      t = self
+      until t.month != self.month
+        c += 1
+        t += dir * (7 * 24 * 3600)
+      end
+
+      c
+    end
+
     def render_nozone_time(seconds)
 
       t =
@@ -398,20 +490,6 @@ module EtOrbi
       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(
@@ -422,182 +500,183 @@ module EtOrbi
     end
   end
 
-  #
-  # 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
+  class << self
 
-    EoTime.new(t.to_f, z)
-  end
+    #
+    # extra public methods
 
-  def self.to_offset(n)
+    # https://en.wikipedia.org/wiki/ISO_8601
+    # Postel's law applies
+    #
+    def 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
 
-    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 list_olson_zones(s)
 
-  def self.get_offset_tzone(str)
+      s.scan(
+        %r{
+          (?<=\s|\A)
+          (?:[A-Za-z][A-Za-z0-9+_-]+)
+          (?:\/(?:[A-Za-z][A-Za-z0-9+_-]+)){0,2}
+        }x)
+    end
 
-    # custom timezones, no DST, just an offset, like "+08:00" or "-01:30"
+    def find_olson_zone(str)
 
-    m = str.match(/\A([+-][0-1][0-9]):?([0-5][0-9])?\z/)
-    return nil unless m
+      list_olson_zones(str).each { |s| z = get_tzone(s); return z if z }
+      nil
+    end
 
-    hr = m[1].to_i
-    mn = m[2].to_i
+    def determine_local_tzone
 
-    hr = nil if hr.abs > 11
-    hr = nil if mn > 59
-    mn = -mn if hr && hr < 0
+      etz = ENV['TZ']
 
-    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
+      tz = ::TZInfo::Timezone.get(etz) rescue nil
+      return tz if tz
 
-    nil
-  end
+      tz = Time.zone.tzinfo \
+        if Time.respond_to?(:zone) && Time.zone.respond_to?(:tzinfo)
+      return tz if tz
 
-  def self.determine_local_tzone
+      tzs = determine_local_tzones
 
-    etz = ENV['TZ']
+      (etz && tzs.find { |z| z.name == etz }) || tzs.first
+    end
 
-    tz = ::TZInfo::Timezone.get(etz) rescue nil
-    return tz if tz
+    #
+    # protected module methods
 
-    tz = Time.zone.tzinfo \
-      if Time.respond_to?(:zone) && Time.zone.respond_to?(:tzinfo)
-    return tz if tz
+    protected
 
-    tzs = determine_local_tzones
+    def to_offset(n)
 
-    (etz && tzs.find { |z| z.name == etz }) || tzs.first
-  end
+      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.determine_local_tzones
+    def get_offset_tzone(str)
 
-    tabbs = (-6..5)
-      .collect { |i| (Time.now + i * 30 * 24 * 3600).zone }
-      .uniq
-      .sort
+      # custom timezones, no DST, just an offset, like "+08:00" or "-01:30"
 
-    t = Time.now
-    tu = t.dup.utc # /!\ dup is necessary, #utc modifies its target
+      m = str.match(/\A([+-][0-1][0-9]):?([0-5][0-9])?\z/)
+      return nil unless m
 
-    twin = Time.utc(t.year, 1, 1) # winter
-    tsum = Time.utc(t.year, 7, 1) # summer
+      hr = m[1].to_i
+      mn = m[2].to_i
 
-    ::TZInfo::Timezone.all.select do |tz|
+      hr = nil if hr.abs > 11
+      hr = nil if mn > 59
+      mn = -mn if hr && hr < 0
 
-      pabbs =
-        [
-          tz.period_for_utc(twin).abbreviation.to_s,
-          tz.period_for_utc(tsum).abbreviation.to_s
-        ].uniq.sort
+      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
 
-      pabbs == tabbs
+      nil
     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 determine_local_tzones
 
-  def self.list_olson_zones(s)
+      tabbs = (-6..5)
+        .collect { |i| (Time.now + i * 30 * 24 * 3600).zone }
+        .uniq
+        .sort
 
-    s.scan(
-      %r{
-        (?<=\s|\A)
-        (?:[A-Za-z][A-Za-z0-9+_-]+)
-        (?:\/(?:[A-Za-z][A-Za-z0-9+_-]+)){0,2}
-      }x)
-  end
+      t = Time.now
+      tu = t.dup.utc # /!\ dup is necessary, #utc modifies its target
 
-  #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
+      twin = Time.utc(t.year, 1, 1) # winter
+      tsum = Time.utc(t.year, 7, 1) # summer
 
-  #
-  # system tz determination
+      ::TZInfo::Timezone.all.select do |tz|
 
-  def self.debian_tz
+        pabbs =
+          [
+            tz.period_for_utc(twin).abbreviation.to_s,
+            tz.period_for_utc(tsum).abbreviation.to_s
+          ].uniq.sort
 
-    path = '/etc/timezone'
+        pabbs == tabbs
+      end
+    end
 
-    File.exist?(path) ? File.read(path).strip : nil
-  rescue; nil; end
+    #
+    # system tz determination
 
-  def self.centos_tz
+    def debian_tz
 
-    path = '/etc/sysconfig/clock'
+      path = '/etc/timezone'
 
-    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)
+      File.exist?(path) ? File.read(path).strip : nil
+    rescue; nil; end
 
-    nil
-  rescue; nil; end
+    def centos_tz
 
-  def self.osx_tz
+      path = '/etc/sysconfig/clock'
 
-    path = '/etc/localtime'
+      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)
 
-    File.symlink?(path) ?
-      File.readlink(path).split('/')[4..-1].join('/') :
       nil
-  rescue; nil; end
+    rescue; nil; end
 
-#  def self.find_tz
+    def osx_tz
+
+      path = '/etc/localtime'
+
+      File.symlink?(path) ?
+        File.readlink(path).split('/')[4..-1].join('/') :
+        nil
+    rescue; nil; end
+
+#    def find_tz
 #
-#    debian_tz || centos_tz || osx_tz
-#  end
+#      debian_tz || centos_tz || osx_tz
+#    end
 
-  def self.gather_tzs
+    def gather_tzs
 
-    { :debian => debian_tz, :centos => centos_tz, :osx => osx_tz }
+      { :debian => debian_tz, :centos => centos_tz, :osx => osx_tz }
+    end
   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
 end
 

metadata

@@ -1,41 +1,41 @@
 --- !ruby/object:Gem::Specification
 name: et-orbi
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.0.5
 platform: ruby
 authors:
 - John Mettraux
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-09 00:00:00.000000000 Z
+date: 2017-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tzinfo
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.4'
 description: Time zones for fugit and rufus-scheduler. Urbi et Orbi.
@@ -45,15 +45,15 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
+- CREDITS.md
+- LICENSE.txt
 - Makefile
+- README.md
+- et-orbi.gemspec
 - lib/et-orbi.rb
 - lib/et_orbi.rb
 - lib/etorbi.rb
-- et-orbi.gemspec
-- LICENSE.txt
-- CHANGELOG.md
-- CREDITS.md
-- README.md
 homepage: http://github.com/floraison/et-orbi
 licenses:
 - MIT
@@ -64,17 +64,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: time with zones