jimmy 0.5.1 → 2.0.0

data/lib/jimmy/declaration/object.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Jimmy
+  module Declaration
+    # Shortcut for +object.additional_properties(false)+.
+    # @return [Jimmy::Schema]
+    def struct
+      object.additional_properties false
+    end
+  end
+end

data/lib/jimmy/declaration/string.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Jimmy
+  module Declaration
+    FORMATS = Set.new(
+      %w[
+        date-time
+        date
+        time
+        email
+        idn-email
+        hostname
+        idn-hostname
+        ipv4
+        ipv6
+        uri
+        uri-reference
+        iri
+        iri-reference
+        uri-template
+        json-pointer
+        relative-json-pointer
+        regex
+      ]
+    ).freeze
+
+    # Set the pattern for a string value.
+    # @param [Regexp] expression The pattern for a string value. Cannot include
+    #   any options such as +/i+.
+    # @return [self] self, for chaining
+    def pattern(expression)
+      assert_regexp expression
+      string
+      set pattern: expression.source
+    end
+
+    FORMATS.each do |format|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{format.gsub '-', '_'}
+          string
+          format '#{format}'
+        end
+      RUBY
+    end
+
+    # Generated by `rake yard`. Do not modify anything below here.
+    #
+    # @!method date_time()
+    #   Validate a string with format "date-time".
+    #   @return [Schema]
+    # @!method date()
+    #   Validate a string with format "date".
+    #   @return [Schema]
+    # @!method time()
+    #   Validate a string with format "time".
+    #   @return [Schema]
+    # @!method email()
+    #   Validate a string with format "email".
+    #   @return [Schema]
+    # @!method idn_email()
+    #   Validate a string with format "idn-email".
+    #   @return [Schema]
+    # @!method hostname()
+    #   Validate a string with format "hostname".
+    #   @return [Schema]
+    # @!method idn_hostname()
+    #   Validate a string with format "idn-hostname".
+    #   @return [Schema]
+    # @!method ipv4()
+    #   Validate a string with format "ipv4".
+    #   @return [Schema]
+    # @!method ipv6()
+    #   Validate a string with format "ipv6".
+    #   @return [Schema]
+    # @!method uri()
+    #   Validate a string with format "uri".
+    #   @return [Schema]
+    # @!method uri_reference()
+    #   Validate a string with format "uri-reference".
+    #   @return [Schema]
+    # @!method iri()
+    #   Validate a string with format "iri".
+    #   @return [Schema]
+    # @!method iri_reference()
+    #   Validate a string with format "iri-reference".
+    #   @return [Schema]
+    # @!method uri_template()
+    #   Validate a string with format "uri-template".
+    #   @return [Schema]
+    # @!method json_pointer()
+    #   Validate a string with format "json-pointer".
+    #   @return [Schema]
+    # @!method relative_json_pointer()
+    #   Validate a string with format "relative-json-pointer".
+    #   @return [Schema]
+    # @!method regex()
+    #   Validate a string with format "regex".
+    #   @return [Schema]
+  end
+end

data/lib/jimmy/declaration/types.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Jimmy
+  module Declaration
+    # Acceptable values for +#type+.
+    SIMPLE_TYPES =
+      Set.new(%w[array boolean integer null number object string]).freeze
+
+    # Set the type(s) of the schema.
+    # @param [String, Array<String>] types The type(s) of the schema.
+    # @return [self] self, for chaining
+    def type(*types)
+      types = types.flatten
+      types.each &method(:assert_simple_type)
+      assert_array types, unique: true, minimum: 1
+      types = Array(get('type') { [] }) | types.flatten
+      types = types.first if types.one?
+      set type: types
+    end
+
+    alias types type
+
+    SIMPLE_TYPES.each do |type|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{type}
+          type '#{type}'
+        end
+      RUBY
+    end
+
+    alias nullable null
+
+    # Generated by `rake yard`. Do not modify anything below here.
+    #
+    # @!method array()
+    #   Make the schema allow type "array".
+    #   @return [Schema]
+    # @!method boolean()
+    #   Make the schema allow type "boolean".
+    #   @return [Schema]
+    # @!method integer()
+    #   Make the schema allow type "integer".
+    #   @return [Schema]
+    # @!method null()
+    #   Make the schema allow type "null".
+    #   @return [Schema]
+    # @!method number()
+    #   Make the schema allow type "number".
+    #   @return [Schema]
+    # @!method object()
+    #   Make the schema allow type "object".
+    #   @return [Schema]
+    # @!method string()
+    #   Make the schema allow type "string".
+    #   @return [Schema]
+  end
+end

data/lib/jimmy/error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Jimmy
+  class Error < StandardError
+    class InvalidSchemaPropertyValue < self; end
+    class WrongType < self; end
+    class BadArgument < self; end
+  end
+end

data/lib/jimmy/file_map.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require 'jimmy/index'
+require 'jimmy/loaders/ruby'
+require 'jimmy/loaders/json'
+require 'jimmy/schema_with_uri'
+require 'jimmy/schemer_factory'
+
+module Jimmy
+  # Maps a directory of files to schemas with URIs. Can be used as a URI
+  # resolver with {SchemerFactory}.
+  #
+  # Given +~/schemas/user.rb+ as a schema file:
+  #
+  #   file_map = FileMap.new('~/schemas', 'http://example.com/schemas/', suffix: '.json')
+  #   file_map.resolve('user.json') # => SchemaWithURI
+  #
+  # Calling {SchemaWithURI#as_json} on the above will include the full ID
+  # +http://example.com/schemas/user.json#+ in the +$id+ key.
+  #
+  # Including the suffix in the call to {FileMap#resolve} is optional.
+  #
+  # If you initialize a {FileMap} with +live: true+, files will be loaded
+  # lazily and repeatedly, every time {FileMap#resolve} or {FileMap#index} is
+  # called. This is intended as convenience for development environments.
+  class FileMap
+    DEFAULT_LOADERS = {
+      'rb'   => Loaders::Ruby,
+      'json' => Loaders::JSON
+    }.freeze
+
+    # @param [Pathname, String] base_dir The directory that should map to the
+    #   given URI.
+    # @param [Json::URI, URI, String] base_uri The URI that should resolve to
+    #   the given directory. If omitted, a +file://+ URI will be used for the
+    #   absolute path of the given directory.
+    # @param [true, false] live When true, schemas are not stored in memory, and
+    #   are instead live-reloaded on demand. Typically only useful for
+    #   development environments.
+    # @param [Hash{String => #call}] loaders Loaders for one or more file types.
+    #   By default, +.json+ files are parsed as-is, and +.rb+ files are
+    #   evaluated in the context of a {Loaders::Ruby} instance, which
+    #   exposes the methods in {Macros}.
+    # @param [String] suffix Optional suffix that will be appended to each
+    #   schema ID. This can be set to +".json"+ if, for example, you want your
+    #   schemas to have +.json+ suffixes when you serve them over HTTP.
+    def initialize(
+      base_dir,
+      base_uri = nil,
+      live:    false,
+      loaders: DEFAULT_LOADERS,
+      suffix:  ''
+    )
+      @dir = Pathname(base_dir).realpath
+      unless @dir.directory? && @dir.readable?
+        raise Error::BadArgument, 'Expected a readable directory'
+      end
+
+      base_uri ||= uri_for_dir
+      @uri = Json::URI.new(base_uri.to_s, container: true)
+
+      @live    = live
+      @loaders = loaders
+      @suffix  = suffix
+
+      index unless live
+    end
+
+    # Given a URI, either absolute or relative to the file map's base URI,
+    # returns a {SchemaWithURI} if a matching schema is found.
+    # @param [Json::URI, URI, String] uri
+    # @return [Jimmy::SchemaWithURI, nil]
+    def resolve(uri)
+      uri          = make_child_uri(uri)
+      absolute_uri = @uri + uri
+
+      return index.resolve(absolute_uri) unless live?
+
+      schema = load_file(path_for_uri uri)&.get_fragment(uri.fragment)
+      schema && SchemaWithURI.new(absolute_uri, schema)
+    end
+
+    alias [] resolve
+
+    # Get an index of all schemas in the file map's directory.
+    # @return [Jimmy::Index]
+    def index
+      return @index if @index
+
+      index = build_index
+      @index = index unless live?
+
+      index
+    end
+
+    # Returns true if live-reloading is enabled.
+    # @return [true, false]
+    def live?
+      @live
+    end
+
+    private
+
+    def load_file(file_base)
+      @loaders.each do |ext, loader|
+        file = Pathname("#{file_base}.#{ext}")
+        next unless file.file?
+        return loader.call(file) if file.readable?
+
+        warn "Jimmy cannot read #{file}"
+      end
+      nil
+    end
+
+    def uri_for_dir
+      Json::URI.new 'file://' + fs_to_rfc3968(@dir)
+    end
+
+    def path_for_uri(uri)
+      path  = uri.path[0..(-@suffix.length - 1)]
+      parts = path.split('/').map(&URI.method(:decode_www_form_component))
+      @dir.join(*parts)
+    end
+
+    def make_child_uri(uri)
+      uri = @uri.route_to(@uri + uri)
+
+      unless uri.host.nil? && !uri.path.match?(%r{\A(\.\.|/)})
+        raise Error::BadArgument, 'The given URI is outside this FileMap'
+      end
+
+      uri.path += @suffix unless uri.path.end_with? @suffix
+      uri
+    end
+
+    def build_index
+      index = Index.new
+
+      Dir[@dir + "**/*.{#{@loaders.keys.join ','}}"].sort.each do |file|
+        relative_uri = relative_uri_for_file(file)
+        uri          = @uri + relative_uri
+
+        index[uri] = @loaders.fetch(File.extname(file)[1..]).call(file)
+      end
+
+      index
+    end
+
+    def relative_uri_for_file(file)
+      path = Pathname(file)
+        .relative_path_from(@dir)
+        .to_s
+        .sub(/\.[^.]+\z/, '')
+
+      Json::URI.new fs_to_rfc3968(path) + @suffix
+    end
+
+    def fs_to_rfc3968(path)
+      path
+        .to_s
+        .split(File::SEPARATOR)
+        .map { |p| URI.encode_www_form_component p.sub(/:\z/, '') }
+        .join('/')
+    end
+  end
+end

data/lib/jimmy/index.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'jimmy/schema'
+require 'jimmy/schema_with_uri'
+
+module Jimmy
+  # Represents an in-memory collection of schemas
+  class Index
+    include Enumerable
+
+    def initialize # rubocop:disable Style/DocumentationMethod
+      @by_uri = {}
+    end
+
+    # @param [Json::URI, URI, String] uri
+    # @return [Jimmy::SchemaWithURI, nil]
+    def resolve(uri)
+      uri = Json::URI.new(uri)
+      raise Error::BadArgument, 'Cannot resolve relative URIs' if uri.relative?
+
+      return @by_uri[uri] if @by_uri.key? uri
+      return if uri.pointer.empty?
+
+      resolve(uri / -1)&.resolve uri
+    end
+
+    alias [] resolve
+
+    # @param [Json::URI, URI, String] uri
+    # @param [Jimmy::Schema] schema
+    # @return [self] self, for chaining
+    def add(uri, schema)
+      uri = Json::URI.new(uri)
+      raise Error::BadArgument, 'Expected a schema' unless schema.is_a? Schema
+      raise Error::BadArgument, 'Cannot index relative URIs' if uri.relative?
+
+      push SchemaWithURI.new(uri, schema)
+    end
+
+    alias []= add
+
+    # @param [Array<Jimmy::SchemaWithURI>] schemas_with_uris
+    # @return [self]
+    def push(*schemas_with_uris)
+      schemas_with_uris.each do |schema_with_uri|
+        unless schema_with_uri.is_a? SchemaWithURI
+          raise Error::BadArgument, 'Expected a SchemaWithURI'
+        end
+
+        @by_uri[schema_with_uri.uri] = schema_with_uri
+      end
+      self
+    end
+
+    alias << push
+
+    # @return [Array<Json::URI>]
+    def uris
+      @by_uri.keys
+    end
+
+    alias keys uris
+
+    # @param [Json::URI, URI, String] uri
+    # @return [true, false]
+    def uri?(uri)
+      !resolve(uri).nil?
+    end
+
+    alias key? uri?
+    alias has_key? key?
+
+    # @yieldparam [Jimmy::SchemaWithURI] schema_with_uri
+    def each(&block)
+      @by_uri.each_value &block
+    end
+  end
+end

data/lib/jimmy/json/array.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'jimmy/json/collection'
+
+module Jimmy
+  module Json
+    # Represents an array in a JSON schema.
+    class Array
+      include Collection
+
+      KEY_PATTERN = /\A(?:\d|[1-9]\d+)\z/.freeze
+
+      # @param [Array, ::Array, Set] array Items to be included in the array.
+      def initialize(array = [])
+        super()
+        @members = []
+        concat array
+      end
+
+      # Append items in +array+ to self.
+      # @param [Array, ::Array, Set] array
+      # @return [self]
+      def concat(array)
+        array = array.to_a if array.is_a? Set
+        push *array
+      end
+
+      # Add one or more items to self.
+      # @param [Array] members Things to add.
+      # @return [self]
+      def push(*members)
+        @members.concat members.map(&method(:cast_value))
+        self
+      end
+
+      alias << push
+
+      # Iterate over items in the array. If a block with a single argument is
+      # given, only values will be yielded. Otherwise, indexes and values will
+      # be yielded.
+      # @yieldparam [Integer] index The index of each item.
+      # @yieldparam [Object] member Each item.
+      # @return [Enumerable, self] If no block is given, an {::Enumerable} is
+      #   returned. Otherwise, +self+ is returned.
+      def each(&block)
+        return enum_for :each unless block
+
+        if block.arity == 1
+          @members.each { |member| yield member }
+        else
+          @members.each.with_index { |member, i| yield i, member }
+        end
+        self
+      end
+
+      # @return [Integer] The length of the array.
+      def length
+        @members.length
+      end
+
+      # Dig into the array.
+      # @param [Integer] key Index of the item to be dug or returned.
+      # @param [Array<String, Integer>] rest Keys or indexes to be passed to
+      #   resolved hashes/arrays.
+      def dig(key, *rest)
+        key = key.to_i if key.is_a?(String) && key.match?(KEY_PATTERN)
+        super key, *rest
+      end
+
+      # @return [Array] Get a regular array.
+      def to_a
+        @members.dup
+      end
+
+      alias count length
+      alias size length
+
+      protected
+
+      def export_pairs(pairs)
+        pairs.map &:last
+      end
+
+      def cast_key(key)
+        unless key.is_a? Integer
+          raise Error::WrongType, "Invalid array index of type #{key.class}"
+        end
+
+        key
+      end
+    end
+  end
+end