RubyGems - ric - Versions diffs - 0.13.0 → 0.14.0 - Mend

ric 0.13.0 → 0.14.0

Files changed (2084) hide show

data/vendor/bundle/ruby/2.5.0/gems/tzinfo-1.2.5/lib/tzinfo/zoneinfo_timezone_info.rb DELETED Viewed

@@ -1,296 +0,0 @@
-module TZInfo
-  # An InvalidZoneinfoFile exception is raised if an attempt is made to load an
-  # invalid zoneinfo file.
-  class InvalidZoneinfoFile < StandardError
-  end
-  # Represents a timezone defined by a compiled zoneinfo TZif (\0, 2 or 3) file.
-  #
-  # @private
-  class ZoneinfoTimezoneInfo < TransitionDataTimezoneInfo #:nodoc:
-    # Minimum supported timestamp (inclusive).
-    #
-    # Time.utc(1700, 1, 1).to_i
-    MIN_TIMESTAMP = -8520336000
-    # Maximum supported timestamp (exclusive).
-    #
-    # Time.utc(2500, 1, 1).to_i
-    MAX_TIMESTAMP = 16725225600
-    # Constructs the new ZoneinfoTimezoneInfo with an identifier and path
-    # to the file.
-    def initialize(identifier, file_path)
-      super(identifier)
-      File.open(file_path, 'rb') do |file|
-        parse(file)
-      end
-    end
-    private
-      # Unpack will return unsigned 32-bit integers. Translate to
-      # signed 32-bit.
-      def make_signed_int32(long)
-        long >= 0x80000000 ? long - 0x100000000 : long
-      end
-      # Unpack will return a 64-bit integer as two unsigned 32-bit integers
-      # (most significant first). Translate to signed 64-bit
-      def make_signed_int64(high, low)
-        unsigned = (high << 32) | low
-        unsigned >= 0x8000000000000000 ? unsigned - 0x10000000000000000 : unsigned
-      end
-      # Read bytes from file and check that the correct number of bytes could
-      # be read. Raises InvalidZoneinfoFile if the number of bytes didn't match
-      # the number requested.
-      def check_read(file, bytes)
-        result = file.read(bytes)
-        unless result && result.length == bytes
-          raise InvalidZoneinfoFile, "Expected #{bytes} bytes reading '#{file.path}', but got #{result ? result.length : 0} bytes"
-        end
-        result
-      end
-      # Zoneinfo files don't include the offset from standard time (std_offset)
-      # for DST periods. Derive the base offset (utc_offset) where DST is
-      # observed from either the previous or next non-DST period.
-      #
-      # Returns the index of the offset to be used prior to the first
-      # transition.
-      def derive_offsets(transitions, offsets)
-        # The first non-DST offset (if there is one) is the offset observed
-        # before the first transition. Fallback to the first DST offset if there
-        # are no non-DST offsets.
-        first_non_dst_offset_index = offsets.index {|o| !o[:is_dst] }
-        first_offset_index = first_non_dst_offset_index || 0
-        return first_offset_index if transitions.empty?
-        # Determine the utc_offset of the next non-dst offset at each transition.
-        utc_offset_from_next = nil
-        transitions.reverse_each do |transition|
-          offset = offsets[transition[:offset]]
-          if offset[:is_dst]
-            transition[:utc_offset_from_next] = utc_offset_from_next if utc_offset_from_next
-          else
-            utc_offset_from_next = offset[:utc_total_offset]
-          end
-        end
-        utc_offset_from_previous = first_non_dst_offset_index ? offsets[first_non_dst_offset_index][:utc_total_offset] : nil
-        defined_offsets = {}
-        transitions.each do |transition|
-          offset_index = transition[:offset]
-          offset = offsets[offset_index]
-          utc_total_offset = offset[:utc_total_offset]
-          if offset[:is_dst]
-            utc_offset_from_next = transition[:utc_offset_from_next]
-            difference_to_previous = (utc_total_offset - (utc_offset_from_previous || utc_total_offset)).abs
-            difference_to_next = (utc_total_offset - (utc_offset_from_next || utc_total_offset)).abs
-            utc_offset = if difference_to_previous == 3600
-              utc_offset_from_previous
-            elsif difference_to_next == 3600
-              utc_offset_from_next
-            elsif difference_to_previous > 0 && difference_to_next > 0
-              difference_to_previous < difference_to_next ? utc_offset_from_previous : utc_offset_from_next
-            elsif difference_to_previous > 0
-              utc_offset_from_previous
-            elsif difference_to_next > 0
-              utc_offset_from_next
-            else
-              # No difference, assume a 1 hour offset from standard time.
-              utc_total_offset - 3600
-            end
-            if !offset[:utc_offset]
-              offset[:utc_offset] = utc_offset
-              defined_offsets[offset] = offset_index
-            elsif offset[:utc_offset] != utc_offset
-              # An earlier transition has already derived a different
-              # utc_offset. Define a new offset or reuse an existing identically
-              # defined offset.
-              new_offset = offset.dup
-              new_offset[:utc_offset] = utc_offset
-              offset_index = defined_offsets[new_offset]
-              unless offset_index
-                offsets << new_offset
-                offset_index = offsets.length - 1
-                defined_offsets[new_offset] = offset_index
-              end
-              transition[:offset] = offset_index
-            end
-          else
-            utc_offset_from_previous = utc_total_offset
-          end
-        end
-        first_offset_index
-      end
-      # Defines an offset for the timezone based on the given index and offset
-      # Hash.
-      def define_offset(index, offset)
-        utc_total_offset = offset[:utc_total_offset]
-        utc_offset = offset[:utc_offset]
-        if utc_offset
-          # DST offset with base utc_offset derived by derive_offsets.
-          std_offset = utc_total_offset - utc_offset
-        elsif offset[:is_dst]
-          # DST offset unreferenced by a transition (offset in use before the
-          # first transition). No derived base UTC offset, so assume 1 hour
-          # DST.
-          utc_offset = utc_total_offset - 3600
-          std_offset = 3600
-        else
-          # Non-DST offset.
-          utc_offset = utc_total_offset
-          std_offset = 0
-        end
-        offset index, utc_offset, std_offset, offset[:abbr].untaint.to_sym
-      end
-      # Parses a zoneinfo file and intializes the DataTimezoneInfo structures.
-      def parse(file)
-        magic, version, ttisgmtcnt, ttisstdcnt, leapcnt, timecnt, typecnt, charcnt =
-          check_read(file, 44).unpack('a4 a x15 NNNNNN')
-        if magic != 'TZif'
-          raise InvalidZoneinfoFile, "The file '#{file.path}' does not start with the expected header."
-        end
-        if (version == '2' || version == '3') && RubyCoreSupport.time_supports_64bit
-          # Skip the first 32-bit section and read the header of the second 64-bit section
-          file.seek(timecnt * 5 + typecnt * 6 + charcnt + leapcnt * 8 + ttisgmtcnt + ttisstdcnt, IO::SEEK_CUR)
-          prev_version = version
-          magic, version, ttisgmtcnt, ttisstdcnt, leapcnt, timecnt, typecnt, charcnt =
-            check_read(file, 44).unpack('a4 a x15 NNNNNN')
-          unless magic == 'TZif' && (version == prev_version)
-            raise InvalidZoneinfoFile, "The file '#{file.path}' contains an invalid 64-bit section header."
-          end
-          using_64bit = true
-        elsif version != '3' && version != '2' && version != "\0"
-          raise InvalidZoneinfoFile, "The file '#{file.path}' contains a version of the zoneinfo format that is not currently supported."
-        else
-          using_64bit = false
-        end
-        unless leapcnt == 0
-          raise InvalidZoneinfoFile, "The zoneinfo file '#{file.path}' contains leap second data. TZInfo requires zoneinfo files that omit leap seconds."
-        end
-        transitions = []
-        if using_64bit
-          timecnt.times do |i|
-            high, low = check_read(file, 8).unpack('NN'.freeze)
-            transition_time = make_signed_int64(high, low)
-            transitions << {:at => transition_time}
-          end
-        else
-          timecnt.times do |i|
-            transition_time = make_signed_int32(check_read(file, 4).unpack('N'.freeze)[0])
-            transitions << {:at => transition_time}
-          end
-        end
-        timecnt.times do |i|
-          localtime_type = check_read(file, 1).unpack('C'.freeze)[0]
-          transitions[i][:offset] = localtime_type
-        end
-        offsets = []
-        typecnt.times do |i|
-          gmtoff, isdst, abbrind = check_read(file, 6).unpack('NCC'.freeze)
-          gmtoff = make_signed_int32(gmtoff)
-          isdst = isdst == 1
-          offset = {:utc_total_offset => gmtoff, :is_dst => isdst, :abbr_index => abbrind}
-          unless isdst
-            offset[:utc_offset] = gmtoff
-            offset[:std_offset] = 0
-          end
-          offsets << offset
-        end
-        abbrev = check_read(file, charcnt)
-        offsets.each do |o|
-          abbrev_start = o[:abbr_index]
-          raise InvalidZoneinfoFile, "Abbreviation index is out of range in file '#{file.path}'" unless abbrev_start < abbrev.length
-          abbrev_end = abbrev.index("\0", abbrev_start)
-          raise InvalidZoneinfoFile, "Missing abbreviation null terminator in file '#{file.path}'" unless abbrev_end
-          o[:abbr] = RubyCoreSupport.force_encoding(abbrev[abbrev_start...abbrev_end], 'UTF-8')
-        end
-        transitions.each do |t|
-          if t[:offset] < 0 || t[:offset] >= offsets.length
-            raise InvalidZoneinfoFile, "Invalid offset referenced by transition in file '#{file.path}'."
-          end
-        end
-        # Derive the offsets from standard time (std_offset).
-        first_offset_index = derive_offsets(transitions, offsets)
-        define_offset(first_offset_index, offsets[first_offset_index])
-        offsets.each_with_index do |o, i|
-          define_offset(i, o) unless i == first_offset_index
-        end
-        if !using_64bit && !RubyCoreSupport.time_supports_negative
-          # Filter out transitions that are not supported by Time on this
-          # platform.
-          # Move the last transition before the epoch up to the epoch. This
-          # allows for accurate conversions for all supported timestamps on the
-          # platform.
-          before_epoch, after_epoch = transitions.partition {|t| t[:at] < 0}
-          if before_epoch.length > 0 && after_epoch.length > 0 && after_epoch.first[:at] != 0
-            last_before = before_epoch.last
-            last_before[:at] = 0
-            transitions = [last_before] + after_epoch
-          else
-            transitions = after_epoch
-          end
-        end
-        # Ignore transitions that occur outside of a defined window. The
-        # transition index cannot handle a large range of transition times.
-        #
-        # This is primarily intended to ignore the far in the past transition
-        # added in zic 2014c (at timestamp -2**63 in zic 2014c and at the
-        # approximate time of the big bang from zic 2014d).
-        transitions.each do |t|
-          at = t[:at]
-          if at >= MIN_TIMESTAMP && at < MAX_TIMESTAMP
-            time = Time.at(at).utc
-            transition time.year, time.mon, t[:offset], at
-          end
-        end
-      end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/tzinfo-1.2.5/lib/tzinfo.rb DELETED Viewed

@@ -1,40 +0,0 @@
-# Top level module for TZInfo.
-module TZInfo
-end
-require 'tzinfo/ruby_core_support'
-require 'tzinfo/offset_rationals'
-require 'tzinfo/time_or_datetime'
-require 'tzinfo/timezone_definition'
-require 'tzinfo/timezone_offset'
-require 'tzinfo/timezone_transition'
-require 'tzinfo/timezone_transition_definition'
-require 'tzinfo/timezone_index_definition'
-require 'tzinfo/timezone_info'
-require 'tzinfo/data_timezone_info'
-require 'tzinfo/linked_timezone_info'
-require 'tzinfo/transition_data_timezone_info'
-require 'tzinfo/zoneinfo_timezone_info'
-require 'tzinfo/data_source'
-require 'tzinfo/ruby_data_source'
-require 'tzinfo/zoneinfo_data_source'
-require 'tzinfo/timezone_period'
-require 'tzinfo/timezone'
-require 'tzinfo/info_timezone'
-require 'tzinfo/data_timezone'
-require 'tzinfo/linked_timezone'
-require 'tzinfo/timezone_proxy'
-require 'tzinfo/country_index_definition'
-require 'tzinfo/country_info'
-require 'tzinfo/ruby_country_info'
-require 'tzinfo/zoneinfo_country_info'
-require 'tzinfo/country'
-require 'tzinfo/country_timezone'

data/vendor/bundle/ruby/2.5.0/gems/tzinfo-1.2.5/test/tc_country.rb DELETED Viewed

@@ -1,234 +0,0 @@
-require File.join(File.expand_path(File.dirname(__FILE__)), 'test_utils')
-include TZInfo
-class TCCountry < Minitest::Test
-  def setup
-    @orig_data_source = DataSource.get
-    Country.send :init_countries
-  end
-  def teardown
-    DataSource.set(@orig_data_source)
-  end
-  def test_get_valid
-    c = Country.get('GB')
-    assert c
-    assert_equal('GB', c.code)
-  end
-  def test_get_not_exist
-    assert_raises(InvalidCountryCode) {
-      Country.get('ZZ')
-    }
-  end
-  def test_get_invalid
-    assert_raises(InvalidCountryCode) {
-      Country.get('../Countries/GB')
-    }
-  end
-  def test_get_nil
-    assert_raises(InvalidCountryCode) {
-      Country.get(nil)
-    }
-  end
-  def test_get_case
-    assert_raises(InvalidCountryCode) {
-      Country.get('gb')
-    }
-  end
-  def test_get_tainted_loaded
-    Country.get('GB')
-    safe_test do
-      code = 'GB'.dup.taint
-      assert(code.tainted?)
-      country = Country.get(code)
-      assert_equal('GB', country.code)
-      assert(code.tainted?)
-    end
-  end
-  def test_get_tainted_and_frozen_loaded
-    Country.get('GB')
-    safe_test do
-      country = Country.get('GB'.dup.taint.freeze)
-      assert_equal('GB', country.code)
-    end
-  end
-  def test_get_tainted_not_previously_loaded
-    safe_test do
-      code = 'GB'.dup.taint
-      assert(code.tainted?)
-      country = Country.get(code)
-      assert_equal('GB', country.code)
-      assert(code.tainted?)
-    end
-  end
-  def test_get_tainted_and_frozen_not_previously_loaded
-    safe_test do
-      country = Country.get('GB'.dup.taint.freeze)
-      assert_equal('GB', country.code)
-    end
-  end
-  def test_new_nil
-    assert_raises(InvalidCountryCode) {
-      Country.new(nil)
-    }
-  end
-  def test_new_arg
-    c = Country.new('GB')
-    assert_same(Country.get('GB'), c)
-  end
-  def test_new_arg_not_exist
-    assert_raises(InvalidCountryCode) {
-      Country.new('ZZ')
-    }
-  end
-  def test_all_codes
-    all_codes = Country.all_codes
-    assert_kind_of(Array, all_codes)
-  end
-  def test_all
-    all = Country.all
-    assert_equal(Country.all_codes, all.collect {|c| c.code})
-  end
-  def test_code
-    assert_equal('US', Country.get('US').code)
-  end
-  def test_name
-    assert_kind_of(String, Country.get('US').name)
-  end
-  def test_to_s
-    assert_equal(Country.get('US').name, Country.get('US').to_s)
-    assert_equal(Country.get('GB').name, Country.get('GB').to_s)
-  end
-  def test_zone_identifiers
-    zone_names = Country.get('US').zone_names
-    assert_kind_of(Array, zone_names)
-    assert_equal(true, zone_names.frozen?)
-  end
-  def test_zone_names
-    assert_equal(Country.get('US').zone_identifiers, Country.get('US').zone_names)
-  end
-  def test_zones
-    zones = Country.get('US').zones
-    assert_kind_of(Array, zones)
-    assert_equal(Country.get('US').zone_identifiers, zones.collect {|z| z.identifier})
-    zones.each {|z| assert_kind_of(TimezoneProxy, z)}
-  end
-  def test_zone_info
-    zones = Country.get('US').zone_info
-    assert_kind_of(Array, zones)
-    assert_equal(true, zones.frozen?)
-    assert_equal(Country.get('US').zone_identifiers, zones.collect {|z| z.identifier})
-    assert_equal(Country.get('US').zone_identifiers, zones.collect {|z| z.timezone.identifier})
-    zones.each {|z| assert_kind_of(CountryTimezone, z)}
-  end
-  def test_compare
-    assert_equal(0, Country.get('GB') <=> Country.get('GB'))
-    assert_equal(-1, Country.get('GB') <=> Country.get('US'))
-    assert_equal(1, Country.get('US') <=> Country.get('GB'))
-    assert_equal(-1, Country.get('FR') <=> Country.get('US'))
-    assert_equal(1, Country.get('US') <=> Country.get('FR'))
-  end
-  def test_compare_non_comparable
-    assert_nil(Country.get('GB') <=> Object.new)
-  end
-  def test_equality
-    assert_equal(true, Country.get('GB') == Country.get('GB'))
-    assert_equal(false, Country.get('GB') == Country.get('US'))
-    assert(!(Country.get('GB') == Object.new))
-  end
-  def test_eql
-    assert_equal(true, Country.get('GB').eql?(Country.get('GB')))
-    assert_equal(false, Country.get('GB').eql?(Country.get('US')))
-    assert(!Country.get('GB').eql?(Object.new))
-  end
-  def test_hash
-    assert_equal('GB'.hash, Country.get('GB').hash)
-    assert_equal('US'.hash, Country.get('US').hash)
-  end
-  def test_marshal
-    c = Country.get('US')
-    # Should get back the same instance because load calls Country.get.
-    assert_same(c, Marshal.load(Marshal.dump(c)))
-  end
-  def test_reload
-    # If country gets reloaded for some reason, it needs to force a reload of
-    # the country index.
-    assert_equal('US', Country.get('US').code)
-    # Suppress redefined method warnings.
-    without_warnings do
-      load 'tzinfo/country.rb'
-    end
-    assert_equal('US', Country.get('US').code)
-  end
-  def test_get_missing_data_source
-    DataSource.set(DataSource.new)
-    assert_raises(InvalidDataSource) do
-      Country.get('GB')
-    end
-  end
-  def test_new_missing_data_source
-    DataSource.set(DataSource.new)
-    assert_raises(InvalidDataSource) do
-      Country.new('GB')
-    end
-  end
-  def test_all_codes_missing_data_source
-    DataSource.set(DataSource.new)
-    assert_raises(InvalidDataSource) do
-      Country.all_codes
-    end
-  end
-  def test_all_missing_data_source
-    DataSource.set(DataSource.new)
-    assert_raises(InvalidDataSource) do
-      Country.all
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/tzinfo-1.2.5/test/tc_country_index_definition.rb DELETED Viewed

@@ -1,69 +0,0 @@
-require File.join(File.expand_path(File.dirname(__FILE__)), 'test_utils')
-include TZInfo
-class TCCountryIndexDefinition < Minitest::Test
-  module CountriesTest1
-    include CountryIndexDefinition
-    country 'ZZ', 'Country One' do |c|
-      c.timezone 'Test/Zone/1', 3, 2, 41,20
-    end
-    country 'AA', 'Aland' do |c|
-      c.timezone 'Test/Zone/3', 71,30, 358, 15
-      c.timezone 'Test/Zone/2', 41, 20, 211, 30
-    end
-    country 'TE', 'Three'
-  end
-  module CountriesTest2
-    include CountryIndexDefinition
-    country 'CO', 'First Country' do |c|
-    end
-  end
-  def test_module_1
-    hash = CountriesTest1.countries
-    assert_equal(3, hash.length)
-    assert_equal(true, hash.frozen?)
-    zz = hash['ZZ']
-    aa = hash['AA']
-    te = hash['TE']
-    assert_kind_of(RubyCountryInfo, zz)
-    assert_equal('ZZ', zz.code)
-    assert_equal('Country One', zz.name)
-    assert_equal(1, zz.zones.length)
-    assert_equal('Test/Zone/1', zz.zones[0].identifier)
-    assert_kind_of(RubyCountryInfo, aa)
-    assert_equal('AA', aa.code)
-    assert_equal('Aland', aa.name)
-    assert_equal(2, aa.zones.length)
-    assert_equal('Test/Zone/3', aa.zones[0].identifier)
-    assert_equal('Test/Zone/2', aa.zones[1].identifier)
-    assert_kind_of(RubyCountryInfo, te)
-    assert_equal('TE', te.code)
-    assert_equal('Three', te.name)
-    assert_equal(0, te.zones.length)
-  end
-  def test_module_2
-    hash = CountriesTest2.countries
-    assert_equal(1, hash.length)
-    assert_equal(true, hash.frozen?)
-    co = hash['CO']
-    assert_kind_of(RubyCountryInfo, co)
-    assert_equal('CO', co.code)
-    assert_equal('First Country', co.name)
-    assert_equal(0, co.zones.length)
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/tzinfo-1.2.5/test/tc_country_info.rb DELETED Viewed

@@ -1,16 +0,0 @@
-require File.join(File.expand_path(File.dirname(__FILE__)), 'test_utils')
-include TZInfo
-class TCCountryInfo < Minitest::Test
-  def test_code
-    ci = CountryInfo.new('ZZ', 'Zzz') {|c| }
-    assert_equal('ZZ', ci.code)
-  end
-  def test_name
-    ci = CountryInfo.new('ZZ', 'Zzz') {|c| }
-    assert_equal('Zzz', ci.name)
-  end
-end