jimmy 0.5.1 → 2.0.0

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'jimmy'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/jimmy.gemspec

@@ -1,28 +1,32 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'jimmy/version'
+# frozen_string_literal: true
+
+require_relative 'lib/jimmy/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = 'jimmy'
-  spec.version       = Jimmy::VERSION
-  spec.authors       = ['Neil E. Pearson']
-  spec.email         = ['neil.pearson@orionvm.com']
+  spec.name    = 'jimmy'
+  spec.version = Jimmy::VERSION
+  spec.authors = ['Neil E. Pearson']
+  spec.email   = ['neil@helium.net.au']
+
+  spec.summary               = 'Jimmy the Gem'
+  spec.description           = 'Jimmy the Gem'
+  spec.homepage              = 'https://github.com/hx/jimmy'
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.3.0')
 
-  spec.summary       = 'Jimmy the JSON Schema DSL'
-  spec.description   = 'Jimmy makes it a snap to compose detailed JSON schema documents.'
-  spec.homepage      = 'https://github.com/hx/jimmy'
+  spec.metadata['homepage_uri']    = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+  spec.metadata['changelog_uri']   = spec.homepage
 
-  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.bindir        = 'bin'
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added
+  # into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`
+      .split("\x0")
+      .reject { |f| f.start_with? 'spec/' }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
   spec.license       = 'Apache License, Version 2.0'
-
-  spec.add_dependency 'json-schema', '~> 2.5'
-
-  spec.add_development_dependency 'bundler', '~> 1.9'
-  spec.add_development_dependency 'rake', '~> 10.0'
-  spec.add_development_dependency 'rspec', '~> 3.2'
-  spec.add_development_dependency 'diff_matcher', '~> 2.7'
 end

data/lib/jimmy.rb

@@ -1,20 +1,28 @@
-require 'pathname'
+# frozen_string_literal: true
+
+require 'jimmy/error'
 require 'jimmy/version'
+require 'jimmy/schema'
+require 'jimmy/macros'
+require 'jimmy/file_map'
+require 'jimmy/json/uri'
 
+# Jimmy makes declaring and validating against JSON schemas a piece of cake.
 module Jimmy
-    ROOT = Pathname(__FILE__).parent.parent
-end
+  ROOT = Pathname(__dir__).parent
 
-require_relative 'jimmy/symbol_array'
+  extend Macros
 
-require_relative 'jimmy/domain'
-require_relative 'jimmy/schema'
-require_relative 'jimmy/reference'
-require_relative 'jimmy/type_reference'
-require_relative 'jimmy/schema_creation'
-require_relative 'jimmy/schema_types'
-require_relative 'jimmy/schema_type'
-require_relative 'jimmy/combination'
-require_relative 'jimmy/link'
-require_relative 'jimmy/validation_error'
-require_relative 'jimmy/definitions'
+  # @see SchemerFactory#initialize
+  def self.schemer(*args, **opts)
+    SchemerFactory.new(*args, **opts).schemer
+  end
+
+  # Passes +schema+ to {Schema.new}, unless it is already a {Schema}, in which
+  # case it is returned unmodified.
+  # @param [Schema, Object] schema
+  # @return [Schema]
+  def self.Schema(schema) # rubocop:disable Naming/MethodName
+    schema.is_a?(Schema) ? schema : Schema.new(schema)
+  end
+end

data/lib/jimmy/declaration.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require 'jimmy/declaration/composites'
+require 'jimmy/declaration/number'
+require 'jimmy/declaration/object'
+require 'jimmy/declaration/string'
+require 'jimmy/declaration/types'
+
+require 'jimmy/declaration/assertion'
+require 'jimmy/declaration/casting'
+
+module Jimmy
+  # Contains methods for declaring or modifying schemas.
+  module Declaration
+    # Set the title of the schema.
+    # @param [String] title The title of the schema.
+    # @return [self] self, for chaining
+    def title(title)
+      assert_string title
+      set title: title
+    end
+
+    # Set the description of the schema.
+    # @param [String] description The description of the schema.
+    # @return [self] self, for chaining
+    def description(description)
+      assert_string description
+      set description: description
+    end
+
+    # Set the default value for the schema.
+    # @param [Object] default The default value for the schema.
+    # @return [self] self, for chaining
+    def default(default)
+      set default: default
+    end
+
+    # Set whether the schema is read-only.
+    # @param [true, false] is_read_only
+    # @return [self] self, for chaining
+    def read_only(is_read_only = true)
+      assert_boolean is_read_only
+      set readOnly: is_read_only
+    end
+
+    # Set whether the schema is write-only.
+    # @param [true, false] is_write_only
+    # @return [self] self, for chaining
+    def write_only(is_write_only = true)
+      assert_boolean is_write_only
+      set writeOnly: is_write_only
+    end
+
+    # Set a constant value that will be expected to match exactly.
+    # @param [Object] constant_value The value that will be expected to match
+    #   exactly.
+    # @return [self] self, for chaining
+    def const(constant_value)
+      set const: constant_value
+    end
+
+    # Set an enum value for the schema.
+    # @param [Array] allowed_values The allowed values in the enum.
+    # @return [self] self, for chaining
+    def enum(allowed_values)
+      assert_array allowed_values, minimum: 1, unique: true
+      set enum: allowed_values
+    end
+
+    # Add examples to the schema
+    # @param [Array] examples One or more examples to add to the schema.
+    # @return [self] self, for chaining
+    def examples(*examples)
+      getset('examples') { [] }.concat examples
+      self
+    end
+
+    alias example examples
+
+    # Add a schema to this schema's +definitions+ property.
+    # @param [String] name The name of the schema definition.
+    # @param [Jimmy::Schema] schema
+    # @yieldparam schema [Jimmy::Schema] The defined schema.
+    # @return [self] self, for chaining
+    def define(name, schema = Schema.new, &block)
+      return definitions name, &block if name.is_a? Hash
+
+      assign_to_schema_hash 'definitions', name, schema, &block
+    end
+
+    # Add definitions to the schema's +definitions+ property.
+    # @param [Hash{String => Jimmy::Schema, nil}] definitions Definitions to be
+    #   added to the schema's +definitions+ property.
+    # @yieldparam name [String] The name of a definition that was given a nil
+    #   schema.
+    # @yieldparam schema [Jimmy::Schema] A new schema created in place of a
+    #   nil hash value.
+    # @return [self] self, for chaining
+    def definitions(definitions, &block)
+      batch_assign_to_schema_hash 'definitions', definitions, &block
+    end
+
+    # Define the schema that this schema must not match.
+    # @param schema [Jimmy::Schema] The schema that must not match.
+    # @return [self] self, for chaining
+    def not(schema)
+      # TODO: combine more nots into an anyOf
+      set not: cast_schema(schema)
+    end
+
+    private
+
+    def set(props)
+      s = schema
+      props.each { |k, v| s[k.to_s] = v }
+      s
+    end
+
+    def getset(name)
+      set name => yield unless key? name
+      get name
+    end
+
+    def assign_to_schema_hash(property_name, key, schema)
+      property_name = cast_key(property_name)
+      key           = cast_key(key)
+      hash          = getset(property_name) { {} }
+      assert !hash.key?(key) do
+        "Property '#{property_name}' already has a member '#{key}'"
+      end
+      schema = cast_schema(schema)
+      yield schema if block_given?
+      hash[key] = schema
+      self
+    end
+
+    def batch_assign_to_schema_hash(property_name, hash)
+      assert_hash hash
+      hash.each do |name, schema|
+        name = cast_key(name)
+        if schema.nil? && block_given?
+          schema = Schema.new
+          yield name, schema
+        end
+        assign_to_schema_hash property_name, name, schema
+      end
+      self
+    end
+  end
+end

data/lib/jimmy/declaration/assertion.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'jimmy/error'
+
+module Jimmy
+  module Declaration
+    BOOLEANS = Set.new([true, false]).freeze
+
+    private
+
+    def assert(condition = false)
+      raise Error::InvalidSchemaPropertyValue, yield unless condition
+    end
+
+    def assert_numeric(value, minimum: -Float::INFINITY)
+      assert(value.is_a? Numeric) { "Expected #{value.class} to be numeric" }
+      assert(value >= minimum) { "Expected #{value} to be at least #{minimum}" }
+    end
+
+    def assert_string(value)
+      assert(value.is_a? String) { "Expected #{value.class} to be a string" }
+    end
+
+    def assert_simple_type(value)
+      assert_string value
+      assert SIMPLE_TYPES.include?(value) do
+        "Expected #{value.class} to be one of #{SIMPLE_TYPES.to_a.join ', '}"
+      end
+    end
+
+    def assert_boolean(value)
+      assert BOOLEANS.include? value do
+        "Expected #{value.class} to be boolean"
+      end
+    end
+
+    def assert_array(value, unique: false, minimum: 0)
+      assert(value.is_a? Array) { "Expected #{value.class} to be an array" }
+      assert(value.uniq == value) { 'Expected a unique array' } if unique
+      assert value.length >= minimum do
+        "Expected an array of at least #{minimum} item(s)"
+      end
+    end
+
+    def assert_hash(value)
+      assert(value.is_a? Hash) { "Expected #{value.class} to be a hash" }
+    end
+
+    def assert_range(value)
+      assert(value.is_a? Range) { "Expected #{value.class} to be a range " }
+    end
+
+    def assert_regexp(value)
+      assert value.is_a? Regexp do
+        "Expected #{value.class} to be regular expression"
+      end
+      assert value.options.zero? do
+        "Expected #{value.inspect} not to have any options"
+      end
+    end
+
+    def valid_for(*types)
+      assert type? *types do
+        "The property is only valid for #{types.join ', '} schemas"
+      end
+    end
+
+    # Returns true if one of the given types is an existing type.
+    # @param [Array<String>] types The type or types to check.
+    # @return [true, false]
+    def type?(*types)
+      types.each &method(:assert_simple_type)
+      existing = get('type', nil)
+      if existing.is_a? Json::Array
+        (existing.to_a & types).any?
+      else
+        types.include? existing
+      end
+    end
+  end
+end

data/lib/jimmy/declaration/casting.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Jimmy
+  module Declaration
+    private
+
+    CASTS = {
+      TrueClass  => ->(s, _) { s },
+      FalseClass => ->(s, _) { s.nothing },
+      Regexp     => ->(s, v) { s.string.pattern v },
+      Range      => ->(s, v) { s.number.range v }
+    }.freeze
+
+    CASTABLE_CLASSES = CASTS.keys.freeze
+
+    # Cast the given value to a usable schema.
+    # @param [Object] value
+    # @return [Jimmy::Schema]
+    def cast_schema(value)
+      case value
+      when *CASTABLE_CLASSES then apply_cast(Schema.new, value)
+      when Schema then value
+      else
+        assert { "Expected #{value.class} to be a schema" }
+      end
+    end
+
+    def apply_cast(schema, value)
+      CASTS.each do |klass, proc|
+        return proc.call schema, value if value.is_a? klass
+      end
+    end
+  end
+end

data/lib/jimmy/declaration/composites.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Jimmy
+  module Declaration
+    # Set the +anyOf+ value for the schema.
+    # @param [Array<Jimmy::Schema>] schemas The schemas to set as the value of
+    #   +anyOf+.
+    # @return [self] self, for chaining
+    def any_of(*schemas)
+      set_composite 'anyOf', schemas.flatten
+    end
+
+    # Set the +allOf+ value for the schema.
+    # @param [Array<Jimmy::Schema>] schemas The schemas to set as the value of
+    #   +allOf+.
+    # @return [self] self, for chaining
+    def all_of(*schemas)
+      set_composite 'allOf', schemas.flatten
+    end
+
+    # Set the +oneOf+ value for the schema.
+    # @param [Array<Jimmy::Schema>] schemas The schemas to set as the value of
+    #   +oneOf+.
+    # @return [self] self, for chaining
+    def one_of(*schemas)
+      set_composite 'oneOf', schemas.flatten
+    end
+
+    private
+
+    # @return [self]
+    def set_composite(name, schemas)
+      assert_array schemas, minimum: 1
+      schemas = schemas.map(&method(:cast_schema))
+      assert schemas.none? { |s| s.anything? || s.nothing? } do
+        'Absolutes make no sense in composites'
+      end
+      set name => schemas
+    end
+  end
+end

data/lib/jimmy/declaration/number.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Jimmy
+  module Declaration
+    # Set the number of which the value should be a multiple.
+    # @param [Numeric] number The number to set as the multipleOf value
+    # @return [self] self, for chaining
+    def multiple_of(number)
+      valid_for 'number', 'integer'
+      assert_numeric number
+      assert(number.positive?) { "Expected #{number} to be positive" }
+      set multipleOf: number
+    end
+
+    # Set minimum and maximum by providing a range.
+    # @param [Range] range The range to use for minimum and maximum values.
+    # @return [self] self, for chaining
+    def range(range)
+      assert_range range
+      schema.minimum range.begin
+      unless range.end.nil?
+        schema.maximum range.end, exclusive: range.exclude_end?
+      end
+      self
+    end
+  end
+end