mumukit-content-type 1.11.0 → 1.12.0

data/vendor/bundle/ruby/2.7.0/gems/tzinfo-1.2.11/lib/tzinfo/timezone_transition_definition.rb

@@ -0,0 +1,104 @@
+module TZInfo
+  # A TimezoneTransition defined by as integer timestamp, as a rational to
+  # create a DateTime or as both.
+  #
+  # @private 
+  class TimezoneTransitionDefinition < TimezoneTransition #:nodoc:
+    # The numerator of the DateTime if the transition time is defined as a 
+    # DateTime, otherwise the transition time as a timestamp.
+    attr_reader :numerator_or_time
+    protected :numerator_or_time
+    
+    # Either the denominator of the DateTime if the transition time is defined
+    # as a DateTime, otherwise nil. 
+    attr_reader :denominator
+    protected :denominator
+    
+    # Creates a new TimezoneTransitionDefinition with the given offset, 
+    # previous_offset (both TimezoneOffset instances) and UTC time.
+    #
+    # The time can be specified as a timestamp, as a rational to create a
+    # DateTime, or as both.
+    #
+    # If both a timestamp and rational are given, then the rational will only
+    # be used if the timestamp falls outside of the range of Time on the
+    # platform being used at runtime.
+    #
+    # DateTimes are created from the rational as follows:
+    # 
+    #  RubyCoreSupport.datetime_new!(RubyCoreSupport.rational_new!(numerator, denominator), 0, Date::ITALY)
+    #
+    # For performance reasons, the numerator and denominator must be specified
+    # in their lowest form.
+    def initialize(offset, previous_offset, numerator_or_timestamp, denominator_or_numerator = nil, denominator = nil)
+      super(offset, previous_offset)
+      
+      if denominator
+        numerator = denominator_or_numerator
+        timestamp = numerator_or_timestamp
+      elsif denominator_or_numerator
+        numerator = numerator_or_timestamp
+        denominator = denominator_or_numerator
+        timestamp = nil
+      else
+        numerator = nil
+        denominator = nil
+        timestamp = numerator_or_timestamp
+      end
+      
+      # Determine whether to use the timestamp or the numerator and denominator.
+      if numerator && (
+        !timestamp || 
+        (timestamp < 0 && !RubyCoreSupport.time_supports_negative) || 
+        ((timestamp < -2147483648 || timestamp > 2147483647) && !RubyCoreSupport.time_supports_64bit)
+        )
+        
+        @numerator_or_time = numerator
+        @denominator = denominator
+      else
+        @numerator_or_time = timestamp
+        @denominator = nil
+      end
+      
+      @at = nil
+    end
+    
+    # A TimeOrDateTime instance representing the UTC time when this transition
+    # occurs.
+    def at
+      # Thread-safety: It is possible that the value of @at may be calculated
+      # multiple times in concurrently executing threads. It is not worth the
+      # overhead of locking to ensure that @at is only calculated once.
+      
+      unless @at
+        result = unless @denominator
+          TimeOrDateTime.new(@numerator_or_time)
+        else
+          r = RubyCoreSupport.rational_new!(@numerator_or_time, @denominator)
+          dt = RubyCoreSupport.datetime_new!(r, 0, Date::ITALY)
+          TimeOrDateTime.new(dt)
+        end
+
+        return result if frozen?
+        @at = result
+      end
+      
+      @at
+    end
+    
+    # Returns true if this TimezoneTransitionDefinition is equal to the given
+    # TimezoneTransitionDefinition. Two TimezoneTransitionDefinition instances 
+    # are considered to be equal by eql? if offset, previous_offset, 
+    # numerator_or_time and denominator are all equal.
+    def eql?(tti)
+      tti.kind_of?(TimezoneTransitionDefinition) &&
+        offset == tti.offset && previous_offset == tti.previous_offset &&
+        numerator_or_time == tti.numerator_or_time && denominator == tti.denominator        
+    end
+    
+    # Returns a hash of this TimezoneTransitionDefinition instance.
+    def hash
+      @offset.hash ^ @previous_offset.hash ^ @numerator_or_time.hash ^ @denominator.hash
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/tzinfo-1.2.11/lib/tzinfo/transition_data_timezone_info.rb

@@ -0,0 +1,274 @@
+module TZInfo
+  # Raised if no offsets have been defined when calling period_for_utc or
+  # periods_for_local. Indicates an error in the timezone data.
+  class NoOffsetsDefined < StandardError
+  end
+    
+  # Represents a data timezone defined by a set of offsets and a set 
+  # of transitions.
+  #
+  # @private
+  class TransitionDataTimezoneInfo < DataTimezoneInfo #:nodoc:
+            
+    # Constructs a new TransitionDataTimezoneInfo with its identifier.
+    def initialize(identifier)   
+      super(identifier)
+      @offsets = {}
+      @transitions = []
+      @previous_offset = nil
+      @transitions_index = nil
+    end
+ 
+    # Defines a offset. The id uniquely identifies this offset within the
+    # timezone. utc_offset and std_offset define the offset in seconds of 
+    # standard time from UTC and daylight savings from standard time 
+    # respectively. abbreviation describes the timezone offset (e.g. GMT, BST,
+    # EST or EDT).
+    #
+    # The first offset to be defined is treated as the offset that applies
+    # until the first transition. This will usually be in Local Mean Time (LMT).
+    #
+    # ArgumentError will be raised if the id is already defined.
+    def offset(id, utc_offset, std_offset, abbreviation)
+      raise ArgumentError, 'Offset already defined' if @offsets.has_key?(id)
+      
+      offset = TimezoneOffset.new(utc_offset, std_offset, abbreviation)
+      @offsets[id] = offset
+      @previous_offset = offset unless @previous_offset
+    end
+    
+    # Defines a transition. Transitions must be defined in chronological order.
+    # ArgumentError will be raised if a transition is added out of order.
+    # offset_id refers to an id defined with offset. ArgumentError will be 
+    # raised if the offset_id cannot be found. numerator_or_time and
+    # denomiator specify the time the transition occurs as. See 
+    # TimezoneTransition for more detail about specifying times.
+    def transition(year, month, offset_id, numerator_or_timestamp, denominator_or_numerator = nil, denominator = nil)
+      offset = @offsets[offset_id]      
+      raise ArgumentError, 'Offset not found' unless offset
+            
+      if @transitions_index
+        if year < @last_year || (year == @last_year && month < @last_month)
+          raise ArgumentError, 'Transitions must be increasing date order'
+        end
+        
+        # Record the position of the first transition with this index.
+        index = transition_index(year, month)
+        @transitions_index[index] ||= @transitions.length
+                
+        # Fill in any gaps       
+        (index - 1).downto(0) do |i|
+          break if @transitions_index[i]
+          @transitions_index[i] = @transitions.length
+        end
+      else
+        @transitions_index = [@transitions.length]
+        @start_year = year
+        @start_month = month        
+      end
+      
+      @transitions << TimezoneTransitionDefinition.new(offset, @previous_offset,
+        numerator_or_timestamp, denominator_or_numerator, denominator)
+      @last_year = year
+      @last_month = month             
+      @previous_offset = offset
+    end           
+    
+    # Returns the TimezonePeriod for the given UTC time.
+    # Raises NoOffsetsDefined if no offsets have been defined.
+    def period_for_utc(utc)
+      unless @transitions.empty?
+        utc = TimeOrDateTime.wrap(utc)               
+        index = transition_index(utc.year, utc.mon)
+        
+        start_transition = nil
+        start = transition_before_end(index)
+        if start
+          start.downto(0) do |i|
+            if @transitions[i].at <= utc
+              start_transition = @transitions[i]
+              break
+            end
+          end
+        end
+        
+        end_transition = nil
+        start = transition_after_start(index)      
+        if start
+          start.upto(@transitions.length - 1) do |i|
+            if @transitions[i].at > utc
+              end_transition = @transitions[i]
+              break
+            end
+          end
+        end
+               
+        if start_transition || end_transition
+          TimezonePeriod.new(start_transition, end_transition)
+        else
+          # Won't happen since there are transitions. Must always find one
+          # transition that is either >= or < the specified time.
+          raise 'No transitions found in search'
+        end        
+      else
+        raise NoOffsetsDefined, 'No offsets have been defined' unless @previous_offset        
+        TimezonePeriod.new(nil, nil, @previous_offset)
+      end
+    end
+    
+    # Returns the set of TimezonePeriods for the given local time as an array.    
+    # Results returned are ordered by increasing UTC start date.
+    # Returns an empty array if no periods are found for the given time.
+    # Raises NoOffsetsDefined if no offsets have been defined.    
+    def periods_for_local(local)
+      unless @transitions.empty?
+        local = TimeOrDateTime.wrap(local)
+        index = transition_index(local.year, local.mon)
+        
+        result = []
+       
+        start_index = transition_after_start(index - 1)       
+        if start_index && @transitions[start_index].local_end_at > local
+          if start_index > 0
+            if @transitions[start_index - 1].local_start_at <= local
+              result << TimezonePeriod.new(@transitions[start_index - 1], @transitions[start_index])
+            end
+          else
+            result << TimezonePeriod.new(nil, @transitions[start_index])
+          end
+        end
+        
+        end_index = transition_before_end(index + 1)
+        
+        if end_index        
+          start_index = end_index unless start_index
+          
+          start_index.upto(transition_before_end(index + 1)) do |i|
+            if @transitions[i].local_start_at <= local
+              if i + 1 < @transitions.length
+                if @transitions[i + 1].local_end_at > local
+                  result << TimezonePeriod.new(@transitions[i], @transitions[i + 1])
+                end
+              else
+                result << TimezonePeriod.new(@transitions[i], nil)
+              end
+            end
+          end
+        end
+        
+        result
+      else
+        raise NoOffsetsDefined, 'No offsets have been defined' unless @previous_offset
+        [TimezonePeriod.new(nil, nil, @previous_offset)]
+      end
+    end
+    
+    # Returns an Array of TimezoneTransition instances representing the times
+    # where the UTC offset of the timezone changes.
+    #
+    # Transitions are returned up to a given date and time up to a given date 
+    # and time, specified in UTC (utc_to).
+    #
+    # A from date and time may also be supplied using the utc_from parameter
+    # (also specified in UTC). If utc_from is not nil, only transitions from 
+    # that date and time onwards will be returned.
+    #
+    # Comparisons with utc_to are exclusive. Comparisons with utc_from are
+    # inclusive. If a transition falls precisely on utc_to, it will be excluded.
+    # If a transition falls on utc_from, it will be included.
+    #
+    # Transitions returned are ordered by when they occur, from earliest to 
+    # latest.
+    #
+    # utc_to and utc_from can be specified using either DateTime, Time or 
+    # integer timestamps (Time.to_i).
+    #
+    # If utc_from is specified and utc_to is not greater than utc_from, then
+    # transitions_up_to raises an ArgumentError exception.
+    def transitions_up_to(utc_to, utc_from = nil)
+      utc_to = TimeOrDateTime.wrap(utc_to)
+      utc_from = utc_from ? TimeOrDateTime.wrap(utc_from) : nil
+      
+      if utc_from && utc_to <= utc_from
+        raise ArgumentError, 'utc_to must be greater than utc_from'
+      end
+      
+      unless @transitions.empty?
+        if utc_from
+          from = transition_after_start(transition_index(utc_from.year, utc_from.mon))
+          
+          if from
+            while from < @transitions.length && @transitions[from].at < utc_from
+              from += 1
+            end
+            
+            if from >= @transitions.length
+              return []
+            end
+          else
+            # utc_from is later than last transition.
+            return []
+          end
+        else
+          from = 0
+        end
+        
+        to = transition_before_end(transition_index(utc_to.year, utc_to.mon))
+        
+        if to
+          while to >= 0 && @transitions[to].at >= utc_to
+            to -= 1
+          end
+          
+          if to < 0
+            return []
+          end
+        else
+          # utc_to is earlier than first transition.
+          return []
+        end
+
+        @transitions[from..to]
+      else
+        []
+      end
+    end
+    
+    private
+      # Returns the index into the @transitions_index array for a given year 
+      # and month.
+      def transition_index(year, month)
+        index = (year - @start_year) * 2
+        index += 1 if month > 6
+        index -= 1 if @start_month > 6
+        index
+      end
+      
+      # Returns the index into @transitions of the first transition that occurs
+      # on or after the start of the given index into @transitions_index.
+      # Returns nil if there are no such transitions.
+      def transition_after_start(index)
+        if index >= @transitions_index.length
+          nil
+        else
+          index = 0 if index < 0
+          @transitions_index[index]
+        end
+      end
+      
+      # Returns the index into @transitions of the first transition that occurs
+      # before the end of the given index into @transitions_index.
+      # Returns nil if there are no such transitions.
+      def transition_before_end(index)
+        index = index + 1
+        
+        if index <= 0
+          nil
+        elsif index >= @transitions_index.length          
+          @transitions.length - 1
+        else      
+          @transitions_index[index] - 1          
+        end
+      end            
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/tzinfo-1.2.11/lib/tzinfo/transition_rule.rb

@@ -0,0 +1,325 @@
+require 'date'
+
+module TZInfo
+  # Base class for rules definining the transition between standard and daylight
+  # savings time.
+  class TransitionRule #:nodoc:
+    # Returns the number of seconds after midnight local time on the day
+    # identified by the rule at which the transition occurs. Can be negative to
+    # denote a time on the prior day. Can be greater than or equal to 86,400 to
+    # denote a time of the following day.
+    attr_reader :transition_at
+
+    # Initializes a new TransitionRule.
+    def initialize(transition_at)
+      raise ArgumentError, 'Invalid transition_at' unless transition_at.kind_of?(Integer)
+      @transition_at = transition_at
+    end
+
+    # Calculates the UTC time of the transition from a given offset on a given
+    # year.
+    def at(offset, year)
+      day = get_day(year)
+      day.add_with_convert(@transition_at - offset.utc_total_offset)
+    end
+
+    # Determines if this TransitionRule is equal to another instance.
+    def ==(r)
+      r.kind_of?(TransitionRule) && @transition_at == r.transition_at
+    end
+    alias eql? ==
+
+    # Returns a hash based on hash_args (defaulting to transition_at).
+    def hash
+      hash_args.hash
+    end
+
+    protected
+
+    # Returns an Array of parameters that will influence the output of hash.
+    def hash_args
+      [@transition_at]
+    end
+
+    def new_time_or_datetime(year, month = 1, day = 1)
+      result = if ((year >= 2039 || (year == 2038 && (month >= 2 || (month == 1 && day >= 20)))) && !RubyCoreSupport.time_supports_64bit) ||
+        (year < 1970 && !RubyCoreSupport.time_supports_negative)
+
+        # Time handles 29 February on a non-leap year as 1 March.
+        # DateTime rejects. Advance manually.
+        if month == 2 && day == 29 && !Date.gregorian_leap?(year)
+          month = 3
+          day = 1
+        end
+
+        RubyCoreSupport.datetime_new(year, month, day)
+      else
+        Time.utc(year, month, day)
+      end
+
+      TimeOrDateTime.wrap(result)
+    end
+  end
+
+  # A base class for transition rules that activate based on an integer day of
+  # the year.
+  #
+  # @private
+  class DayOfYearTransitionRule < TransitionRule #:nodoc:
+    # Initializes a new DayOfYearTransitionRule.
+    def initialize(day, transition_at)
+      super(transition_at)
+      raise ArgumentError, 'Invalid day' unless day.kind_of?(Integer)
+      @seconds = day * 86400
+    end
+
+    # Determines if this DayOfYearTransitionRule is equal to another instance.
+    def ==(r)
+      super(r) && r.kind_of?(DayOfYearTransitionRule) && @seconds == r.seconds
+    end
+    alias eql? ==
+
+    protected
+
+    # @return [Integer] the day multipled by the number of seconds in a day.
+    attr_reader :seconds
+
+    # Returns an Array of parameters that will influence the output of hash.
+    def hash_args
+      [@seconds] + super
+    end
+  end
+
+  # Defines transitions that occur on the zero-based nth day of the year.
+  #
+  # Day 0 is 1 January.
+  #
+  # Leap days are counted. Day 59 will be 29 February on a leap year and 1 March
+  # on a non-leap year. Day 365 will be 31 December on a leap year and 1 January
+  # the following year on a non-leap year.
+  #
+  # @private
+  class AbsoluteDayOfYearTransitionRule < DayOfYearTransitionRule #:nodoc:
+    # Initializes a new AbsoluteDayOfYearTransitionRule.
+    def initialize(day, transition_at = 0)
+      super(day, transition_at)
+      raise ArgumentError, 'Invalid day' unless day >= 0 && day <= 365
+    end
+
+    # Returns true if the day specified by this transition is the first in the
+    # year (a day number of 0), otherwise false.
+    def is_always_first_day_of_year?
+      seconds == 0
+    end
+
+    # @returns false.
+    def is_always_last_day_of_year?
+      false
+    end
+
+    # Determines if this AbsoluteDayOfYearTransitionRule is equal to another
+    # instance.
+    def ==(r)
+      super(r) && r.kind_of?(AbsoluteDayOfYearTransitionRule)
+    end
+    alias eql? ==
+
+    protected
+
+    # Returns a TimeOrDateTime representing midnight local time on the day
+    # specified by the rule for the given offset and year.
+    def get_day(year)
+      new_time_or_datetime(year).add_with_convert(seconds)
+    end
+
+    # Returns an Array of parameters that will influence the output of hash.
+    def hash_args
+      [AbsoluteDayOfYearTransitionRule] + super
+    end
+  end
+
+  # Defines transitions that occur on the one-based nth Julian day of the year.
+  #
+  # Leap days are not counted. Day 1 is 1 January. Day 60 is always 1 March.
+  # Day 365 is always 31 December.
+  #
+  # @private
+  class JulianDayOfYearTransitionRule < DayOfYearTransitionRule #:nodoc:
+    # The 60 days in seconds.
+    LEAP = 60 * 86400
+
+    # The length of a non-leap year in seconds.
+    YEAR = 365 * 86400
+
+    # Initializes a new JulianDayOfYearTransitionRule.
+    def initialize(day, transition_at = 0)
+      super(day, transition_at)
+      raise ArgumentError, 'Invalid day' unless day >= 1 && day <= 365
+    end
+
+    # Returns true if the day specified by this transition is the first in the
+    # year (a day number of 1), otherwise false.
+    def is_always_first_day_of_year?
+      seconds == 86400
+    end
+
+    # Returns true if the day specified by this transition is the last in the
+    # year (a day number of 365), otherwise false.
+    def is_always_last_day_of_year?
+      seconds == YEAR
+    end
+
+    # Determines if this JulianDayOfYearTransitionRule is equal to another
+    # instance.
+    def ==(r)
+      super(r) && r.kind_of?(JulianDayOfYearTransitionRule)
+    end
+    alias eql? ==
+
+    protected
+
+    # Returns a TimeOrDateTime representing midnight local time on the day
+    # specified by the rule for the given offset and year.
+    def get_day(year)
+      # Returns 1 March on non-leap years.
+      leap = new_time_or_datetime(year, 2, 29)
+      diff = seconds - LEAP
+      diff += 86400 if diff >= 0 && leap.mday == 29
+      leap.add_with_convert(diff)
+    end
+
+    # Returns an Array of parameters that will influence the output of hash.
+    def hash_args
+      [JulianDayOfYearTransitionRule] + super
+    end
+  end
+
+  # A base class for rules that transition on a particular day of week of a
+  # given week (subclasses specify which week of the month).
+  #
+  # @private
+  class DayOfWeekTransitionRule < TransitionRule #:nodoc:
+    # Initializes a new DayOfWeekTransitionRule.
+    def initialize(month, day_of_week, transition_at)
+      super(transition_at)
+      raise ArgumentError, 'Invalid month' unless month.kind_of?(Integer) && month >= 1 && month <= 12
+      raise ArgumentError, 'Invalid day_of_week' unless day_of_week.kind_of?(Integer) && day_of_week >= 0 && day_of_week <= 6
+      @month = month
+      @day_of_week = day_of_week
+    end
+
+    # Returns false.
+    def is_always_first_day_of_year?
+      false
+    end
+
+    # Returns false.
+    def is_always_last_day_of_year?
+      false
+    end
+
+    # Determines if this DayOfWeekTransitionRule is equal to another instance.
+    def ==(r)
+      super(r) && r.kind_of?(DayOfWeekTransitionRule) && @month == r.month && @day_of_week == r.day_of_week
+    end
+    alias eql? ==
+
+    protected
+
+    # Returns the month of the year (1 to 12).
+    attr_reader :month
+
+    # Returns the day of the week (0 to 6 for Sunday to Monday).
+    attr_reader :day_of_week
+
+    # Returns an Array of parameters that will influence the output of hash.
+    def hash_args
+      [@month, @day_of_week] + super
+    end
+  end
+
+  # A rule that transitions on the nth occurrence of a particular day of week
+  # of a calendar month.
+  #
+  # @private
+  class DayOfMonthTransitionRule < DayOfWeekTransitionRule #:nodoc:
+    # Initializes a new DayOfMonthTransitionRule.
+    def initialize(month, week, day_of_week, transition_at = 0)
+      super(month, day_of_week, transition_at)
+      raise ArgumentError, 'Invalid week' unless week.kind_of?(Integer) && week >= 1 && week <= 4
+      @offset_start = (week - 1) * 7 + 1
+    end
+
+    # Determines if this DayOfMonthTransitionRule is equal to another instance.
+    def ==(r)
+      super(r) && r.kind_of?(DayOfMonthTransitionRule) && @offset_start == r.offset_start
+    end
+    alias eql? ==
+
+    protected
+
+    # Returns the day the week starts on for a month starting on a Sunday.
+    attr_reader :offset_start
+
+    # Returns a TimeOrDateTime representing midnight local time on the day
+    # specified by the rule for the given offset and year.
+    def get_day(year)
+      candidate = new_time_or_datetime(year, month, @offset_start)
+      diff = day_of_week - candidate.wday
+
+      if diff < 0
+        candidate.add_with_convert((7 + diff) * 86400)
+      elsif diff > 0
+        candidate.add_with_convert(diff * 86400)
+      else
+        candidate
+      end
+    end
+
+    # Returns an Array of parameters that will influence the output of hash.
+    def hash_args
+      [@offset_start] + super
+    end
+  end
+
+  # A rule that transitions on the last occurrence of a particular day of week
+  # of a calendar month.
+  #
+  # @private
+  class LastDayOfMonthTransitionRule < DayOfWeekTransitionRule #:nodoc:
+    # Initializes a new LastDayOfMonthTransitionRule.
+    def initialize(month, day_of_week, transition_at = 0)
+      super(month, day_of_week, transition_at)
+    end
+
+    # Determines if this LastDayOfMonthTransitionRule is equal to another
+    # instance.
+    def ==(r)
+      super(r) && r.kind_of?(LastDayOfMonthTransitionRule)
+    end
+    alias eql? ==
+
+    protected
+
+    # Returns a TimeOrDateTime representing midnight local time on the day
+    # specified by the rule for the given offset and year.
+    def get_day(year)
+      next_month = month + 1
+      if next_month == 13
+        year += 1
+        next_month = 1
+      end
+
+      candidate = new_time_or_datetime(year, next_month).add_with_convert(-86400)
+      diff = candidate.wday - day_of_week
+
+      if diff < 0
+        candidate - (diff + 7) * 86400
+      elsif diff > 0
+        candidate - diff * 86400
+      else
+        candidate
+      end
+    end
+  end
+end