jimmy 0.5.1 → 2.0.0

data/lib/jimmy/loaders/base.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Jimmy
+  module Loaders
+    # Base class for all file loaders
+    # @abstract
+    class Base
+      # Load the given file. Intended to be used by a {Jimmy::FileMap}.
+      # @api private
+      # @param [Pathname, String] file Path of the file to load
+      def self.call(file)
+        new(file).load
+      end
+
+      # The source file to be loaded.
+      # @return Pathname
+      attr_reader :source
+
+      # @param [Pathname] source The source file to load.
+      def initialize(source)
+        @source = Pathname(source)
+      end
+
+      # @return [Jimmy::Schema]
+      def load
+        raise NotImplementedError, "Please implement #load on #{self.class}"
+      end
+    end
+  end
+end

data/lib/jimmy/loaders/json.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'jimmy/loaders/base'
+
+module Jimmy
+  module Loaders
+    # Loads a plain .json file
+    class JSON < Base
+      # @return [Jimmy::Schema]
+      def load
+        Schema.new ::JSON.parse(source.read)
+      end
+    end
+  end
+end

data/lib/jimmy/loaders/ruby.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'jimmy/macros'
+require 'jimmy/loaders/base'
+
+module Jimmy
+  module Loaders
+    # Loads .rb files
+    class Ruby < Base
+      include Macros
+
+      # @param [Pathname, string] file
+      # @return [Jimmy::Schema]
+      def load(file = source)
+        file = Pathname(file)
+        file = source.parent + file if file.relative?
+        Jimmy::Schema(instance_eval file.read, file.to_s)
+      end
+    end
+  end
+end

data/lib/jimmy/macros.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'jimmy/declaration'
+
+module Jimmy
+  # The +Macros+ module includes methods that can be called directly on the
+  # +Jimmy+ module for quickly making common types of schemas.
+  module Macros
+    include Declaration
+
+    # Make a new schema. Shortcut for +Schema.new+.
+    # @yieldparam schema [Schema] The new schema
+    # @return [Schema] The new schema.
+    def schema(&block)
+      Schema.new &block
+    end
+
+    # Make a schema that never validates.
+    # @return [Schema] The new schema.
+    def nothing
+      schema.nothing
+    end
+
+    # Make a schema that references another schema by URI.
+    # @param [String, URI, Json::URI] uri
+    # @return [Schema] The new schema.
+    def ref(uri)
+      schema.ref uri
+    end
+
+    private
+
+    def get(*args, &block)
+      {}.fetch(*args, &block)
+    end
+  end
+end

data/lib/jimmy/schema.rb

@@ -1,113 +1,133 @@
-module Jimmy
-  class Schema
-    JSON_SCHEMA_URI       = 'http://json-schema.org/draft-04/schema#'
-    JSON_HYPER_SCHEMA_URI = 'http://json-schema.org/draft-04/hyper-schema#'
-
-    attr_reader :dsl, :attrs, :domain, :type, :parent
-    attr_writer :name
-    attr_accessor :nullable
-
-    @argument_handlers = Hash.new { |hash, key| hash[key] = {} }
-    
-    def self.set_argument_handler(schema_class, arg_class, handler)
-      @argument_handlers[schema_class][arg_class] = handler
-    end
+# frozen_string_literal: true
 
-    def self.argument_hander(schema_class, argument)
-      handlers = {}
-      until schema_class == SchemaType do
-        handlers = (@argument_handlers[schema_class] || {}).merge(handlers)
-        schema_class = schema_class.superclass
-      end
-      result = handlers.find { |k, _| argument.is_a? k }
-      result && result.last
-    end
+require 'json'
+
+require 'jimmy/json/hash'
+require 'jimmy/declaration'
 
-    def compile
-      compiler = nil
-      schema_class = SchemaTypes[type]
-      until schema_class == SchemaType do
-        compiler ||= SchemaTypes.compilers[schema_class]
-        schema_class = schema_class.superclass
+module Jimmy
+  # Represents a schema as defined by http://json-schema.org/draft-07/schema
+  class Schema < Json::Hash
+    include Declaration
+
+    PROPERTIES = %w[
+      title description default readOnly writeOnly examples
+      multipleOf maximum exclusiveMaximum minimum exclusiveMinimum
+      maxLength minLength pattern
+      additionalItems items maxItems minItems uniqueItems contains
+      maxProperties minProperties required additionalProperties
+      definitions properties patternProperties dependencies propertyNames
+      const enum type format
+      contentMediaType contentEncoding
+      if then else
+      allOf anyOf oneOf
+      not
+    ].freeze
+
+    # @yieldparam schema [self] The new schema
+    def initialize(schema = {})
+      @nothing = false
+      case schema
+      when *CASTABLE_CLASSES
+        super({})
+        apply_cast self, schema
+      when Hash then super
+      else raise Error::WrongType, "Unexpected #{schema.class}"
       end
-      hash                = {}
-      hash['type']        = nullable ? ['null', type.to_s] : type.to_s
-      hash['definitions'] = definitions.compile unless definitions.empty?
-      hash['links']       = links.map &:compile unless links.empty?
-      hash.merge! data
-      dsl.evaluate compiler, hash if compiler
-      hash
+      yield self if block_given?
     end
 
-    def name
-      @name || (parent && parent.name)
+    # Returns true when the schema will never validate against anything.
+    # @return [true, false]
+    def nothing?
+      @nothing
     end
 
-    def uri
-      domain.uri_for name
+    # Returns true when the schema will validate against anything.
+    # @return [true, false]
+    def anything?
+      !@nothing && empty?
     end
 
-    def definitions
-      @definitions ||= Definitions.new(self)
+    # Set a property of the schema.
+    # @param [String, Symbol] key Symbols are converted to camel-case strings.
+    # @param [Object] value
+    def []=(key, value)
+      @nothing = false
+
+      case key
+      when '$id' then @id = value # TODO: something, with this
+      when '$ref' then ref value
+      when '$schema'
+        URI(value) == URI(SCHEMA) or
+          raise Error::BadArgument, 'Unsupported JSON schema draft'
+      when '$comment' then @comment = value # TODO: something, with this
+      else super
+      end
     end
 
-    def links
-      @links ||= []
+    # @see ::Object#inspect
+    def inspect
+      "#<#{self.class} #{super}>"
     end
 
-    def data
-      @data ||= {}
+    # Turns the schema into a reference to another schema. Freezes the schema
+    # so that no further changes can be made.
+    # @param [Json::URI, URI, String] uri The URI of the JSON schema to
+    #   reference.
+    # @return [self]
+    def ref(uri)
+      assert empty? do
+        'Reference schemas cannot have other properties: ' +
+          keys.join(', ')
+      end
+      @members['$ref'] = Json::URI.new(uri)
+      freeze
     end
 
-    def hyper?
-      links.any?
+    # Make the schema validate nothing (i.e. everything is invalid).
+    # @return [self] self
+    def nothing
+      clear
+      @nothing = true
+      self
     end
 
-    def schema_uri
-      hyper? ? JSON_HYPER_SCHEMA_URI : JSON_SCHEMA_URI
+    # Get the URI of the schema to which this schema refers, or nil if the
+    # schema is not a reference.
+    # @return [Json::URI, nil]
+    def target
+      self['$ref']
     end
 
-    def to_h
-      {'$schema' => schema_uri}.tap do |h|
-        h['id'] = uri.to_s if name
-        h.merge! compile
-      end
+    # Returns true if the schema refers to another schema.
+    # @return [true, false]
+    def ref?
+      key? '$ref'
     end
 
-    def validate(data)
-      errors = JSON::Validator.fully_validate(JSON::Validator.schema_for_uri(uri).schema, data, errors_as_objects: true)
-      raise ValidationError.new(self, data, errors) unless errors.empty?
-    end
+    alias get fetch
 
-    def initialize(type, parent)
-      @attrs  = {}
-      @type   = type
-      @domain = parent.domain
-      @dsl    = SchemaTypes.dsls[type].new(self)
-      @parent = parent if parent.is_a? self.class
-    end
+    PROPERTY_SEQUENCE = PROPERTIES.each.with_index.to_h.freeze
 
-    def setup(*args, **locals, &block)
-      args.each do |arg|
-        case arg
-          when Symbol
-            dsl.__send__ arg
-          when Hash
-            arg.each { |k, v| dsl.__send__ k, v }
-          else
-            handler = Schema.argument_hander(SchemaTypes[type], arg)
-            raise "`#{type}` cannot handle arguments of type #{arg.class.name}" unless handler
-            dsl.evaluate handler, arg
-        end
-      end
-      if block
-        if dsl.respond_to? :with_locals
-          dsl.with_locals(locals) { dsl.evaluate block }
-        else
-          dsl.evaluate block
-        end
-      end
+    # @api private
+    def sort_keys_by(key, _value) # :nodoc:
+      PROPERTY_SEQUENCE.fetch(key) { raise KeyError, 'Not a valid schema key' }
     end
 
+    protected
+
+    def schema
+      self
+    end
   end
 end
+
+require 'jimmy/schema/array'
+require 'jimmy/schema/number'
+require 'jimmy/schema/object'
+require 'jimmy/schema/string'
+
+require 'jimmy/schema/operators'
+require 'jimmy/schema/json'
+require 'jimmy/schema/casting'

data/lib/jimmy/schema/array.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Jimmy
+  class Schema
+    # Set whether the array value is required to have unique items.
+    # @param [true, false] unique Whether the array value should have unique
+    #   items.
+    # @return [self] self, for chaining
+    def unique_items(unique = true)
+      valid_for 'array'
+      assert_boolean unique
+      set uniqueItems: unique
+    end
+
+    alias unique unique_items
+
+    # Set the maximum items for an array value.
+    # @param [Numeric] count The maximum items for an array value.
+    # @return [self] self, for chaining
+    def max_items(count)
+      valid_for 'array'
+      assert_numeric count, minimum: 0
+      set maxItems: count
+    end
+
+    # Set the minimum items for an array value.
+    # @param [Numeric] count The minimum items for an array value.
+    # @return [self] self, for chaining
+    def min_items(count)
+      valid_for 'array'
+      assert_numeric count, minimum: 0
+      set minItems: count
+    end
+
+    # Set the minimum and maximum items for an array value, using a range.
+    # @param [Range, Integer] range The minimum and maximum items for an array
+    #   value. If an integer is given, it is taken to be both.
+    # @return [self] self, for chaining
+    def count(range)
+      range = range..range if range.is_a?(Integer)
+      assert_range range
+      min_items range.min
+      max_items range.max unless range.end.nil?
+      self
+    end
+
+    # Set the schema or schemas for validating items in an array value.
+    # @param [Jimmy::Schema, Array<Jimmy::Schema>] schema_or_schemas A schema
+    #   or array of schemas for validating items in an array value. If an
+    #   array of schemas is given, the first schema will apply to the first
+    #   item, and so on.
+    # @param [Jimmy::Schema, nil] rest_schema The schema to apply to items with
+    #   indexes greater than the length of the first argument. Only applicable
+    #   when an array is given for the first argument.
+    # @return [self] self, for chaining
+    def items(schema_or_schemas, rest_schema = nil)
+      if schema_or_schemas.is_a? Array
+        item *schema_or_schemas
+        set additionalItems: cast_schema(rest_schema) if rest_schema
+      else
+        match_all_items schema_or_schemas, rest_schema
+      end
+      self
+    end
+
+    # Add a single-item schema, or several, to the +items+ array. Only valid
+    # if a match-all schema has not been set.
+    # @param [Array<Jimmy::Schema>] single_item_schemas One or more schemas
+    #   to add to the existing +items+ array.
+    # @return [self] self, for chaining
+    def item(*single_item_schemas)
+      valid_for 'array'
+      assert_array(single_item_schemas, minimum: 1)
+      existing = getset('items') { [] }
+      assert !existing.is_a?(Schema) do
+        'Cannot add individual item schemas after adding a match-all schema'
+      end
+      single_item_schemas.each do |schema|
+        existing << cast_schema(schema)
+      end
+      self
+    end
+
+    private
+
+    def match_all_items(schema, rest_schema)
+      valid_for 'array'
+      assert(rest_schema.nil?) do
+        'You cannot specify an additional items schema when using a '\
+          'match-all schema'
+      end
+      set items: cast_schema(schema)
+    end
+  end
+end

data/lib/jimmy/schema/casting.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Jimmy
+  class Schema
+    private
+
+    def cast_key(key)
+      case key
+      when Regexp
+        assert_regexp key
+        super key.source
+      else
+        super
+      end
+    end
+  end
+end

data/lib/jimmy/schema/json.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Jimmy
+  class Schema
+    # The JSON Schema draft 7 schema URI
+    SCHEMA = 'http://json-schema.org/draft-07/schema#'
+
+    # Get the schema as a plain Hash. Given an +id+, the +$id+ and +$schema+
+    # keys will also be set.
+    # @param [Json::URI, URI, String] id
+    # @return [Hash, true, false]
+    def as_json(id: '', index: nil)
+      id = Json::URI.new(id)
+
+      if index.nil? && id.absolute?
+        return top_level_json(id) { super index: {}, id: id }
+      end
+
+      return true if anything?
+      return false if nothing?
+
+      super index: index || {}, id: id
+    end
+
+    private
+
+    def top_level_json(id)
+      hash = {
+        '$id'     => id.to_s,
+        '$schema' => SCHEMA
+      }
+      if nothing?
+        hash['not'] = true
+      else
+        hash.merge! yield
+      end
+      hash
+    end
+  end
+end