dry-schema 1.7.0 → 1.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 305c1a8710478195cc35c3de75a1f50834c2cc044b0a6d62bb7c95845ff48db8
-  data.tar.gz: 62254023ae1e6ee82ecf7023e3900906a75ebda86676c59dfa24269d337af7f8
+  metadata.gz: c4447e05345b9fee9c6fa8014f1650d2f366428450f1a8b5de29da67794db47f
+  data.tar.gz: 5dd78346a5a1f0e8df66f81ccb409e5870b409bb24547960954680b550186125
 SHA512:
-  metadata.gz: '08c894bf7682d81654ecd9034ae71e14c10e314997196cf11ee39ddaadf799aabeba33e7398aeb54961ba4b19a67e0d68cb3142ebccc182df18dd64ebca3c725'
-  data.tar.gz: 947264e7d824feededff8608e6e090592287503cb699d11ab31183955c963a01c1ceaeaa977c19d8add8e719a329ed1afbe72d8dd51f86603750c2502fd41a98
+  metadata.gz: 1545a765733867780eef3bbfdcb4a5bf2fa9a4e7a5c7c47542a720e19f0b43a0ceef35e59a1c8238a4d4c2a38c7c01690d70df3677bc8a46f1e47d0d9eef3996
+  data.tar.gz: a9c514202ba40aa68a503fa06a11f814cdaef34f196ad14664d23b13d713d364d328cfb73acbd889d55687e7e157e65b1e433df512c1ea2a18ff81bd5c7cb119

data/CHANGELOG.md

@@ -1,5 +1,48 @@
 <!--- DO NOT EDIT THIS FILE - IT'S AUTOMATICALLY GENERATED VIA DEVTOOLS --->
 
+## 1.9.1 2022-02-17
+
+
+### Fixed
+
+- Namespaced messages no longer crashes in certain scenarios (see dry-rb/dry-validation#692 fixed via #398) (@krekoten)
+
+
+[Compare v1.9.0...v1.9.1](https://github.com/dry-rb/dry-schema/compare/v1.9.0...v1.9.1)
+
+## 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.

data/README.md

@@ -22,8 +22,8 @@
 
 This library officially supports the following Ruby versions:
 
-* MRI `>= 2.6.0`
-* ~~jruby~~ `>= 9.3` (we are waiting for [2.6 support](https://github.com/jruby/jruby/issues/6161))
+* MRI `>= 2.7.0`
+* jruby `>= 9.3` (postponed until 2.7 is supported)
 
 ## License
 

data/dry-schema.gemspec

@@ -31,11 +31,11 @@ Gem::Specification.new do |spec|
   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.6.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