jscalendar 0.1.0

data/lib/jscalendar/temporal.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Jscalendar
+  class UnsupportedError < Error; end
+
+  def self.decimal_seconds(number)
+    value = number.is_a?(Float) ? BigDecimal(number.to_s).to_r : number.to_r
+    denominator = value.denominator
+    powers = [2, 5].map do |factor|
+      count = 0
+      while (denominator % factor).zero?
+        denominator /= factor
+        count += 1
+      end
+      count
+    end
+    raise ArgumentError, "seconds must have a finite decimal representation" unless denominator == 1
+
+    digits = powers.max
+    return value.numerator.to_s if digits.zero?
+
+    text = (value.abs * (10**digits)).to_i.to_s.rjust(digits + 1, "0")
+    text.insert(-digits - 1, ".")
+    "#{"-" if value.negative?}#{text.sub(/0+\z/, "")}"
+  end
+
+  class LocalDateTime
+    include Comparable
+
+    def initialize(value)
+      value = value.to_s
+      raise ValidationError, "invalid LocalDateTime" unless Types.utc_date_time?("#{value}Z")
+
+      @value = value.dup.freeze
+    end
+
+    def self.from_time(time)
+      fraction = if time.subsec.zero?
+                   ""
+                 else
+                   Jscalendar.decimal_seconds(time.subsec).delete_prefix("0")
+                 end
+      new(time.strftime("%Y-%m-%dT%H:%M:%S") + fraction)
+    end
+
+    def to_s
+      @value
+    end
+
+    def to_time
+      raise UnsupportedError, "Ruby Time cannot represent leap seconds" if @value[17, 2] == "60"
+
+      fraction = Rational("0#{@value[19..]}")
+      time = Time.utc(*@value[0, 19].scan(/\d+/).map(&:to_i)) + fraction
+      raise UnsupportedError, "Ruby Time cannot preserve this fractional precision" unless time.subsec == fraction
+
+      time
+    end
+
+    def <=>(other)
+      other = LocalDateTime.new(other).to_s
+      [@value[0, 19], Rational("0#{@value[19..]}")] <=> [other[0, 19], Rational("0#{other[19..]}")]
+    end
+
+    def ==(other)
+      other.respond_to?(:to_s) && @value == other.to_s
+    end
+  end
+
+  class Duration
+    attr_reader :days, :seconds
+
+    def initialize(value)
+      @value = value.to_s.dup.freeze
+      sign = is_a?(SignedDuration) ? "[+-]?" : ""
+      match = /\A(#{sign})P(?:(\d+)W)?(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+(?:\.\d*[1-9])?)S)?)?\z/.match(@value)
+      unless match && match.captures[1..].any? && !@value.end_with?("T") && !(match[4] && match[6] && !match[5])
+        raise ValidationError, "invalid #{self.class.name.split("::").last}"
+      end
+
+      factor = match[1] == "-" ? -1 : 1
+      @days = ((match[2].to_i * 7) + match[3].to_i) * factor
+      @seconds = ((match[4].to_i * 3600) + (match[5].to_i * 60) + Rational(match[6] || "0")) * factor
+    end
+
+    def self.from_seconds(seconds)
+      raise ArgumentError, "seconds must be a finite number" unless seconds.is_a?(Numeric) && seconds.finite?
+      raise ArgumentError, "negative Duration" if self == Duration && seconds.negative?
+
+      number = Jscalendar.decimal_seconds(seconds.abs)
+      new("#{"-" if seconds.negative?}PT#{number}S")
+    end
+
+    def to_s
+      @value
+    end
+
+    # Nominal seconds; calendar days can differ from 24 hours across a DST change.
+    def to_seconds
+      (@days * 86_400) + @seconds
+    end
+
+    def add_to(local, time_zone: nil, time_zones: {})
+      local = LocalDateTime.new(local)
+      resolver = time_zone && TimeZoneResolver.new(time_zone, time_zones)
+      if @days.negative? || @seconds.negative?
+        wall = resolver ? resolver.to_local(resolver.to_utc(local) + @seconds).to_time : local.to_time + @seconds
+        shifted = LocalDateTime.from_time(wall + (@days * 86_400))
+        resolver ? resolver.to_local(resolver.to_utc(shifted)) : shifted
+      else
+        shifted = LocalDateTime.from_time(local.to_time + (@days * 86_400))
+        resolver ? resolver.to_local(resolver.to_utc(shifted) + @seconds) : LocalDateTime.from_time(shifted.to_time + @seconds)
+      end
+    end
+  end
+
+  class SignedDuration < Duration; end
+end

data/lib/jscalendar/time_zone.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Jscalendar
+  class TimeZoneResolver
+    def initialize(identifier, definitions = {})
+      @identifier = identifier
+      @custom = definitions[identifier]
+      @iana = TZInfo::Timezone.get(identifier) unless @custom
+      @transitions = {}
+    rescue TZInfo::InvalidTimezoneIdentifier
+      raise ValidationError, "unknown time zone #{identifier}"
+    end
+
+    def to_utc(local)
+      wall = LocalDateTime.new(local).to_time
+      return wall - custom_offset(wall) if @custom
+
+      periods = @iana.periods_for_local(wall)
+      return wall - periods.map(&:observed_utc_offset).max unless periods.empty?
+
+      change = @iana.transitions_up_to(wall + (3 * 86_400), wall - (3 * 86_400)).find do |transition|
+        instant = transition.at.to_time
+        wall >= instant + transition.previous_offset.observed_utc_offset && wall < instant + transition.offset.observed_utc_offset
+      end
+      raise ConversionError, "unable to resolve time zone discontinuity" unless change
+
+      wall - change.previous_offset.observed_utc_offset
+    end
+
+    def to_local(utc)
+      return LocalDateTime.from_time(@iana.utc_to_local(utc.getutc)) unless @custom
+
+      changes = transitions(utc.year + 1)
+      offset = changes.first[1]
+      changes.each do |instant, _before, after|
+        break if instant > utc
+
+        offset = after
+      end
+      LocalDateTime.from_time(utc.getutc + offset)
+    end
+
+    def wall_bounds(from, to)
+      points = [to_local(from).to_time, to_local(to).to_time]
+      changes = if @custom
+                  transitions(to.year + 1).select { |instant, _before, _after| instant.between?(from, to) }
+                else
+                  @iana.transitions_up_to(to + 1, from).map do |transition|
+                    [transition.at.to_time, transition.previous_offset.observed_utc_offset, transition.offset.observed_utc_offset]
+                  end
+                end
+      changes.each { |instant, before, after| points.push(instant + before, instant + after) }
+      points.minmax
+    end
+
+    private
+
+    def custom_offset(wall)
+      changes = transitions(wall.year + 1)
+      offset = changes.first[1]
+      changes.each do |instant, before, after|
+        low, high = [instant + before, instant + after].minmax
+        return before if wall >= low && wall < high
+        break if wall < high
+
+        offset = after
+      end
+      offset
+    end
+
+    def transitions(year)
+      @transitions[year] ||= Timeout.timeout(2, LimitError, "custom time zone expansion exceeded time limit") do
+        rules = @custom.fetch("standard", []) + @custom.fetch("daylight", [])
+        changes = rules.flat_map do |rule|
+          before = offset_seconds(rule.fetch("offsetFrom"))
+          after = offset_seconds(rule.fetch("offsetTo"))
+          initial = LocalDateTime.new(rule.fetch("start")).to_time
+          dates = [initial] + rule.fetch("recurrenceOverrides", {}).keys.map { |date| LocalDateTime.new(date).to_time }
+          rule.fetch("recurrenceRules", []).each do |recurrence|
+            recurrence = Jscalendar.deep_copy(recurrence)
+            # VTIMEZONE UNTIL denotes UTC, while the recurrence engine uses wall time.
+            recurrence["until"] = LocalDateTime.from_time(LocalDateTime.new(recurrence["until"]).to_time + before).to_s if recurrence["until"]
+            dates.concat(Recurrence.rule_times(recurrence, initial, initial, Time.utc(year + 1), limit: 10_001))
+            raise LimitError, "custom time zone has too many transitions" if dates.size > 10_000
+          end
+          dates.uniq.map { |date| [date - before, before, after] }
+        end
+        raise ValidationError, "custom time zone needs a transition rule" if changes.empty?
+
+        changes.sort_by(&:first)
+      end
+    end
+
+    def offset_seconds(value)
+      sign = value.start_with?("-") ? -1 : 1
+      ((value[1, 2].to_i * 3600) + (value[3, 2].to_i * 60) + value[5, 2].to_i) * sign
+    end
+  end
+end

data/lib/jscalendar/types.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+module Jscalendar
+  DEFAULT_LIMITS = { max_input_size: 16 * 1024 * 1024, max_depth: 32, max_map_size: 10_000,
+                     max_data_uri_size: 1024 * 1024, max_patches: 1000, max_occurrences: 10_000, max_rules: 100, max_occurrence_bytes: 32 * 1024 * 1024 }.freeze
+  MAX_INTEGER = (2**53) - 1
+
+  class << self
+    def generate_json(value, options = nil)
+      value = precise_json_floats(value) if RUBY_ENGINE == "truffleruby"
+      JSON.generate(value, options)
+    end
+
+    # TruffleRuby Float#to_s can round away significant digits used by json's generator.
+    def precise_json_floats(value)
+      case value
+      when Hash then value.transform_values { |item| precise_json_floats(item) }
+      when Array then value.map { |item| precise_json_floats(item) }
+      when Float
+        raise JSON::GeneratorError, "#{value} not allowed in JSON" unless value.finite?
+
+        number = format("%.17g", value)
+        number += ".0" unless number.match?(/[.eE]/)
+        JSON::Fragment.new(number)
+      else value
+      end
+    end
+    private :precise_json_floats
+
+    # Copies JSON-compatible values without sharing mutable caller-owned containers.
+    def deep_copy(value, max_depth: DEFAULT_LIMITS[:max_depth], depth: 0, ancestors: [], pointer: "")
+      case value
+      when Hash, Array
+        raise LimitError.new("JSON nesting exceeds max_depth", pointer: pointer) if depth >= max_depth
+        raise ValidationError.new("cyclic JSON data", pointer: pointer) if ancestors.include?(value.object_id)
+
+        nested = ancestors + [value.object_id]
+        if value.is_a?(Array)
+          value.each_with_index.map do |item, index|
+            deep_copy(item, max_depth: max_depth, depth: depth + 1, ancestors: nested, pointer: self.pointer(pointer, index))
+          end
+        else
+          value.each_with_object({}) do |(key, item), result|
+            raise ValidationError.new("JSON object keys must be strings", pointer: pointer) unless key.is_a?(String) || key.is_a?(Symbol)
+
+            key = key.to_s
+            unless key.valid_encoding? && (key.encoding == Encoding::UTF_8 || key.ascii_only?)
+              raise ValidationError.new("invalid JSON object key encoding", pointer: pointer)
+            end
+            raise ValidationError.new("duplicate JSON object key #{key}", pointer: self.pointer(pointer, key)) if result.key?(key)
+
+            result[key.dup] = deep_copy(item, max_depth: max_depth, depth: depth + 1, ancestors: nested,
+                                              pointer: self.pointer(pointer, key))
+          end
+        end
+      when LocalDateTime, Duration then value.to_s
+      when String then value.dup
+      when Integer, Float, TrueClass, FalseClass, NilClass then value
+      when Model, IdMap then value.to_h
+      else raise ValidationError.new("value is not JSON-compatible", pointer: pointer)
+      end
+    end
+
+    def deep_freeze(value)
+      if value.is_a?(Hash)
+        value.each do |key, item|
+          deep_freeze(key)
+          deep_freeze(item)
+        end
+      end
+      value.each { |item| deep_freeze(item) } if value.is_a?(Array)
+      value.freeze
+    end
+
+    def pointer(parent, key)
+      "#{parent}/#{key.to_s.gsub("~", "~0").gsub("/", "~1")}"
+    end
+  end
+
+  SCHEMA = deep_freeze(YAML.safe_load_file(File.expand_path("../../data/types.yml", __dir__)))
+  ENUMS = deep_freeze(YAML.safe_load_file(File.expand_path("../../data/enums.yml", __dir__)))
+
+  module Types
+    module_function
+
+    def id?(value)
+      value.is_a?(String) && value.bytesize.between?(1, 255) && value.match?(/\A[A-Za-z0-9_-]+\z/)
+    end
+
+    def integer?(value, minimum: -MAX_INTEGER, maximum: MAX_INTEGER)
+      value.is_a?(Integer) && value.between?(minimum, maximum)
+    end
+
+    def vendor?(value)
+      return false unless value.is_a?(String) && value.valid_encoding?
+
+      prefix, name = value.split(":", 2)
+      return false unless name && !prefix.empty? && !name.empty? && !name.match?(%r{[\x00-\x08\x0A-\x1F\x7F"/~]})
+
+      prefix.split(".", -1).all? do |label|
+        label.match?(/\A[A-Za-z0-9\u0080-\u{10ffff}](?:[A-Za-z0-9\u0080-\u{10ffff}-]*[A-Za-z0-9\u0080-\u{10ffff}])?\z/)
+      end
+    rescue ArgumentError, Encoding::CompatibilityError
+      false
+    end
+
+    def uri?(value)
+      value.is_a?(String) && value.ascii_only? && !value.match?(/%(?![0-9a-fA-F]{2})/) && !URI.parse(value).scheme.nil?
+    rescue URI::InvalidURIError
+      false
+    end
+
+    def utc_date_time?(value)
+      return false unless value.is_a?(String)
+
+      match = /\A(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d*[1-9])?Z\z/.match(value)
+      return false unless match
+
+      year, month, day, hour, minute, second = match.captures.map(&:to_i)
+      Date.valid_date?(year, month, day, Date::GREGORIAN) && hour < 24 && minute < 60 && second <= 60 &&
+        (second < 60 || (hour == 23 && minute == 59 && [6, 12].include?(month) && day == Date.new(year, month, -1).day))
+    end
+
+    GRANDFATHERED_LANGUAGES = %w[art-lojban cel-gaulish en-gb-oed i-ami i-bnn i-default i-enochian i-hak i-klingon
+                                 i-lux i-mingo i-navajo i-pwn i-tao i-tay i-tsu no-bok no-nyn sgn-be-fr sgn-be-nl
+                                 sgn-ch-de zh-guoyu zh-hakka zh-min zh-min-nan zh-xiang].freeze
+
+    def language_tag?(value)
+      return false unless value.is_a?(String)
+      return true if GRANDFATHERED_LANGUAGES.include?(value.downcase)
+      return true if value.match?(/\Ax(?:-[A-Za-z0-9]{1,8})+\z/i)
+
+      parts = value.split("-", -1)
+      language = parts.shift
+      return false unless language&.match?(/\A[A-Za-z]{2,8}\z/)
+
+      3.times { parts.shift if parts.first&.match?(/\A[A-Za-z]{3}\z/) } if language.size <= 3
+      parts.shift if parts.first&.match?(/\A[A-Za-z]{4}\z/)
+      parts.shift if parts.first&.match?(/\A(?:[A-Za-z]{2}|[0-9]{3})\z/)
+      variants = []
+      while parts.first&.match?(/\A(?:[A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3})\z/)
+        variant = parts.shift.downcase
+        return false if variants.include?(variant)
+
+        variants << variant
+      end
+      singletons = []
+      until parts.empty?
+        singleton = parts.shift.downcase
+        return false unless singleton.match?(/\A[A-Za-z0-9]\z/) && !singletons.include?(singleton)
+        return !parts.empty? && parts.all? { |part| part.match?(/\A[A-Za-z0-9]{1,8}\z/) } if singleton == "x"
+
+        singletons << singleton
+        count = 0
+        while parts.first&.match?(/\A[A-Za-z0-9]{2,8}\z/)
+          parts.shift
+          count += 1
+        end
+        return false if count.zero?
+      end
+      true
+    end
+
+    def email?(value)
+      return false unless value.is_a?(String) && value.ascii_only?
+
+      value = value.gsub(/\r\n(?=[ \t])/, "")
+      return false if value.match?(/[^\x09\x20-\x7E]/)
+
+      value = without_email_comments(value)
+      return false unless value
+
+      atom = %q([A-Za-z0-9!#$%&'*+\-/=?^_`{|}~]+)
+      quoted = '"(?:[^"\\\\\r\n]|\\\\[\\x20-\\x7E])*"'
+      word = "(?:#{atom}|#{quoted})"
+      local = "#{word}(?:[ \\t]*\\.[ \\t]*#{word})*"
+      domain = "(?:#{atom}(?:[ \\t]*\\.[ \\t]*#{atom})*|\\[(?:[^\\[\\]\\\\\\r\\n]|\\\\[\\x20-\\x7E])*\\])"
+      value.match?(/\A[ \t]*#{local}[ \t]*@[ \t]*#{domain}[ \t]*\z/)
+    end
+
+    def without_email_comments(value)
+      result = +""
+      depth = 0
+      quoted = nil
+      escaped = false
+      value.each_char do |character|
+        if escaped
+          result << character if depth.zero?
+          escaped = false
+        elsif character == "\\" && (depth.positive? || quoted)
+          escaped = true
+          result << character if depth.zero?
+        elsif depth.positive?
+          depth += 1 if character == "("
+          depth -= 1 if character == ")"
+          result << " " if depth.zero?
+        elsif quoted
+          result << character
+          quoted = nil if character == quoted
+        elsif character == "("
+          depth = 1
+        else
+          result << character
+          quoted = character == "[" ? "]" : '"' if ['"', "["].include?(character)
+        end
+      end
+      result if depth.zero? && !quoted && !escaped
+    end
+  end
+end