dry-schema 1.6.2 → 1.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad4d59e0bdc2cc46cc165f50e1ab741c07d1c00dca7467c4a6bfd647460a6d3b
-  data.tar.gz: 295466e7e905103612280d5fdb549f116212c99c2c96b54f3561b1264174a499
+  metadata.gz: 630c8c7019a02d6f22386ef4ac1ca68321af93bd3a5e34f8b62b21d28a7eee69
+  data.tar.gz: e53baa861af349395446deb0183e7358438e4ca4ea7fa78b25d4c4f04e4ea2a5
 SHA512:
-  metadata.gz: 635185546a80867d4fc34db6d30153e43533865c3003e64bd7d7fc638cbe0cb97a7770598d3902ccf8fbd53b3b8e15253a0bb2ce4dc36c9e553fe2486491d9f1
-  data.tar.gz: 465f1b34aab9ff0c74f690aedcfef27536fea6372df401f5193b90a2347752c58d5e2a7ed020a674ac8f0c468f809b7448cda6f303eb5dd9a48575c7cea43cde
+  metadata.gz: 2ed11d1eba31d808c75018d5ea78fc649f4f59486c2047554aeabac5cd71e9b2d6e64b88661c8f0615b9a9402c177d2c51f49cd49e3ae6e697c45f9f952dab18
+  data.tar.gz: 5c085c4994f662a44eb372e92a894c76d83eefdce88389ed6c1947004c7bd39204b843ea5eb408af86ad986e6978dde67227b9bdcf7d888d1a8e277b457c4345

data/CHANGELOG.md

@@ -1,5 +1,58 @@
 <!--- DO NOT EDIT THIS FILE - IT'S AUTOMATICALLY GENERATED VIA DEVTOOLS --->
 
+## 1.9.0 2022-02-15
+
+
+### Added
+
+- [EXPERIMENTAL] `json_schema` extension which allows you to convert a schema into a JSON schema (via #369) (@ianks)
+
+### Fixed
+
+- Composing schemas no longer crashes in certain scenarios (issue #342 fixed via #366) (@vsuhachev)
+- Fix info extension for typed arrays (issue #394 fixed via #397) (@CandyFet)
+
+
+[Compare v1.8.0...v1.9.0](https://github.com/dry-rb/dry-schema/compare/v1.8.0...v1.9.0)
+
+## 1.8.0 2021-09-12
+
+
+### Changed
+
+- [internal] Upgraded to new `setting` API provided in dry-configurable 0.13.0 (@timriley in #356)
+
+[Compare v1.7.1...v1.8.0](https://github.com/dry-rb/dry-schema/compare/v1.7.1...v1.8.0)
+
+## 1.7.1 2021-08-29
+
+
+### Changed
+
+- [internal] Use explicit `#to_h` conversion of Dry::Configurable::Config, to ensure compatibility with upcoming dry-configurable 0.13.0 release (via #371) (@timriley)
+
+[Compare v1.7.0...v1.7.1](https://github.com/dry-rb/dry-schema/compare/v1.7.0...v1.7.1)
+
+## 1.7.0 2021-06-29
+
+This release ships with a bunch of internal refactorings that should improve performance but if you see any unexpected behavior please do report issues.
+
+### Fixed
+
+- Handle arrays of hashes where Array constructor coerces non-Hash input (#351 fixed via #354) (@ojab)
+- Run outer schema processor steps before inner ones (issue #350 fixed via #361) (@ojab)
+- Fix key validator false negatives on empty collections (see #363) (@Drenmi)
+- Prevent error message YAML files from being parsed multiple times (issue #352 via #364) (@alassek)
+- Using constructor types should work fine now ie `required(:foo).filled(Types::Params::Integer.constructor(&:succ))` (issue #280 fixed via #365) (@solnic)
+- Handle non-Hash to Hash transformation in `before(:key_coercer)` (issue #350 fixed via #362) (@ojab)
+
+### Changed
+
+- [internal] `Dry::Schema::Path` clean up and performance improvements (via #358) (@ojab)
+- [internal] simplify and speed up handling of steps in nested schemas (via #360) (@ojab)
+
+[Compare v1.6.2...v1.7.0](https://github.com/dry-rb/dry-schema/compare/v1.6.2...v1.7.0)
+
 ## 1.6.2 2021-04-15
 
 

data/README.md

@@ -1,3 +1,4 @@
+<!--- this file is synced from dry-rb/template-gem project -->
 [gem]: https://rubygems.org/gems/dry-schema
 [actions]: https://github.com/dry-rb/dry-schema/actions
 [codacy]: https://www.codacy.com/gh/dry-rb/dry-schema
@@ -14,15 +15,15 @@
 
 ## Links
 
-* [User documentation](http://dry-rb.org/gems/dry-schema)
+* [User documentation](https://dry-rb.org/gems/dry-schema)
 * [API documentation](http://rubydoc.info/gems/dry-schema)
 
 ## Supported Ruby versions
 
 This library officially supports the following Ruby versions:
 
-* MRI >= `2.5`
-* jruby >= `9.2`
+* MRI `>= 2.7.0`
+* jruby `>= 9.3` (postponed until 2.7 is supported)
 
 ## License
 

data/dry-schema.gemspec

@@ -1,15 +1,16 @@
 # frozen_string_literal: true
-# this file is managed by dry-rb/devtools project
 
-lib = File.expand_path('lib', __dir__)
+# this file is synced from dry-rb/template-gem project
+
+lib = File.expand_path("lib", __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'dry/schema/version'
+require "dry/schema/version"
 
 Gem::Specification.new do |spec|
-  spec.name          = 'dry-schema'
+  spec.name          = "dry-schema"
   spec.authors       = ["Piotr Solnica"]
   spec.email         = ["piotr.solnica@gmail.com"]
-  spec.license       = 'MIT'
+  spec.license       = "MIT"
   spec.version       = Dry::Schema::VERSION.dup
 
   spec.summary       = "Coercion and validation for data structures"
@@ -17,23 +18,24 @@ Gem::Specification.new do |spec|
     dry-schema provides a DSL for defining schemas with keys and rules that should be applied to
     values. It supports coercion, input sanitization, custom types and localized error messages
     (with or without I18n gem). It's also used as the schema engine in dry-validation.
+
   TEXT
-  spec.homepage      = 'https://dry-rb.org/gems/dry-schema'
+  spec.homepage      = "https://dry-rb.org/gems/dry-schema"
   spec.files         = Dir["CHANGELOG.md", "LICENSE", "README.md", "dry-schema.gemspec", "lib/**/*", "config/*.yml"]
-  spec.bindir        = 'bin'
+  spec.bindir        = "bin"
   spec.executables   = []
-  spec.require_paths = ['lib']
+  spec.require_paths = ["lib"]
 
-  spec.metadata['allowed_push_host'] = 'https://rubygems.org'
-  spec.metadata['changelog_uri']     = 'https://github.com/dry-rb/dry-schema/blob/master/CHANGELOG.md'
-  spec.metadata['source_code_uri']   = 'https://github.com/dry-rb/dry-schema'
-  spec.metadata['bug_tracker_uri']   = 'https://github.com/dry-rb/dry-schema/issues'
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  spec.metadata["changelog_uri"]     = "https://github.com/dry-rb/dry-schema/blob/master/CHANGELOG.md"
+  spec.metadata["source_code_uri"]   = "https://github.com/dry-rb/dry-schema"
+  spec.metadata["bug_tracker_uri"]   = "https://github.com/dry-rb/dry-schema/issues"
 
-  spec.required_ruby_version = ">= 2.5.0"
+  spec.required_ruby_version = ">= 2.7.0"
 
   # to update dependencies edit project.yml
   spec.add_runtime_dependency "concurrent-ruby", "~> 1.0"
-  spec.add_runtime_dependency "dry-configurable", "~> 0.8", ">= 0.8.3"
+  spec.add_runtime_dependency "dry-configurable", "~> 0.13", ">= 0.13.0"
   spec.add_runtime_dependency "dry-core", "~> 0.5", ">= 0.5"
   spec.add_runtime_dependency "dry-initializer", "~> 3.0"
   spec.add_runtime_dependency "dry-logic", "~> 1.0"

data/lib/dry/schema/compiler.rb

@@ -47,7 +47,7 @@ module Dry
       # @return [Boolean]
       #
       # @api private
-      def supports?(predicate)
+      def support?(predicate)
         predicates.key?(predicate)
       end
     end

data/lib/dry/schema/config.rb

@@ -25,7 +25,7 @@ module Dry
       # @return [Schema::PredicateRegistry]
       #
       # @api public
-      setting(:predicates, Schema::PredicateRegistry.new)
+      setting :predicates, default: Schema::PredicateRegistry.new
 
       # @!method types
       #
@@ -34,7 +34,7 @@ module Dry
       # @return [Hash]
       #
       # @api public
-      setting(:types, Dry::Types)
+      setting :types, default: Dry::Types
 
       # @!method messages
       #
@@ -43,12 +43,12 @@ module Dry
       # @return [Dry::Configurable::Config]
       #
       # @api public
-      setting(:messages) do
-        setting(:backend, :yaml)
-        setting(:namespace)
-        setting(:load_paths, Set[DEFAULT_MESSAGES_PATH], &:dup)
-        setting(:top_namespace, DEFAULT_MESSAGES_ROOT)
-        setting(:default_locale, nil)
+      setting :messages do
+        setting :backend, default: :yaml
+        setting :namespace
+        setting :load_paths, default: Set[DEFAULT_MESSAGES_PATH], constructor: :dup.to_proc
+        setting :top_namespace, default: DEFAULT_MESSAGES_ROOT
+        setting :default_locale
       end
 
       # @!method validate_keys
@@ -58,7 +58,7 @@ module Dry
       # @return [Boolean]
       #
       # @api public
-      setting(:validate_keys, false)
+      setting :validate_keys, default: false
 
       # @api private
       def respond_to_missing?(meth, include_private = false)

data/lib/dry/schema/dsl.rb

@@ -80,8 +80,10 @@ module Dry
       # Build a new DSL object and evaluate provided block
       #
       # @param [Hash] options
-      # @option options [Class] :processor The processor type (`Params`, `JSON` or a custom sub-class)
-      # @option options [Compiler] :compiler An instance of a rule compiler (must be compatible with `Schema::Compiler`) (optional)
+      # @option options [Class] :processor The processor type
+      #                                    (`Params`, `JSON` or a custom sub-class)
+      # @option options [Compiler] :compiler An instance of a rule compiler
+      #                                      (must be compatible with `Schema::Compiler`) (optional)
       # @option options [Array[DSL]] :parent One or more instances of the parent DSL (optional)
       # @option options [Config] :config A configuration object (optional)
       #
@@ -168,7 +170,8 @@ module Dry
       # A generic method for defining keys
       #
       # @param [Symbol] name The key name
-      # @param [Class] macro The macro sub-class (ie `Macros::Required` or any other `Macros::Key` subclass)
+      # @param [Class] macro The macro sub-class (ie `Macros::Required` or
+      #                      any other `Macros::Key` subclass)
       #
       # @return [Macros::Key]
       #
@@ -383,7 +386,7 @@ module Dry
       #
       # @api protected
       def rules
-        parent_rules.merge(macros.map { |m| [m.name, m.to_rule] }.to_h.compact)
+        parent_rules.merge(macros.to_h { [_1.name, _1.to_rule] }.compact)
       end
 
       # Build a key map from defined types

data/lib/dry/schema/extensions/hints/message_compiler_methods.rb

@@ -35,12 +35,14 @@ module Dry
           end
 
           # @api private
+          # rubocop: disable Metrics/AbcSize
+          # rubocop: disable Metrics/PerceivedComplexity
+          # rubocop: disable Metrics/CyclomaticComplexity
           def exclude?(messages, opts)
             Array(messages).all? do |msg|
-              hints = opts
-                .hints
-                .reject { |hint| msg == hint }
-                .reject { |hint| hint.predicate == :filled? }
+              hints = opts.hints.reject { |h|
+                msg.eql?(h) || h.predicate.eql?(:filled?)
+              }
 
               key_failure = opts.key_failure?(msg.path)
               predicate = msg.predicate
@@ -52,6 +54,9 @@ module Dry
                 HINT_OTHER_EXCLUSION.include?(predicate)
             end
           end
+          # rubocop: enable Metrics/CyclomaticComplexity
+          # rubocop: enable Metrics/PerceivedComplexity
+          # rubocop: enable Metrics/AbcSize
 
           # @api private
           def message_type(options)

data/lib/dry/schema/extensions/hints.rb

@@ -22,17 +22,19 @@ module Dry
       # @see Message::Or
       #
       # @api public
-      class Or::SinglePath
-        # @api private
-        def hint?
-          false
+      module Or
+        class SinglePath
+          # @api private
+          def hint?
+            false
+          end
         end
-      end
 
-      class Or::MultiPath
-        # @api private
-        def hint?
-          false
+        class MultiPath
+          # @api private
+          def hint?
+            false
+          end
         end
       end
 

data/lib/dry/schema/extensions/info/schema_compiler.rb

@@ -96,7 +96,16 @@ module Dry
             keys[rest[0][1]] = {required: opts.fetch(:required, true)}
           else
             type = PREDICATE_TO_TYPE[name]
-            keys[key][:type] = type if type
+            assign_type(key, type) if type
+          end
+        end
+
+        # @api private
+        def assign_type(key, type)
+          if keys[key][:type]
+            keys[key][:member] = type
+          else
+            keys[key][:type] = type
           end
         end
       end

data/lib/dry/schema/extensions/json_schema/schema_compiler.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+require "dry/schema/constants"
+
+module Dry
+  module Schema
+    # @api private
+    module JSONSchema
+      # @api private
+      class SchemaCompiler
+        # An error raised when a predicate cannot be converted
+        UnknownConversionError = Class.new(StandardError)
+
+        IDENTITY = ->(v, _) { v }.freeze
+        TO_INTEGER = ->(v, _) { v.to_i }.freeze
+
+        PREDICATE_TO_TYPE = {
+          array?: {type: "array"},
+          bool?: {type: "boolean"},
+          date?: {type: "string", format: "date"},
+          date_time?: {type: "string", format: "date-time"},
+          decimal?: {type: "number"},
+          float?: {type: "number"},
+          hash?: {type: "object"},
+          int?: {type: "integer"},
+          nil?: {type: "null"},
+          str?: {type: "string"},
+          time?: {type: "string", format: "time"},
+          min_size?: {minLength: TO_INTEGER},
+          max_size?: {maxLength: TO_INTEGER},
+          included_in?: {enum: ->(v, _) { v.to_a }},
+          filled?: EMPTY_HASH,
+          uri?: {format: "uri"},
+          uuid_v1?: {
+            pattern: "^[0-9A-F]{8}-[0-9A-F]{4}-1[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$"
+          },
+          uuid_v2?: {
+            pattern: "^[0-9A-F]{8}-[0-9A-F]{4}-2[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$"
+          },
+          uuid_v3?: {
+            pattern: "^[0-9A-F]{8}-[0-9A-F]{4}-3[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$"
+          },
+          uuid_v4?: {
+            pattern: "^[a-f0-9]{8}-?[a-f0-9]{4}-?4[a-f0-9]{3}-?[89ab][a-f0-9]{3}-?[a-f0-9]{12}$"
+          },
+          uuid_v5?: {
+            pattern: "^[0-9A-F]{8}-[0-9A-F]{4}-5[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$"
+          },
+          gt?: {exclusiveMinimum: IDENTITY},
+          gteq?: {mininum: IDENTITY},
+          lt?: {exclusiveMaximum: IDENTITY},
+          lteq?: {maximum: IDENTITY},
+          odd?: {type: "integer", not: {multipleOf: 2}},
+          even?: {type: "integer", multipleOf: 2}
+        }.freeze
+
+        # @api private
+        attr_reader :keys, :required
+
+        # @api private
+        def initialize(root: false, loose: false)
+          @keys = EMPTY_HASH.dup
+          @required = Set.new
+          @root = root
+          @loose = loose
+        end
+
+        # @api private
+        def to_hash
+          result = {}
+          result[:$schema] = "http://json-schema.org/draft-06/schema#" if root?
+          result.merge!(type: "object", properties: keys, required: required.to_a)
+          result
+        end
+
+        alias_method :to_h, :to_hash
+
+        # @api private
+        def call(ast)
+          visit(ast)
+        end
+
+        # @api private
+        def visit(node, opts = EMPTY_HASH)
+          meth, rest = node
+          public_send(:"visit_#{meth}", rest, opts)
+        end
+
+        # @api private
+        def visit_set(node, opts = EMPTY_HASH)
+          target = (key = opts[:key]) ? self.class.new : self
+
+          node.map { |child| target.visit(child, opts) }
+
+          return unless key
+
+          target_info = opts[:member] ? {items: target.to_h} : target.to_h
+          type = opts[:member] ? "array" : "object"
+
+          keys.update(key => {**keys[key], type: type, **target_info})
+        end
+
+        # @api private
+        def visit_and(node, opts = EMPTY_HASH)
+          left, right = node
+
+          # We need to know the type first to apply filled macro
+          if left[1][0] == :filled?
+            visit(right, opts)
+            visit(left, opts)
+          else
+            visit(left, opts)
+            visit(right, opts)
+          end
+        end
+
+        # @api private
+        def visit_implication(node, opts = EMPTY_HASH)
+          node.each do |el|
+            visit(el, **opts, required: false)
+          end
+        end
+
+        # @api private
+        def visit_each(node, opts = EMPTY_HASH)
+          visit(node, opts.merge(member: true))
+        end
+
+        # @api private
+        def visit_key(node, opts = EMPTY_HASH)
+          name, rest = node
+
+          if opts.fetch(:required, :true)
+            required << name.to_s
+          else
+            opts.delete(:required)
+          end
+
+          visit(rest, opts.merge(key: name))
+        end
+
+        # @api private
+        def visit_not(node, opts = EMPTY_HASH)
+          _name, rest = node
+
+          visit_predicate(rest, opts)
+        end
+
+        # @api private
+        def visit_predicate(node, opts = EMPTY_HASH)
+          name, rest = node
+
+          if name.equal?(:key?)
+            prop_name = rest[0][1]
+            keys[prop_name] = {}
+          else
+            target = keys[opts[:key]]
+            type_opts = fetch_type_opts_for_predicate(name, rest, target)
+
+            if target[:type]&.include?("array")
+              target[:items] ||= {}
+              merge_opts!(target[:items], type_opts)
+            else
+              merge_opts!(target, type_opts)
+            end
+          end
+        end
+
+        # @api private
+        def fetch_type_opts_for_predicate(name, rest, target)
+          type_opts = PREDICATE_TO_TYPE.fetch(name) do
+            raise_unknown_conversion_error!(:predicate, name) unless loose?
+
+            EMPTY_HASH
+          end.dup
+          type_opts.transform_values! { |v| v.respond_to?(:call) ? v.call(rest[0][1], target) : v }
+          type_opts.merge!(fetch_filled_options(target[:type], target)) if name == :filled?
+          type_opts
+        end
+
+        # @api private
+        def fetch_filled_options(type, _target)
+          case type
+          when "string"
+            {minLength: 1}
+          when "array"
+            raise_unknown_conversion_error!(:type, :array) unless loose?
+
+            {not: {type: "null"}}
+          else
+            {not: {type: "null"}}
+          end
+        end
+
+        # @api private
+        def merge_opts!(orig_opts, new_opts)
+          new_type = new_opts[:type]
+          orig_type = orig_opts[:type]
+
+          if orig_type && new_type && orig_type != new_type
+            new_opts[:type] = [orig_type, new_type]
+          end
+
+          orig_opts.merge!(new_opts)
+        end
+
+        # @api private
+        def root?
+          @root
+        end
+
+        # @api private
+        def loose?
+          @loose
+        end
+
+        def raise_unknown_conversion_error!(type, name)
+          message = <<~MSG
+            Could not find an equivalent conversion for #{type} #{name.inspect}.
+
+            This means that your generated JSON schema may be missing this validation.
+
+            You can ignore this by generating the schema in "loose" mode, i.e.:
+                my_schema.json_schema(loose: true)
+          MSG
+
+          raise UnknownConversionError, message.chomp
+        end
+      end
+    end
+  end
+end

data/lib/dry/schema/extensions/json_schema.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "dry/schema/extensions/json_schema/schema_compiler"
+
+module Dry
+  module Schema
+    # JSONSchema extension
+    #
+    # @api public
+    module JSONSchema
+      module SchemaMethods
+        # Convert the schema into a JSON schema hash
+        #
+        # @param [Symbol] loose Compile the schema in "loose" mode
+        #
+        # @return [Hash<Symbol=>Hash>]
+        #
+        # @api public
+        def json_schema(loose: false)
+          compiler = SchemaCompiler.new(root: true, loose: loose)
+          compiler.call(to_ast)
+          compiler.to_hash
+        end
+      end
+    end
+
+    Processor.include(JSONSchema::SchemaMethods)
+  end
+end

data/lib/dry/schema/extensions/struct.rb

@@ -18,7 +18,7 @@ module Dry
             end
 
             super(args[0].schema, *args.drop(1))
-            type(schema_dsl.types[name].constructor(args[0]))
+            type(schema_dsl.types[name].constructor(args[0].schema))
           else
             super
           end

data/lib/dry/schema/extensions.rb

@@ -15,3 +15,7 @@ end
 Dry::Schema.register_extension(:info) do
   require "dry/schema/extensions/info"
 end
+
+Dry::Schema.register_extension(:json_schema) do
+  require "dry/schema/extensions/json_schema"
+end