senko 0.1.0

data/lib/senko/dialect.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Senko
+  module Dialect
+    DEFAULT = :'2020-12'
+
+    DIALECT_MAP = {
+      'https://json-schema.org/draft/2020-12/schema' => :'2020-12',
+      'https://json-schema.org/draft/2020-12/schema#' => :'2020-12',
+      'https://json-schema.org/draft/2019-09/schema' => :'2019-09',
+      'https://json-schema.org/draft/2019-09/schema#' => :'2019-09',
+      'http://json-schema.org/draft-07/schema#' => :'draft-07',
+      'http://json-schema.org/draft-07/schema' => :'draft-07',
+      'http://json-schema.org/draft-06/schema#' => :'draft-06',
+      'http://json-schema.org/draft-06/schema' => :'draft-06',
+      'http://json-schema.org/draft-04/schema#' => :'draft-04',
+      'http://json-schema.org/draft-04/schema' => :'draft-04'
+    }.freeze
+
+    SUPPORTED = %i[2020-12 2019-09 draft-07 draft-06 draft-04].freeze
+
+    module_function
+
+    def detect(schema, explicit_draft = nil)
+      draft = explicit_draft || schema_draft(schema) || DEFAULT
+      normalized = normalize_name(draft)
+      unless SUPPORTED.include?(normalized)
+        raise UnsupportedDialectError,
+              "unsupported JSON Schema dialect: #{draft.inspect}"
+      end
+
+      normalized
+    end
+
+    def schema_draft(schema)
+      return nil unless schema.is_a?(Hash)
+
+      value = schema['$schema'] || schema[:$schema]
+      DIALECT_MAP[value]
+    end
+
+    def normalize_name(name)
+      case name
+      when :'2020-12', :draft202012, '2020-12', 'draft202012'
+        :'2020-12'
+      when :'2019-09', :draft201909, '2019-09', 'draft201909'
+        :'2019-09'
+      when :'draft-07', :draft07, 'draft-07', 'draft07'
+        :'draft-07'
+      when :'draft-06', :draft06, 'draft-06', 'draft06'
+        :'draft-06'
+      when :'draft-04', :draft04, 'draft-04', 'draft04'
+        :'draft-04'
+      else
+        name
+      end
+    end
+  end
+end

data/lib/senko/errors.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Senko
+  class Error
+    attr_reader :message, :instance_location, :keyword_location, :keyword, :schema, :data
+
+    def initialize(message:, instance_location:, keyword_location:, keyword:, schema: nil, data: nil)
+      @message = message
+      @instance_location = instance_location
+      @keyword_location = keyword_location
+      @keyword = keyword
+      @schema = schema
+      @data = data
+    end
+
+    alias path instance_location
+    alias schema_path keyword_location
+
+    def to_h
+      {
+        'keywordLocation' => keyword_location,
+        'instanceLocation' => instance_location,
+        'error' => message
+      }
+    end
+  end
+
+  class CompileError < StandardError; end
+  class CircularReferenceError < CompileError; end
+  class UnresolvableRefError < CompileError; end
+  class UnsupportedDialectError < CompileError; end
+
+  class ValidationError < StandardError
+    attr_reader :result
+
+    def initialize(result)
+      @result = result
+      super('validation failed')
+    end
+  end
+end

data/lib/senko/format.rb

@@ -0,0 +1,327 @@
+# frozen_string_literal: true
+
+require 'date'
+require 'ipaddr'
+require 'simpleidn'
+require 'time'
+require 'uri'
+require 'addressable/uri'
+
+module Senko
+  module Format
+    DOT_ATOM = %r{\A[A-Za-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[A-Za-z0-9!#$%&'*+/=?^_`{|}~-]+)*\z}
+    HOST_LABEL = /\A[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?\z/
+    UUID = /\A[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\z/
+    JSON_POINTER = %r{\A(?:/(?:[^~/]|~0|~1)*)*\z}
+    RELATIVE_JSON_POINTER = %r{\A(?:0|[1-9][0-9]*)(?:#|(?:/(?:[^~/]|~0|~1)*)*)\z}
+    RFC3339_DATE = /\A([0-9]{4})-([0-9]{2})-([0-9]{2})\z/
+    RFC3339_DATE_TIME = /\A([0-9]{4}-[0-9]{2}-[0-9]{2})[Tt]([0-9]{2}:[0-9]{2}:[0-9]{2}(?:\.[0-9]+)?(?:[Zz]|[+-][0-9]{2}:[0-9]{2}))\z/
+    RFC3339_TIME = /\A([0-9]{2}):([0-9]{2}):([0-9]{2})(?:\.[0-9]+)?([Zz]|[+-]([0-9]{2}):([0-9]{2}))\z/
+    IPV4_DECIMAL = /\A(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])(?:\.(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])){3}\z/
+    IDN_SEPARATORS = /[.\u{3002}\u{ff0e}\u{ff61}]/
+    DISALLOWED_IDNA = /[\u{0640}\u{07fa}\u{302e}\u{302f}\u{3031}-\u{3035}\u{303b}]/
+
+    module_function
+
+    def valid?(name, value, custom_formats = {})
+      validator = custom_formats[name] || validators[name]
+      return true unless validator
+      return true unless value.is_a?(String)
+
+      validator.call(value)
+    rescue Addressable::URI::InvalidURIError, ArgumentError, IPAddr::InvalidAddressError,
+           RegexpError, SimpleIDN::ConversionError, URI::InvalidURIError
+      false
+    end
+
+    def validators
+      @validators ||= {
+        'date-time' => ->(value) { rfc3339_date_time?(value) },
+        'date' => ->(value) { rfc3339_date?(value) },
+        'time' => ->(value) { rfc3339_time?(value) },
+        'duration' => ->(value) { duration?(value) },
+        'email' => ->(value) { email?(value, idn: false) },
+        'idn-email' => ->(value) { email?(value, idn: true) },
+        'hostname' => ->(value) { hostname?(value) },
+        'idn-hostname' => ->(value) { hostname?(value, ascii_only: false) },
+        'ipv4' => ->(value) { value.match?(IPV4_DECIMAL) && IPAddr.new(value).ipv4? },
+        'ipv6' => ->(value) { ipv6?(value) },
+        'uri' => ->(value) { absolute_uri?(value) },
+        'uri-reference' => ->(value) { uri_reference?(value) },
+        'iri' => ->(value) { iri?(value, absolute: true) },
+        'iri-reference' => ->(value) { iri?(value, absolute: false) },
+        'uuid' => ->(value) { value.match?(UUID) },
+        'uri-template' => ->(value) { uri_template?(value) },
+        'json-pointer' => ->(value) { value.match?(JSON_POINTER) },
+        'relative-json-pointer' => ->(value) { value.match?(RELATIVE_JSON_POINTER) },
+        'regex' => ->(value) { ecma_regex?(value) }
+      }
+    end
+
+    def hostname?(value, ascii_only: true)
+      return false if value.empty? || value.length > 253
+      return false if ascii_only && !value.ascii_only?
+
+      labels = value.split(ascii_only ? '.' : IDN_SEPARATORS, -1)
+      return false if labels.empty? || labels.any?(&:empty?)
+
+      labels.all? { |label| hostname_label?(label, ascii_only: ascii_only) }
+    end
+
+    def absolute_uri?(value)
+      return false if invalid_uri_ascii?(value)
+
+      uri = Addressable::URI.parse(value)
+      uri.scheme && value.match?(/\A[A-Za-z][A-Za-z0-9+\-.]*:/)
+    end
+
+    def uri_reference?(value)
+      return false if invalid_uri_ascii?(value, allow_relative: true)
+
+      Addressable::URI.parse(value)
+      true
+    end
+
+    def iri?(value, absolute:)
+      return false if value.match?(/[\s<>\\]/)
+      return false if bad_percent_encoding?(value)
+      return true unless absolute
+      return false if unbracketed_ipv6_authority?(value)
+
+      Addressable::URI.parse(value)
+      value.match?(/\A[A-Za-z][A-Za-z0-9+\-.]*:/)
+    end
+
+    def uri_template?(value)
+      depth = 0
+      value.each_char do |char|
+        depth += 1 if char == '{'
+        depth -= 1 if char == '}'
+        return false if depth.negative? || depth > 1
+      end
+      depth.zero?
+    end
+
+    def duration?(value)
+      return true if value.match?(/\AP[0-9]+W\z/)
+      return false unless value.ascii_only?
+
+      match = value.match(/\AP(?:(?<years>[0-9]+)Y)?(?:(?<months>[0-9]+)M)?(?:(?<days>[0-9]+)D)?(?:T(?:(?<hours>[0-9]+)H)?(?:(?<minutes>[0-9]+)M)?(?:(?<seconds>[0-9]+)S)?)?\z/)
+      return false unless match
+
+      date_units = %w[years months days].select { |name| match[name] }
+      time_units = %w[hours minutes seconds].select { |name| match[name] }
+      return false if date_units.empty? && time_units.empty?
+      return false if value.include?('T') && time_units.empty?
+      return false if match['years'] && match['days'] && !match['months']
+      return false if match['hours'] && match['seconds'] && !match['minutes']
+
+      true
+    end
+
+    def rfc3339_date_time?(value)
+      match = value.match(RFC3339_DATE_TIME)
+      return false unless match
+
+      rfc3339_date?(match[1]) && rfc3339_time?(match[2])
+    end
+
+    def rfc3339_date?(value)
+      match = value.match(RFC3339_DATE)
+      return false unless match
+
+      year = match[1].to_i
+      month = match[2].to_i
+      day = match[3].to_i
+      return false unless month.between?(1, 12)
+
+      day.between?(1, days_in_month(year, month))
+    end
+
+    def rfc3339_time?(value)
+      match = value.match(RFC3339_TIME)
+      return false unless match
+
+      hour = match[1].to_i
+      minute = match[2].to_i
+      second = match[3].to_i
+      offset = match[4]
+      return false unless hour.between?(0, 23) && minute.between?(0, 59)
+      return false unless second.between?(0, 60)
+      return false if offset != 'Z' && offset != 'z' && (!match[5].to_i.between?(0,
+                                                                                 23) || !match[6].to_i.between?(0, 59))
+      return true if second < 60
+
+      leap_second_utc_minute?(hour, minute, offset, match[5], match[6])
+    end
+
+    def leap_second_utc_minute?(hour, minute, offset, offset_hour, offset_minute)
+      offset_minutes = if %w[Z z].include?(offset)
+                         0
+                       else
+                         sign = offset.start_with?('+') ? 1 : -1
+                         sign * ((offset_hour.to_i * 60) + offset_minute.to_i)
+                       end
+
+      (((hour * 60) + minute - offset_minutes) % 1440) == ((23 * 60) + 59)
+    end
+
+    def days_in_month(year, month)
+      return 29 if month == 2 && leap_year?(year)
+      return 28 if month == 2
+      return 30 if [4, 6, 9, 11].include?(month)
+
+      31
+    end
+
+    def leap_year?(year)
+      (year % 4).zero? && (!(year % 100).zero? || (year % 400).zero?)
+    end
+
+    def email?(value, idn:)
+      local, domain = split_email(value)
+      return false unless local && domain
+      return false unless local_part?(local, idn: idn)
+
+      if domain.start_with?('[') && domain.end_with?(']')
+        address_literal?(domain[1...-1])
+      else
+        hostname?(domain, ascii_only: !idn)
+      end
+    end
+
+    def split_email(value)
+      if value.start_with?('"')
+        index = value.index('"@', 1)
+        return nil unless index
+
+        [value[0..index], value[(index + 2)..]]
+      else
+        parts = value.split('@', -1)
+        return nil unless parts.length == 2
+
+        parts
+      end
+    end
+
+    def local_part?(value, idn:)
+      return value.match?(/\A"(?:[^"\\]|\\.)+"\z/) if value.start_with?('"')
+      return value.match?(/\A[^\s@.]+(?:\.[^\s@.]+)*\z/) if idn
+
+      value.match?(DOT_ATOM)
+    end
+
+    def address_literal?(value)
+      if value.start_with?('IPv6:')
+        ipv6?(value.delete_prefix('IPv6:'))
+      else
+        value.match?(IPV4_DECIMAL) && IPAddr.new(value).ipv4?
+      end
+    end
+
+    def hostname_label?(label, ascii_only:)
+      return false if label.empty?
+      return false if label.length > 63 && label.ascii_only?
+      return false if label.start_with?('-') || label.end_with?('-')
+      return ascii_label?(label) if ascii_only && !label.downcase.start_with?('xn--')
+
+      unicode = label.downcase.start_with?('xn--') ? SimpleIDN.to_unicode(label.downcase) : label
+      return false if unicode[2, 2] == '--'
+      return false unless canonical_idn_label?(label, unicode)
+      return false if unicode.match?(DISALLOWED_IDNA)
+      return false if unicode.match?(/\A\p{Mark}/)
+
+      contextual_idn_label?(unicode)
+    end
+
+    def ascii_label?(label)
+      label.ascii_only? && label.match?(HOST_LABEL) && !label.include?('_')
+    end
+
+    def canonical_idn_label?(label, unicode)
+      ascii = SimpleIDN.to_ascii(unicode).downcase
+      return label.downcase == ascii if label.downcase.start_with?('xn--')
+
+      ascii.length <= 63
+    end
+
+    def contextual_idn_label?(label)
+      chars = label.each_char.to_a
+      chars.each_with_index do |char, index|
+        return false if char == "\u{00b7}" && !(index.positive? && chars[index - 1] == 'l' && chars[index + 1] == 'l')
+        return false if char == "\u{0375}" && !greek?(chars[index + 1])
+        return false if char == "\u{05f3}" && !(index.positive? && hebrew?(chars[index - 1]))
+        return false if char == "\u{05f4}" && !(index.positive? && hebrew?(chars[index - 1]))
+        return false if char == "\u{30fb}" && !label.match?(/[\p{Hiragana}\p{Katakana}\p{Han}]/)
+        return false if char == "\u{200d}" && !(index.positive? && virama?(chars[index - 1]))
+      end
+      return false if label.match?(/[\u{0660}-\u{0669}]/) && label.match?(/[\u{06f0}-\u{06f9}]/)
+
+      true
+    end
+
+    def greek?(char)
+      char&.match?(/\p{Greek}/)
+    end
+
+    def hebrew?(char)
+      char&.match?(/\p{Hebrew}/)
+    end
+
+    def virama?(char)
+      char == "\u{094d}"
+    end
+
+    def ipv6?(value)
+      return false unless value.ascii_only?
+      return false if value.match?(/\s/) || value.include?('/') || value.include?('%') || !value.include?(':')
+
+      IPAddr.new(value).ipv6?
+    end
+
+    def invalid_uri_ascii?(value, allow_relative: false)
+      return true unless value.ascii_only?
+      return true if value.match?(/[\s<>\\]/)
+      return true if value.match?(/[{}|^`"]/)
+      return true if bad_percent_encoding?(value)
+      return true if !allow_relative && !value.match?(/\A[A-Za-z][A-Za-z0-9+\-.]*:/)
+
+      false
+    end
+
+    def bad_percent_encoding?(value)
+      value.match?(/%(?![0-9A-Fa-f]{2})/)
+    end
+
+    def unbracketed_ipv6_authority?(value)
+      match = value.match(%r{\A[A-Za-z][A-Za-z0-9+\-.]*://([^/?#]*)})
+      return false unless match
+
+      host = match[1].split('@', 2).last
+      host.include?(':') && !host.start_with?('[')
+    end
+
+    def ecma_regex?(value)
+      return false if value.match?(/(?:^|[^\\])\\a/)
+
+      verbose = $VERBOSE
+      $VERBOSE = nil
+      Regexp.new(ecma_pattern_source(value))
+      true
+    ensure
+      $VERBOSE = verbose
+    end
+
+    def ecma_pattern_source(value)
+      value
+        .gsub(/\\c([A-Za-z])/) { Regexp.escape((::Regexp.last_match(1).upcase.ord - 64).chr) }
+        .gsub('\\d', '[0-9]')
+        .gsub('\\D', '[^0-9]')
+        .gsub('\\w', '[A-Za-z0-9_]')
+        .gsub('\\W', '[^A-Za-z0-9_]')
+        .gsub('\\s', '[\\t\\n\\v\\f\\r \\u00a0\\ufeff\\u2028\\u2029\\p{Space_Separator}]')
+        .gsub('\\S', '[^\\t\\n\\v\\f\\r \\u00a0\\ufeff\\u2028\\u2029\\p{Space_Separator}]')
+        .gsub(/(?<!\\)\$/, '\\z')
+    end
+  end
+end

data/lib/senko/native.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+begin
+  require 'senko/senko'
+rescue LoadError
+  begin
+    require_relative '../../ext/senko/senko'
+  rescue LoadError
+    # Pure Ruby fallback. The native extension is a Phase 2 optimization.
+  end
+end

data/lib/senko/result.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative 'errors'
+
+module Senko
+  class Result
+    attr_reader :errors, :annotations
+
+    def initialize(fail_fast: false)
+      @fail_fast = fail_fast
+      @errors = []
+      @annotations = []
+    end
+
+    def valid?
+      @errors.empty?
+    end
+
+    def fail_fast?
+      @fail_fast
+    end
+
+    def add_error(error)
+      @errors << error
+    end
+
+    def add_annotation(annotation)
+      @annotations << annotation
+    end
+
+    def to_basic
+      payload = { 'valid' => valid? }
+      payload['errors'] = @errors.map(&:to_h) unless valid?
+      payload
+    end
+
+    def to_detailed
+      {
+        'valid' => valid?,
+        'keywordLocation' => '',
+        'instanceLocation' => '',
+        'errors' => @errors.map(&:to_h)
+      }.tap do |payload|
+        payload.delete('errors') if valid?
+      end
+    end
+
+    def to_verbose
+      payload = to_detailed
+      payload['annotations'] = @annotations unless @annotations.empty?
+      payload['errors'] = @errors.map { |error| verbose_error(error) } unless valid?
+      payload
+    end
+
+    private
+
+    def verbose_error(error)
+      error.to_h.merge(
+        'keyword' => error.keyword,
+        'schema' => error.schema,
+        'data' => error.data
+      )
+    end
+  end
+end

data/lib/senko/schema.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'json'
+
+require_relative 'errors'
+require_relative 'validator'
+
+module Senko
+  class Schema
+    attr_reader :source, :instructions, :options
+
+    def initialize(source:, instructions:, options:, generated_validator: nil)
+      @source = source
+      @instructions = instructions
+      @options = options
+      @generated_validator = generated_validator
+      @validator = Validator.new(options)
+      @track_evaluation = Validator.requires_evaluation_tracking?(instructions)
+    end
+
+    def valid?(data)
+      return @generated_validator.call(data) if @generated_validator
+
+      @validator.valid?(@instructions, data, track_evaluation: @track_evaluation)
+    end
+
+    def validate(data, fail_fast: @options[:fail_fast])
+      @validator.validate(@instructions, data, fail_fast: fail_fast)
+    end
+
+    def valid_json?(json)
+      validate_json(json, fail_fast: true).valid?
+    end
+
+    def validate_json(json, fail_fast: @options[:fail_fast])
+      validate(JSON.parse(json), fail_fast: fail_fast)
+    rescue JSON::ParserError => e
+      result = Result.new(fail_fast: fail_fast)
+      result.add_error(
+        Error.new(
+          message: "invalid JSON: #{e.message}",
+          instance_location: '',
+          keyword_location: '',
+          keyword: 'parse',
+          data: json
+        )
+      )
+      result
+    end
+
+    def validate!(data)
+      result = validate(data, fail_fast: true)
+      raise ValidationError, result unless result.valid?
+
+      data
+    end
+  end
+end