jimmy 0.5.1 → 2.0.0

data/lib/jimmy/schema/number.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Jimmy
+  class Schema
+    # Set the minimum value.
+    # @param [Numeric] number The minimum numeric value.
+    # @param [true, false] exclusive Whether the value is included in the
+    #   minimum.
+    # @return [self] self, for chaining
+    def minimum(number, exclusive: false)
+      set_numeric_boundary 'minimum', number, exclusive
+    end
+
+    # Set the exclusive minimum value.
+    # @param [Numeric] number The exclusive minimum numeric value.
+    # @return [self] self, for chaining
+    def exclusive_minimum(number)
+      minimum number, exclusive: true
+    end
+
+    # Set the maximum value.
+    # @param [Numeric] number The maximum numeric value.
+    # @param [true, false] exclusive Whether the value is included in the
+    #   maximum.
+    # @return [self] self, for chaining
+    def maximum(number, exclusive: false)
+      set_numeric_boundary 'maximum', number, exclusive
+    end
+
+    # Set the exclusive maximum value.
+    # @param [Numeric] number The exclusive maximum numeric value.
+    # @return [self] self, for chaining
+    def exclusive_maximum(number)
+      maximum number, exclusive: true
+    end
+
+    private
+
+    def set_numeric_boundary(name, number, exclusive)
+      valid_for 'number', 'integer'
+      assert_numeric number
+      assert_boolean exclusive
+      name = 'exclusive' + name[0].upcase + name[1..] if exclusive
+      set name => number
+    end
+  end
+end

data/lib/jimmy/schema/object.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Jimmy
+  class Schema
+    # Define a property for an object value.
+    # @param [String, Symbol] name The name of the property.
+    # @param [Jimmy::Schema] schema The schema for the property. If
+    #   omitted, a new Schema will be created, and will be yielded if a block
+    #   is given.
+    # @param [true, false] required If true, +name+ will be added to the
+    #   +required+ property.
+    # @yieldparam schema [Jimmy::Schema] The schema being assigned.
+    # @return [self] self, for chaining
+    def property(name, schema = Schema.new, required: false, &block)
+      return properties(name, required: required, &block) if name.is_a? Hash
+
+      valid_for 'object'
+      collection = collection_for_property_key(name)
+      assign_to_schema_hash collection, name, schema, &block
+      require name if required
+      self
+    end
+
+    # Define properties for an object value.
+    # @param [Hash{String, Symbol => Jimmy::Schema, nil}] properties
+    # @param [true, false] required If true, literal (non-pattern) properties
+    #   will be added to the +required+ property.
+    # @yieldparam name [String] The name of a property that was given with a nil
+    #   schema.
+    # @yieldparam schema [Jimmy::Schema] A new schema created for a property
+    #   that was given without one.
+    # @return [self] self, for chaining
+    def properties(properties, required: false, &block)
+      valid_for 'object'
+      assert_hash properties
+      groups = properties.group_by { |k, _| collection_for_property_key k }
+      groups.each do |collection, pairs|
+        batch_assign_to_schema_hash collection, pairs.to_h, &block
+      end
+      require *properties.keys if required
+      self
+    end
+
+    alias allow properties
+
+    # Designate the given properties as required for object values.
+    # @param [Array<String, Symbol, Hash{String, Symbol => Jimmy::Schema, nil}>]
+    #   properties Names of properties that are required, or hashes that can be
+    #   passed to +#properties+, and whose keys will also be added to the
+    #   +required+ property.
+    # @yieldparam name [String] The name of a property that was given with a nil
+    #   schema.
+    # @yieldparam schema [Jimmy::Schema] A new schema created for a property
+    #   that was given without one.
+    # @return [self] self, for chaining
+    def require(*properties, &block)
+      properties.each do |name|
+        if name.is_a? Hash
+          self.properties name, required: true, &block
+        else
+          getset('required') { Set.new } << validate_property_name(name)
+        end
+      end
+      self
+    end
+
+    alias requires require
+
+    # Require all properties that have been explicitly defined for object
+    #   values.
+    # @return [self] self, for chaining
+    def require_all
+      require *get('properties') { {} }.keys
+    end
+
+    # Set the schema for additional properties not matching those given to
+    # +#require+, +#property+, and +#properties+. Pass +false+ to disallow
+    # additional properties.
+    # @param [Jimmy::Schema, true, false] schema
+    # @return [self] self, for chaining
+    def additional_properties(schema)
+      set additionalProperties: cast_schema(schema)
+    end
+
+    private
+
+    def collection_for_property_key(key)
+      if key.is_a? Regexp
+        'patternProperties'
+      else
+        'properties'
+      end
+    end
+
+    def validate_property_name(name)
+      name = cast_key(name)
+      assert_string name
+      return name unless get('additionalProperties', nil) == Schema.new.nothing
+
+      names    = get('properties') { {} }.keys
+      patterns = get('patternProperties') { {} }.keys
+      assert names.include?(name) || patterns.any? { |p| p.match? name } do
+        "Expected '#{name}' to be an existing property"
+      end
+      name
+    end
+  end
+end

data/lib/jimmy/schema/operators.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Jimmy
+  class Schema
+    # Compare the schema to another schema.
+    # @param [Schema] other
+    # @return [true, false]
+    def ==(other)
+      return false unless other.is_a? Schema
+
+      other.as_json == as_json
+    end
+
+    # Get the opposite of this schema, by wrapping it in a new schema's +not+
+    # property.
+    #
+    # If this schema's only property is +not+, its value will instead
+    # be returned. Therefore:
+    #
+    #   schema.negated.negated == schema
+    #
+    # Since +#!+ is an alias for +#negated+, this also works:
+    #
+    #   !!schema == schema
+    #
+    # Schemas matching absolutes +ANYTHING+ or +NOTHING+ will return the
+    # opposite absolute.
+    # @return [Jimmy::Schema]
+    def negated
+      return Schema.new if nothing?
+      return Schema.new.nothing if anything?
+      return get('not') if keys == ['not']
+
+      Schema.new.not self
+    end
+
+    # Combine this schema with another schema using an +allOf+ schema. If this
+    # schema's only property is +allOf+, its items will be flattened into the
+    # new schema.
+    #
+    # Since +#&+ is an alias of +#and+, the following two statements are
+    # equivalent:
+    #
+    #   schema.and(other)
+    #   schema & other
+    # @param [Jimmy::Schema] other The other schema.
+    # @return [Jimmy::Schema] The new schema.
+    def and(other)
+      make_new_composite 'allOf', other
+    end
+
+    # Combine this schema with another schema using an +anyOf+ schema. If this
+    # schema's only property is +anyOf+, its items will be flattened into the
+    # new schema.
+    #
+    # Since +#|+ is an alias of +#or+, the following two statements are
+    # equivalent:
+    #
+    #   schema.or(other)
+    #   schema | other
+    # @param [Jimmy::Schema] other The other schema.
+    # @return [Jimmy::Schema] The new schema.
+    def or(other)
+      make_new_composite 'anyOf', other
+    end
+
+    # Combine this schema with another schema using a +oneOf+ schema. If this
+    # schema's only property is +oneOf+, its items will be flattened into the
+    # new schema.
+    #
+    # Since +#^+ is an alias of +#xor+, the following two statements are
+    # equivalent:
+    #
+    #   schema.xor(other)
+    #   schema ^ other
+    # @param [Jimmy::Schema] other The other schema.
+    # @return [Jimmy::Schema] The new schema.
+    def xor(other)
+      make_new_composite 'oneOf', other
+    end
+
+    alias & and
+    alias | or
+    alias ^ xor
+    alias ! negated
+
+    private
+
+    def make_new_composite(name, other)
+      return self if other == self
+
+      this = keys == [name] ? get(name) : [self]
+      Schema.new.instance_exec { set_composite name, [*this, other] }
+    end
+  end
+end

data/lib/jimmy/schema/string.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Jimmy
+  class Schema
+    # Set the maximum length for a string value.
+    # @param [Numeric] length The maximum length for a string value.
+    # @return [self] self, for chaining
+    def max_length(length)
+      valid_for 'string'
+      assert_numeric length, minimum: 0
+      set maxLength: length
+    end
+
+    # Set the minimum length for a string value.
+    # @param [Numeric] length The minimum length for a string value.
+    # @return [self] self, for chaining
+    def min_length(length)
+      valid_for 'string'
+      assert_numeric length, minimum: 0
+      set minLength: length
+    end
+
+    # Set the minimum and maximum length for a string value, using a range.
+    # @param [Range, Integer] range The minimum and maximum length for a string
+    #   value. If an integer is given, it is taken to be both.
+    # @return [self] self, for chaining
+    def length(range)
+      range = range..range if range.is_a?(Integer)
+      assert_range range
+      min_length range.min
+      max_length range.max unless range.end.nil?
+      self
+    end
+
+    # Set the format for a string value.
+    # @param [String] format_name The named format for a string value.
+    # @return [self] self, for chaining
+    def format(format_name)
+      valid_for 'string'
+      assert_string format_name
+      set format: format_name
+    end
+  end
+end

data/lib/jimmy/schema_with_uri.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Jimmy
+  # Represents a schema with a URI.
+  class SchemaWithURI
+    # @return [Json::URI]
+    attr_reader :uri
+    # @return [Schema]
+    attr_reader :schema
+
+    # @param [URI, String, Json::URI] uri
+    # @param [Schema] schema
+    def initialize(uri, schema)
+      @uri    = Json::URI.new(uri)
+      @schema = schema
+      freeze
+    end
+
+    # @return [Hash{String => Object}]
+    def as_json(*)
+      @schema.as_json id: @uri
+    end
+
+    # @return [String]
+    def to_json(**opts)
+      ::JSON.generate as_json, **opts
+    end
+
+    # Returns true if +other+ has a matching URI and Schema.
+    # @param [SchemaWithURI] other
+    # @return [true, false]
+    def ==(other)
+      other.is_a?(self.class) && uri == other.uri && schema == other.schema
+    end
+
+    # Attempt to resolve URI using {#schema}. This will only succeed if +uri+
+    # represents a fragment of {#schema}.
+    # @raise [Error::BadArgument] Raised if the URI is outside {#uri}.
+    # @param [String, URI, Json::URI] uri
+    # @return [SchemaWithURI, nil]
+    def resolve(uri)
+      uri = Json::URI.new(uri)
+      raise Error::BadArgument, 'Cannot resolve relative URIs' if uri.relative?
+      raise Error::BadArgument, 'Wrong URI base' unless uri + '#' == @uri + '#'
+
+      pointer = uri.pointer.remove_prefix(@uri.pointer) or return
+
+      return unless (fragment = @schema.get_fragment(pointer))
+
+      self.class.new uri, fragment
+    end
+  end
+end

data/lib/jimmy/schemer_factory.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Jimmy
+  # Factory class for making +JSONSchemer::Schema::Base+ instances
+  class SchemerFactory
+    # Returns true if the +json_schemer+ gem is loaded.
+    # @return [true, false]
+    def self.available?
+      defined? ::JSONSchemer
+    end
+
+    # @param [Schema, #as_json] schema
+    # @param [Array<#resolve, 'net/http'>] resolvers
+    # @param [true, false] cache_resolvers
+    # @param [Hash] opts Options to be passed to +JSONSchemer+
+    def initialize(schema, *resolvers, cache_resolvers: true, **opts)
+      unless self.class.available?
+        raise LoadError, 'Please add the json_schemer gem to your Gemfile'
+      end
+
+      @schema    = schema
+      @resolvers = resolvers.map(&method(:cast_resolver))
+      @options   = opts.dup
+
+      return if @resolvers.empty?
+
+      res = method(:resolve)
+      res = JSONSchemer::CachedRefResolver.new(&res) if cache_resolvers
+      @options[:ref_resolver] = res
+    end
+
+    # Get an instance of {JSONSchemer::Schema::Base} that can be used to
+    # validate JSON documents against the given {Schema}.
+    # @return [JSONSchemer::Schema::Base]
+    def schemer
+      @schemer ||= JSONSchemer.schema(@schema.as_json, **@options)
+    end
+
+    # @param [String, URI, Json::URI] uri
+    # @return [Hash{String => Object}, nil]
+    def resolve(uri)
+      @resolvers.each do |resolver|
+        return resolver.call(uri) unless resolver.respond_to? :resolve
+
+        schema = resolver.resolve(uri)
+        return schema.as_json if schema
+      end
+      nil
+    end
+
+    private
+
+    def cast_resolver(resolver)
+      if resolver == 'net/http'
+        return JSONSchemer::Schema::Base::NET_HTTP_REF_RESOLVER
+      end
+
+      unless resolver.respond_to? :resolve
+        raise Error::BadArgument, 'Expected an object responding to :resolve'
+      end
+
+      resolver
+    end
+  end
+end

data/lib/jimmy/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Jimmy
-  VERSION = '0.5.1'
+  VERSION = '2.0.0'
 end

data/schema07.json

@@ -0,0 +1,172 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "http://json-schema.org/draft-07/schema#",
+  "title": "Core schema meta-schema",
+  "definitions": {
+    "schemaArray": {
+      "type": "array",
+      "minItems": 1,
+      "items": { "$ref": "#" }
+    },
+    "nonNegativeInteger": {
+      "type": "integer",
+      "minimum": 0
+    },
+    "nonNegativeIntegerDefault0": {
+      "allOf": [
+        { "$ref": "#/definitions/nonNegativeInteger" },
+        { "default": 0 }
+      ]
+    },
+    "simpleTypes": {
+      "enum": [
+        "array",
+        "boolean",
+        "integer",
+        "null",
+        "number",
+        "object",
+        "string"
+      ]
+    },
+    "stringArray": {
+      "type": "array",
+      "items": { "type": "string" },
+      "uniqueItems": true,
+      "default": []
+    }
+  },
+  "type": ["object", "boolean"],
+  "properties": {
+    "$id": {
+      "type": "string",
+      "format": "uri-reference"
+    },
+    "$schema": {
+      "type": "string",
+      "format": "uri"
+    },
+    "$ref": {
+      "type": "string",
+      "format": "uri-reference"
+    },
+    "$comment": {
+      "type": "string"
+    },
+    "title": {
+      "type": "string"
+    },
+    "description": {
+      "type": "string"
+    },
+    "default": true,
+    "readOnly": {
+      "type": "boolean",
+      "default": false
+    },
+    "writeOnly": {
+      "type": "boolean",
+      "default": false
+    },
+    "examples": {
+      "type": "array",
+      "items": true
+    },
+    "multipleOf": {
+      "type": "number",
+      "exclusiveMinimum": 0
+    },
+    "maximum": {
+      "type": "number"
+    },
+    "exclusiveMaximum": {
+      "type": "number"
+    },
+    "minimum": {
+      "type": "number"
+    },
+    "exclusiveMinimum": {
+      "type": "number"
+    },
+    "maxLength": { "$ref": "#/definitions/nonNegativeInteger" },
+    "minLength": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+    "pattern": {
+      "type": "string",
+      "format": "regex"
+    },
+    "additionalItems": { "$ref": "#" },
+    "items": {
+      "anyOf": [
+        { "$ref": "#" },
+        { "$ref": "#/definitions/schemaArray" }
+      ],
+      "default": true
+    },
+    "maxItems": { "$ref": "#/definitions/nonNegativeInteger" },
+    "minItems": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+    "uniqueItems": {
+      "type": "boolean",
+      "default": false
+    },
+    "contains": { "$ref": "#" },
+    "maxProperties": { "$ref": "#/definitions/nonNegativeInteger" },
+    "minProperties": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+    "required": { "$ref": "#/definitions/stringArray" },
+    "additionalProperties": { "$ref": "#" },
+    "definitions": {
+      "type": "object",
+      "additionalProperties": { "$ref": "#" },
+      "default": {}
+    },
+    "properties": {
+      "type": "object",
+      "additionalProperties": { "$ref": "#" },
+      "default": {}
+    },
+    "patternProperties": {
+      "type": "object",
+      "additionalProperties": { "$ref": "#" },
+      "propertyNames": { "format": "regex" },
+      "default": {}
+    },
+    "dependencies": {
+      "type": "object",
+      "additionalProperties": {
+        "anyOf": [
+          { "$ref": "#" },
+          { "$ref": "#/definitions/stringArray" }
+        ]
+      }
+    },
+    "propertyNames": { "$ref": "#" },
+    "const": true,
+    "enum": {
+      "type": "array",
+      "items": true,
+      "minItems": 1,
+      "uniqueItems": true
+    },
+    "type": {
+      "anyOf": [
+        { "$ref": "#/definitions/simpleTypes" },
+        {
+          "type": "array",
+          "items": { "$ref": "#/definitions/simpleTypes" },
+          "minItems": 1,
+          "uniqueItems": true
+        }
+      ]
+    },
+    "format": { "type": "string" },
+    "contentMediaType": { "type": "string" },
+    "contentEncoding": { "type": "string" },
+    "if": { "$ref": "#" },
+    "then": { "$ref": "#" },
+    "else": { "$ref": "#" },
+    "allOf": { "$ref": "#/definitions/schemaArray" },
+    "anyOf": { "$ref": "#/definitions/schemaArray" },
+    "oneOf": { "$ref": "#/definitions/schemaArray" },
+    "not": { "$ref": "#" }
+  },
+  "default": true
+}