dato_json_schema 0.20.8

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 735c70cc15ebcd63ca8bf57f522e3530a5188edde5604477485248ec8492311f
+  data.tar.gz: ef9fa70ea29692a09b7b18b947305beb245060dcb67f30ecef35590d1c649fcf
+SHA512:
+  metadata.gz: da29a2be214acabeda042ab5d2a170711054b676087c56e568b41d83170cad46e63280e911cd4a01c5f59092418a9e507ef5bc2c80c7164ddd5680e065c029fe
+  data.tar.gz: b28c3d0fc1db24f3a11ecff03fe74c1006bfeaa97421ec2ce39bc94a03d364ea5926448a11cc13dcb58551daf2361f1bc087a18097175893d462d686a7d72336

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-2015 Brandur and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,75 @@
+# json_schema
+
+A JSON Schema V4 and Hyperschema V4 parser and validator.
+
+Validate some data based on a JSON Schema:
+
+```
+gem install json_schema
+validate-schema schema.json data.json
+```
+
+## Programmatic
+
+``` ruby
+require "json"
+require "json_schema"
+
+# parse the schema - raise SchemaError if it's invalid
+schema_data = JSON.parse(File.read("schema.json"))
+schema = JsonSchema.parse!(schema_data)
+
+# expand $ref nodes - raise SchemaError if unable to resolve
+schema.expand_references!
+
+# validate some data - raise ValidationError if it doesn't conform
+data = JSON.parse(File.read("data.json"))
+schema.validate!(data)
+
+# iterate through hyperschema links
+schema.links.each do |link|
+  puts "#{link.method} #{link.href}"
+end
+
+# abort on first error, instead of listing them all:
+schema.validate!(data, fail_fast: true)
+```
+
+Errors have a `message` (for humans), and `type` (for machines).
+`ValidationError`s also include a `path`, a JSON pointer to the location in
+the supplied document which violated the schema. See [errors](docs/errors.md)
+for more info.
+
+Non-bang methods return a two-element array, with `true`/`false` at index 0
+to indicate pass/fail, and an array of errors at index 1 (if any).
+
+Passing `fail_fast: true` (default: `false`) will cause the validator to abort
+on the first error it encounters and report just that. Even on fully valid data
+this can offer some speed improvement, since it doesn't have to collect error
+messages that might be later discarded (think of e.g. the `anyOf` directive).
+
+## Development
+
+Run the test suite with:
+
+```
+rake
+```
+
+Or run specific suites or tests with:
+
+```
+ruby -Ilib -Itest test/json_schema/validator_test.rb
+ruby -Ilib -Itest test/json_schema/validator_test.rb -n /anyOf/
+```
+
+## Release
+
+1. Update the version in `json_schema.gemspec` as appropriate for [semantic
+   versioning](http://semver.org) and add details to `CHANGELOG`.
+2. `git commit` those changes with a message like "Bump version to x.y.z".
+3. Run the `release` task:
+
+    ```
+    bundle exec rake release
+    ```

data/bin/validate-schema

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+
+require "optparse"
+require_relative "../lib/commands/validate_schema"
+
+def print_usage!
+  $stderr.puts "Usage: validate-schema <schema> <data>, ..."
+  $stderr.puts "       validate-schema -d <data>, ..."
+end
+
+command = Commands::ValidateSchema.new
+
+parser = OptionParser.new { |opts|
+  opts.on("-d", "--detect", "Detect schema from $schema") do
+    command.detect = true
+
+    # mix in common schemas for convenience
+    command.extra_schemas += ["schema.json", "hyper-schema.json"].
+      map { |f| File.expand_path(f, __FILE__ + "/../../schemas") }
+  end
+  opts.on("-s", "--schema SCHEMA", "Additional schema to use for references") do |s|
+    command.extra_schemas << s
+  end
+  opts.on("-f", "--fail-fast", "Abort after encountering the first validation error") do |s|
+    command.fail_fast = true
+  end
+}
+
+parser.parse!
+success = command.run(ARGV.dup)
+
+if success
+  command.messages.each { |m| $stdout.puts(m) }
+elsif !command.errors.empty?
+  command.errors.each { |e| $stderr.puts(e) }
+  exit(1)
+else
+  print_usage!
+  exit(1)
+end

data/lib/commands/validate_schema.rb

@@ -0,0 +1,130 @@
+require "json"
+require "yaml"
+require_relative "../json_schema"
+
+module Commands
+  class ValidateSchema
+    attr_accessor :detect
+    attr_accessor :fail_fast
+    attr_accessor :extra_schemas
+
+    attr_accessor :errors
+    attr_accessor :messages
+
+    def initialize
+      @detect = false
+      @fail_fast = false
+      @extra_schemas = []
+
+      @errors = []
+      @messages = []
+    end
+
+    def run(argv)
+      return false if !initialize_store
+
+      if !detect
+        return false if !(schema_file = argv.shift)
+        return false if !(schema = parse(schema_file))
+      end
+
+      # if there are no remaining files in arguments, also a problem
+      return false if argv.count < 1
+
+      argv.each do |data_file|
+        if !(data = read_file(data_file))
+          return false
+        end
+
+        if detect
+          if !(schema_uri = data["$schema"])
+            @errors = ["#{data_file}: No $schema tag for detection."]
+            return false
+          end
+
+          if !(schema = @store.lookup_schema(schema_uri))
+            @errors = ["#{data_file}: Unknown $schema, try specifying one with -s."]
+            return false
+          end
+        end
+
+        valid, errors = schema.validate(data, fail_fast: fail_fast)
+
+        if valid
+          @messages += ["#{data_file} is valid."]
+        else
+          @errors = map_schema_errors(data_file, errors)
+        end
+      end
+
+      @errors.empty?
+    end
+
+    private
+
+    def initialize_store
+      @store = JsonSchema::DocumentStore.new
+      extra_schemas.each do |extra_schema|
+        if !(extra_schema = parse(extra_schema))
+          return false
+        end
+        @store.add_schema(extra_schema)
+      end
+      true
+    end
+
+    # Builds a JSON Reference + message like "/path/to/file#/path/to/data".
+    def map_schema_errors(file, errors)
+      errors.map { |m| "#{file}#{m}" }
+    end
+
+    def parse(file)
+      if !(schema_data = read_file(file))
+        return nil
+      end
+
+      parser = JsonSchema::Parser.new
+      if !(schema = parser.parse(schema_data))
+        @errors = map_schema_errors(file, parser.errors)
+        return nil
+      end
+
+      expander = JsonSchema::ReferenceExpander.new
+      if !expander.expand(schema, store: @store)
+        @errors = map_schema_errors(file, expander.errors)
+        return nil
+      end
+
+      schema
+    end
+
+    def read_file(file)
+      contents = File.read(file)
+
+      # Perform an empty check because boath YAML and JSON's load will return
+      # `nil` in the case of an empty file, which will otherwise produce
+      # confusing results.
+      if contents.empty?
+        @errors = ["#{file}: File is empty."]
+        nil
+      else
+        if File.extname(file) == ".yaml"
+          YAML.load(contents)
+        else
+          JSON.load(contents)
+        end
+      end
+    rescue Errno::ENOENT
+      @errors = ["#{file}: No such file or directory."]
+      nil
+    rescue JSON::ParserError
+      # Ruby's parsing exceptions aren't too helpful, just point user to
+      # a better tool
+      @errors = ["#{file}: Invalid JSON. Try to validate using `jsonlint`."]
+      nil
+    rescue Psych::SyntaxError
+      @errors = ["#{file}: Invalid YAML."]
+      nil
+    end
+  end
+end

data/lib/json_pointer.rb

@@ -0,0 +1,7 @@
+require_relative "json_pointer/evaluator"
+
+module JsonPointer
+  def self.evaluate(data, path)
+    Evaluator.new(data).evaluate(path)
+  end
+end

data/lib/json_pointer/evaluator.rb

@@ -0,0 +1,80 @@
+module JsonPointer
+  # Evaluates a JSON pointer within a JSON document.
+  #
+  # Note that this class is designed to evaluate references across a plain JSON
+  # data object _or_ an instance of `JsonSchema::Schema`, so the constructor's
+  # `data` argument can be of either type.
+  class Evaluator
+    def initialize(data)
+      @data = data
+    end
+
+    def evaluate(original_path)
+      path = original_path
+
+      # the leading # can either be included or not
+      path = path[1..-1] if path[0] == "#"
+
+      # special case on "" or presumably "#"
+      if path.empty?
+        return @data
+      end
+
+      if path[0] != "/"
+        raise ArgumentError, %{Path must begin with a leading "/": #{original_path}.}
+      end
+
+      path_parts = split(path)
+      evaluate_segment(@data, path_parts)
+    end
+
+    private
+
+    def evaluate_segment(data, path_parts)
+      if path_parts.empty?
+        data
+      elsif data == nil
+        # spec doesn't define how to handle this, so we'll return `nil`
+        nil
+      else
+        key = transform_key(path_parts.shift)
+        if data.is_a?(Array)
+          unless key =~ /^\d+$/
+            raise ArgumentError, %{Key operating on an array must be a digit or "-": #{key}.}
+          end
+          evaluate_segment(data[key.to_i], path_parts)
+        else
+          evaluate_segment(data[key], path_parts)
+        end
+      end
+    end
+
+    # custom split method to account for blank segments
+    def split(path)
+      parts = []
+      last_index = 0
+      while index = path.index("/", last_index)
+        if index == last_index
+          parts << ""
+        else
+          parts << path[last_index...index]
+        end
+        last_index = index + 1
+      end
+      # and also get that last segment
+      parts << path[last_index..-1]
+      # it should begin with a blank segment from the leading "/"; kill that
+      parts.shift
+      parts
+    end
+
+    def transform_key(key)
+      # ~ has special meaning to JSON pointer to allow keys containing "/", so
+      # perform some transformations first as defined by the spec
+      # first as defined by the spec
+      key = key.gsub('~1', '/')
+      key = key.gsub('~0', '~')
+      key
+    end
+  end
+end

data/lib/json_reference.rb

@@ -0,0 +1,58 @@
+require "uri"
+require_relative "json_pointer"
+
+module JsonReference
+  def self.reference(ref)
+    Reference.new(ref)
+  end
+
+  class Reference
+    include Comparable
+
+    attr_accessor :pointer
+    attr_accessor :uri
+
+    def initialize(ref)
+      # Note that the #to_s of `nil` is an empty string.
+      @uri = nil
+
+      # given a simple fragment without '#', resolve as a JSON Pointer only as
+      # per spec
+      if ref.include?("#")
+        uri, @pointer = ref.split('#')
+        if uri && !uri.empty?
+          @uri = URI.parse(uri)
+        end
+        @pointer ||= ""
+      else
+        @pointer = ref
+      end
+
+      # normalize pointers by prepending "#" and stripping trailing "/"
+      @pointer = "#" + @pointer
+      @pointer = @pointer.chomp("/")
+    end
+
+    def <=>(other)
+      to_s <=> other.to_s
+    end
+
+    def inspect
+      "\#<JsonReference::Reference #{to_s}>"
+    end
+
+    # Given the document addressed by #uri, resolves the JSON Pointer part of
+    # the reference.
+    def resolve_pointer(data)
+      JsonPointer.evaluate(data, @pointer)
+    end
+
+    def to_s
+      if @uri
+        "#{@uri.to_s}#{@pointer}"
+      else
+        @pointer
+      end
+    end
+  end
+end

data/lib/json_schema.rb

@@ -0,0 +1,31 @@
+require_relative "json_schema/attributes"
+require_relative "json_schema/configuration"
+require_relative "json_schema/document_store"
+require_relative "json_schema/error"
+require_relative "json_schema/parser"
+require_relative "json_schema/reference_expander"
+require_relative "json_schema/schema"
+require_relative "json_schema/validator"
+
+module JsonSchema
+  def self.configure
+    yield configuration
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.parse(data)
+    parser = Parser.new
+    if schema = parser.parse(data)
+      [schema, nil]
+    else
+      [nil, parser.errors]
+    end
+  end
+
+  def self.parse!(data)
+    Parser.new.parse!(data)
+  end
+end