dato_json_schema 0.20.8

data/lib/json_schema/attributes.rb

@@ -0,0 +1,117 @@
+module JsonSchema
+  # Attributes mixes in some useful attribute-related methods for use in
+  # defining schema classes in a spirit similar to Ruby's attr_accessor and
+  # friends.
+  module Attributes
+    # Provides class-level methods for the Attributes module.
+    module ClassMethods
+      # Attributes that should be copied between classes when invoking
+      # Attributes#copy_from.
+      #
+      # Hash contains instance variable names mapped to a default value for the
+      # field.
+      attr_reader :copyable_attrs
+
+      # Attributes that are part of the JSON schema and hyper-schema
+      # specifications. These are allowed to be accessed with the [] operator.
+      #
+      # Hash contains the access key mapped to the name of the method that should
+      # be invoked to retrieve a value. For example, `type` maps to `type` and
+      # `additionalItems` maps to `additional_items`.
+      attr_reader :schema_attrs
+
+      # identical to attr_accessible, but allows us to copy in values from a
+      # target schema to help preserve our hierarchy during reference expansion
+      def attr_copyable(attr, options = {})
+        attr_accessor(attr)
+
+        ref = :"@#{attr}"
+        # Usually the default being assigned here is nil.
+        self.copyable_attrs[ref] = options[:default]
+
+        if default = options[:default]
+          # remove the reader already created by attr_accessor
+          remove_method(attr)
+
+          if [Array, Hash, Set].include?(default.class)
+            default = default.freeze
+          end
+
+          define_method(attr) do
+            val = instance_variable_get(ref)
+            if !val.nil?
+              val
+            else
+              default
+            end
+          end
+        end
+
+        if options[:clear_cache]
+          remove_method(:"#{attr}=")
+          define_method(:"#{attr}=") do |value|
+            instance_variable_set(options[:clear_cache], nil)
+            instance_variable_set(ref, value)
+          end
+        end
+      end
+
+      def attr_schema(attr, options = {})
+        attr_copyable(attr, :default => options[:default], :clear_cache => options[:clear_cache])
+        self.schema_attrs[options[:schema_name] || attr] = attr
+      end
+
+      # Directive indicating that attributes should be inherited from a parent
+      # class.
+      #
+      # Must appear as first statement in class that mixes in (or whose parent
+      # mixes in) the Attributes module.
+      def inherit_attrs
+        @copyable_attrs = self.superclass.instance_variable_get(:@copyable_attrs).dup
+        @schema_attrs = self.superclass.instance_variable_get(:@schema_attrs).dup
+      end
+
+      # Initializes some class instance variables required to make other
+      # methods in the Attributes module work. Run automatically when the
+      # module is mixed into another class.
+      def initialize_attrs
+        @copyable_attrs = {}
+        @schema_attrs = {}
+      end
+    end
+
+    def self.included(klass)
+      klass.extend(ClassMethods)
+      klass.send(:initialize_attrs)
+    end
+
+    # Allows the values of schema attributes to be accessed with a symbol or a
+    # string. So for example, the value of `schema.additional_items` could be
+    # procured with `schema[:additionalItems]`. This only works for attributes
+    # that are part of the JSON schema specification; other methods on the
+    # class are not available (e.g. `expanded`.)
+    #
+    # This is implemented so that `JsonPointer::Evaluator` can evaluate a
+    # reference on an sintance of this class (as well as plain JSON data).
+    def [](name)
+      name = name.to_sym
+      if self.class.schema_attrs.key?(name)
+        send(self.class.schema_attrs[name])
+      else
+        raise NoMethodError, "Schema does not respond to ##{name}"
+      end
+    end
+
+    def copy_from(schema)
+      self.class.copyable_attrs.each do |copyable, _|
+        instance_variable_set(copyable, schema.instance_variable_get(copyable))
+      end
+    end
+
+    def initialize_attrs
+      self.class.copyable_attrs.each do |attr, _|
+        instance_variable_set(attr, nil)
+      end
+    end
+  end
+end

data/lib/json_schema/configuration.rb

@@ -0,0 +1,28 @@
+module JsonSchema
+  class Configuration
+    attr_accessor :all_of_sub_errors
+    attr_reader :custom_formats
+    attr_reader :validate_regex_with
+
+    def validate_regex_with=(validator)
+      @validate_regex_with = validator
+    end
+
+    def register_format(name, validator_proc)
+      @custom_formats[name] = validator_proc
+    end
+
+    # Used for testing.
+    def reset!
+      @validate_regex_with = nil
+      @custom_formats = {}
+      @all_of_sub_errors = false
+    end
+
+    private
+
+    def initialize
+      reset!
+    end
+  end
+end

data/lib/json_schema/document_store.rb

@@ -0,0 +1,30 @@
+module JsonSchema
+  # The document store helps resolve URI-based JSON pointers by storing IDs
+  # that we've seen in the schema.
+  #
+  # Each URI tuple also contains a pointer map that helps speed up expansions
+  # that have already happened and handles cyclic dependencies. Store a
+  # reference to the top-level schema before doing anything else.
+  class DocumentStore
+    include Enumerable
+
+    def initialize
+      @schema_map = {}
+    end
+
+    def add_schema(schema)
+      raise ArgumentError, "can't add nil URI" if schema.uri.nil?
+      uri = schema.uri.chomp('#')
+      @schema_map[uri] = schema
+    end
+
+    def each
+      @schema_map.each { |k, v| yield(k, v) }
+    end
+
+    def lookup_schema(uri)
+      uri = uri.chomp('#')
+      @schema_map[uri]
+    end
+  end
+end

data/lib/json_schema/error.rb

@@ -0,0 +1,85 @@
+module JsonSchema
+  class Error < RuntimeError
+  end
+
+  class AggregateError < Error
+    attr_accessor :errors
+
+    def initialize(errors)
+      @errors = errors
+    end
+
+    def to_s
+      @errors.join(" ")
+    end
+  end
+
+  class SchemaError < Error
+    attr_accessor :message, :schema, :type
+
+    def self.aggregate(errors)
+      errors.map(&:to_s)
+    end
+
+    def initialize(schema, message, type)
+      @schema = schema
+      @message = message
+      @type = type
+    end
+
+    def to_s
+      if schema && schema.pointer
+        "#{schema.pointer}: #{message}"
+      else
+        message
+      end
+    end
+  end
+
+  class ValidationError < SchemaError
+    attr_accessor :data, :path, :sub_errors
+
+    def initialize(schema, path, message, type, options = {})
+      super(schema, message, type)
+      @path = path
+
+      # TODO: change to named optional arguments when Ruby 1.9 support is
+      # removed
+      @data = options[:data]
+      @sub_errors = options[:sub_errors]
+    end
+
+    def pointer
+      path.join("/")
+    end
+
+    def to_s
+      "#{pointer}: failed schema #{schema.pointer}: #{message}"
+    end
+  end
+
+  module ErrorFormatter
+    def to_list(list)
+      words_connector     = ', '
+      two_words_connector = ' or '
+      last_word_connector = ', or '
+
+      length = list.length
+      joined_list = case length
+                    when 1
+                      list[0]
+                    when 2
+                      "#{list[0]}#{two_words_connector}#{list[1]}"
+                     else
+                      "#{list[0...-1].join(words_connector)}#{last_word_connector}#{list[-1]}"
+                    end
+
+      if joined_list[0] =~ /^[aeiou]/
+        "an #{joined_list}"
+      else
+        "a #{joined_list}"
+      end
+    end
+    module_function :to_list
+  end
+end

data/lib/json_schema/parser.rb

@@ -0,0 +1,390 @@
+require_relative "../json_reference"
+require_relative "validator"
+
+module JsonSchema
+  class Parser
+    ALLOWED_TYPES = %w{any array boolean integer number null object string}
+    BOOLEAN = [FalseClass, TrueClass]
+    FORMATS = JsonSchema::Validator::DEFAULT_FORMAT_VALIDATORS.keys
+    FRIENDLY_TYPES = {
+      Array      => "array",
+      FalseClass => "boolean",
+      Float      => "number",
+      Hash       => "object",
+      Integer    => "integer",
+      NilClass   => "null",
+      String     => "string",
+      TrueClass  => "boolean",
+    }
+
+    # Reuse these frozen objects to avoid allocations
+    EMPTY_ARRAY = [].freeze
+    EMPTY_HASH = {}.freeze
+
+    attr_accessor :errors
+
+    # Basic parsing of a schema. May return a malformed schema! (Use `#parse!`
+    # to raise errors instead).
+    def parse(data, parent = nil)
+      # while #parse_data is recursed into for many schemas over the same
+      # object, the @errors array is an instance-wide accumulator
+      @errors = []
+
+      schema = parse_data(data, parent, "#")
+      if @errors.count == 0
+        schema
+      else
+        nil
+      end
+    end
+
+    def parse!(data, parent = nil)
+      schema = parse(data, parent)
+      if !schema
+        raise AggregateError.new(@errors)
+      end
+      schema
+    end
+
+    private
+
+    def build_uri(id, parent_uri)
+      # kill any trailing slashes
+      if id
+        # may look like: http://json-schema.org/draft-04/hyper-schema#
+        uri = URI.parse(id)
+        # make sure there is no `#` suffix
+        uri.fragment = nil
+        # if id is defined as absolute, the schema's URI stays absolute
+        if uri.absolute? || uri.path[0] == "/"
+          uri.to_s.chomp("/")
+        # otherwise build it according to the parent's URI
+        elsif parent_uri
+          # make sure we don't end up with duplicate slashes
+          parent_uri = parent_uri.chomp("/")
+          parent_uri + "/" + id
+        else
+          "/"
+        end
+      # if id is missing, it's defined as its parent schema's URI
+      elsif parent_uri
+        parent_uri
+      else
+        "/"
+      end
+    end
+
+    def parse_additional_items(schema)
+      if schema.additional_items
+        # an object indicates a schema that will be used to parse any
+        # items not listed in `items`
+        if schema.additional_items.is_a?(Hash)
+          schema.additional_items = parse_data(
+            schema.additional_items,
+            schema,
+            "additionalItems"
+          )
+        end
+        # otherwise, leave as boolean
+      end
+    end
+
+    def parse_additional_properties(schema)
+      if schema.additional_properties
+        # an object indicates a schema that will be used to parse any
+        # properties not listed in `properties`
+        if schema.additional_properties.is_a?(Hash)
+          schema.additional_properties = parse_data(
+            schema.additional_properties,
+            schema,
+            "additionalProperties"
+          )
+        end
+        # otherwise, leave as boolean
+      end
+    end
+
+    def parse_all_of(schema)
+      if schema.all_of && !schema.all_of.empty?
+        schema.all_of = schema.all_of.each_with_index.
+          map { |s, i| parse_data(s, schema, "allOf/#{i}") }
+      end
+    end
+
+    def parse_any_of(schema)
+      if schema.any_of && !schema.any_of.empty?
+        schema.any_of = schema.any_of.each_with_index.
+          map { |s, i| parse_data(s, schema, "anyOf/#{i}") }
+      end
+    end
+
+    def parse_one_of(schema)
+      if schema.one_of && !schema.one_of.empty?
+        schema.one_of = schema.one_of.each_with_index.
+          map { |s, i| parse_data(s, schema, "oneOf/#{i}") }
+      end
+    end
+
+    def parse_data(data, parent, fragment)
+      if !data.is_a?(Hash)
+        # it would be nice to make this message more specific/nicer (at best it
+        # points to the wrong schema)
+        message = %{#{data.inspect} is not a valid schema.}
+        @errors << SchemaError.new(parent, message, :schema_not_found)
+      elsif ref = data["$ref"]
+        schema = Schema.new
+        schema.fragment = fragment
+        schema.parent = parent
+        schema.reference = JsonReference::Reference.new(ref)
+      else
+        schema = parse_schema(data, parent, fragment)
+      end
+
+      schema
+    end
+
+    def parse_definitions(schema)
+      if schema.definitions && !schema.definitions.empty?
+        # leave the original data reference intact
+        schema.definitions = schema.definitions.dup
+        schema.definitions.each do |key, definition|
+          subschema = parse_data(definition, schema, "definitions/#{key}")
+          schema.definitions[key] = subschema
+        end
+      end
+    end
+
+    def parse_dependencies(schema)
+      if schema.dependencies && !schema.dependencies.empty?
+        # leave the original data reference intact
+        schema.dependencies = schema.dependencies.dup
+        schema.dependencies.each do |k, s|
+          # may be Array, String (simple dependencies), or Hash (schema
+          # dependency)
+          if s.is_a?(Hash)
+            schema.dependencies[k] = parse_data(s, schema, "dependencies")
+          elsif s.is_a?(String)
+            # just normalize all simple dependencies to arrays
+            schema.dependencies[k] = [s]
+          end
+        end
+      end
+    end
+
+    def parse_items(schema)
+      if schema.items
+        # tuple validation: an array of schemas
+        if schema.items.is_a?(Array)
+          schema.items = schema.items.each_with_index.
+            map { |s, i| parse_data(s, schema, "items/#{i}") }
+        # list validation: a single schema
+        else
+          schema.items = parse_data(schema.items, schema, "items")
+        end
+      end
+    end
+
+    def parse_links(schema)
+      if schema.links && !schema.links.empty?
+        schema.links = schema.links.each_with_index.map { |l, i|
+          link             = Schema::Link.new
+          link.parent      = schema
+          link.fragment    = "links/#{i}"
+
+          link.data        = l
+
+          # any parsed schema is automatically expanded
+          link.expanded    = true
+
+          link.uri         = nil
+
+          link.description = l["description"]
+          link.enc_type    = l["encType"]
+          link.href        = l["href"]
+          link.method      = l["method"] ? l["method"].downcase.to_sym : nil
+          link.rel         = l["rel"]
+          link.title       = l["title"]
+          link.media_type  = l["mediaType"]
+
+          if l["schema"]
+            link.schema = parse_data(l["schema"], schema, "links/#{i}/schema")
+          end
+
+          if l["targetSchema"]
+            link.target_schema =
+              parse_data(l["targetSchema"], schema, "links/#{i}/targetSchema")
+          end
+
+          if l["jobSchema"]
+            link.job_schema =
+              parse_data(l["jobSchema"], schema, "links/#{i}/jobSchema")
+          end
+
+          link
+        }
+      end
+    end
+
+    def parse_media(schema)
+      if data = schema.media
+        schema.media = Schema::Media.new
+        schema.media.binary_encoding = data["binaryEncoding"]
+        schema.media.type            = data["type"]
+      end
+    end
+
+    def parse_not(schema)
+      if schema.not
+        schema.not = parse_data(schema.not, schema, "not")
+      end
+    end
+
+    def parse_pattern_properties(schema)
+      if schema.pattern_properties && !schema.pattern_properties.empty?
+        # leave the original data reference intact
+        properties = schema.pattern_properties.dup
+        properties = properties.map do |k, s|
+          [parse_regex(schema, k), parse_data(s, schema, "patternProperties/#{k}")]
+        end
+        schema.pattern_properties = Hash[*properties.flatten]
+      end
+    end
+
+    def parse_regex(schema, regex)
+      case JsonSchema.configuration.validate_regex_with
+      when :'ecma-re-validator'
+        unless EcmaReValidator.valid?(regex)
+          message = %{#{regex.inspect} is not an ECMA-262 regular expression.}
+          @errors << SchemaError.new(schema, message, :regex_failed)
+        end
+      end
+      Regexp.new(regex)
+    end
+
+    def parse_properties(schema)
+      # leave the original data reference intact
+      if schema.properties && schema.properties.is_a?(Hash) && !schema.properties.empty?
+        schema.properties = schema.properties.dup
+        schema.properties.each do |key, definition|
+          subschema = parse_data(definition, schema, "properties/#{key}")
+          schema.properties[key] = subschema
+        end
+      end
+    end
+
+    def parse_schema(data, parent, fragment)
+      schema = Schema.new
+      schema.fragment = fragment
+      schema.parent   = parent
+
+      schema.data        = data
+      schema.id          = validate_type(schema, [String], "id")
+
+      # any parsed schema is automatically expanded
+      schema.expanded    = true
+
+      # build URI early so we can reference it in errors
+      schema.uri         = build_uri(schema.id, parent ? parent.uri : nil)
+
+      schema.title       = validate_type(schema, [String], "title")
+      schema.description = validate_type(schema, [String], "description")
+      schema.default     = schema.data["default"]
+
+      # validation: any
+      schema.all_of        = validate_type(schema, [Array], "allOf") || EMPTY_ARRAY
+      schema.any_of        = validate_type(schema, [Array], "anyOf") || EMPTY_ARRAY
+      schema.definitions   = validate_type(schema, [Hash], "definitions") || EMPTY_HASH
+      schema.enum          = validate_type(schema, [Array], "enum")
+      schema.one_of        = validate_type(schema, [Array], "oneOf") || EMPTY_ARRAY
+      schema.not           = validate_type(schema, [Hash], "not")
+      schema.type          = validate_type(schema, [Array, String], "type")
+      schema.type          = [schema.type] if schema.type.is_a?(String)
+      validate_known_type!(schema)
+
+      # validation: array
+      schema.additional_items = validate_type(schema, BOOLEAN + [Hash], "additionalItems")
+      schema.items            = validate_type(schema, [Array, Hash], "items")
+      schema.max_items        = validate_type(schema, [Integer], "maxItems")
+      schema.min_items        = validate_type(schema, [Integer], "minItems")
+      schema.unique_items     = validate_type(schema, BOOLEAN, "uniqueItems")
+
+      # validation: number/integer
+      schema.max           = validate_type(schema, [Float, Integer], "maximum")
+      schema.max_exclusive = validate_type(schema, BOOLEAN, "exclusiveMaximum")
+      schema.min           = validate_type(schema, [Float, Integer], "minimum")
+      schema.min_exclusive = validate_type(schema, BOOLEAN, "exclusiveMinimum")
+      schema.multiple_of   = validate_type(schema, [Float, Integer], "multipleOf")
+
+      # validation: object
+      schema.additional_properties =
+        validate_type(schema, BOOLEAN + [Hash], "additionalProperties")
+      schema.dependencies       = validate_type(schema, [Hash], "dependencies") || EMPTY_HASH
+      schema.max_properties     = validate_type(schema, [Integer], "maxProperties")
+      schema.min_properties     = validate_type(schema, [Integer], "minProperties")
+      schema.pattern_properties = validate_type(schema, [Hash], "patternProperties") || EMPTY_HASH
+      schema.properties         = validate_type(schema, [Hash], "properties") || EMPTY_HASH
+      schema.required           = validate_type(schema, [Array], "required")
+      schema.strict_properties  = validate_type(schema, BOOLEAN, "strictProperties")
+
+      # validation: string
+      schema.format     = validate_type(schema, [String], "format")
+      schema.max_length = validate_type(schema, [Integer], "maxLength")
+      schema.min_length = validate_type(schema, [Integer], "minLength")
+      schema.pattern    = validate_type(schema, [String], "pattern")
+      schema.pattern    = parse_regex(schema, schema.pattern) if schema.pattern
+      validate_format(schema, schema.format) if schema.format
+
+      # hyperschema
+      schema.links      = validate_type(schema, [Array], "links")
+      schema.media      = validate_type(schema, [Hash], "media")
+      schema.path_start = validate_type(schema, [String], "pathStart")
+      schema.read_only  = validate_type(schema, BOOLEAN, "readOnly")
+
+      parse_additional_items(schema)
+      parse_additional_properties(schema)
+      parse_all_of(schema)
+      parse_any_of(schema)
+      parse_one_of(schema)
+      parse_definitions(schema)
+      parse_dependencies(schema)
+      parse_items(schema)
+      parse_links(schema)
+      parse_media(schema)
+      parse_not(schema)
+      parse_pattern_properties(schema)
+      parse_properties(schema)
+
+      schema
+    end
+
+    def validate_known_type!(schema)
+      if schema.type
+        if !(bad_types = schema.type - ALLOWED_TYPES).empty?
+          message = %{Unknown types: #{bad_types.sort.join(", ")}.}
+          @errors << SchemaError.new(schema, message, :unknown_type)
+        end
+      end
+    end
+
+    def validate_type(schema, types, field)
+      friendly_types =
+        types.map { |t| FRIENDLY_TYPES[t] || t }.sort.uniq.join("/")
+      value = schema.data[field]
+      if !value.nil? && !types.any? { |t| value.is_a?(t) }
+        message = %{#{value.inspect} is not a valid "#{field}", must be a #{friendly_types}.}
+        @errors << SchemaError.new(schema, message, :invalid_type)
+        nil
+      else
+        value
+      end
+    end
+
+    def validate_format(schema, format)
+      valid_formats = FORMATS + JsonSchema.configuration.custom_formats.keys
+      return if valid_formats.include?(format)
+
+      message = %{#{format.inspect} is not a valid format, must be one of #{valid_formats.join(', ')}.}
+      @errors << SchemaError.new(schema, message, :unknown_format)
+    end
+  end
+end