dry-schema 1.8.0 → 1.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fc91fbbcd77a2535c39ac072f7725e2cc89cf40fb1710c1f7f2f32867d37351e
-  data.tar.gz: a725bbc8ae7735fb576b827c5ee4dc00235e51287e7fb20882d8235fc61d72f5
+  metadata.gz: 630c8c7019a02d6f22386ef4ac1ca68321af93bd3a5e34f8b62b21d28a7eee69
+  data.tar.gz: e53baa861af349395446deb0183e7358438e4ca4ea7fa78b25d4c4f04e4ea2a5
 SHA512:
-  metadata.gz: 1dcb14a96c4d9e1c38ca7bafaf04a621ee71cffc75bb4f3328d46752ec291f4ee580fea7f21bc4b430277af601ca31e29c5358d3c72d38ec53e128b411921245
-  data.tar.gz: 27d66147c3be3d089d92b56ddec1b00a230d83e04606a52c14c10cb0f40648b8beb893f874e00916c5450769b1bdaf72c0df54e3e89464f96bc96986904fe465
+  metadata.gz: 2ed11d1eba31d808c75018d5ea78fc649f4f59486c2047554aeabac5cd71e9b2d6e64b88661c8f0615b9a9402c177d2c51f49cd49e3ae6e697c45f9f952dab18
+  data.tar.gz: 5c085c4994f662a44eb372e92a894c76d83eefdce88389ed6c1947004c7bd39204b843ea5eb408af86ad986e6978dde67227b9bdcf7d888d1a8e277b457c4345

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 <!--- 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
 
 

data/README.md

@@ -8,7 +8,7 @@
 # dry-schema [![Join the chat at https://dry-rb.zulipchat.com](https://img.shields.io/badge/dry--rb-join%20chat-%23346b7a.svg)][chat]
 
 [![Gem Version](https://badge.fury.io/rb/dry-schema.svg)][gem]
-[![CI Status](https://github.com/dry-rb/dry-schema/workflows/CI/badge.svg)][actions]
+[![CI Status](https://github.com/dry-rb/dry-schema/workflows/ci/badge.svg)][actions]
 [![Codacy Badge](https://api.codacy.com/project/badge/Grade/961f5c776f1d49218b2cede3745e059c)][codacy]
 [![Codacy Badge](https://api.codacy.com/project/badge/Coverage/961f5c776f1d49218b2cede3745e059c)][codacy]
 [![Inline docs](http://inch-ci.org/github/dry-rb/dry-schema.svg?branch=master)][inchpages]
@@ -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,7 +31,7 @@ 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"

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/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

data/lib/dry/schema/key.rb

@@ -85,98 +85,99 @@ module Dry
       def coerced_name
         @__coerced_name__ ||= coercer[name]
       end
-    end
-
-    # A specialized key type which handles nested hashes
-    #
-    # @api private
-    class Key::Hash < Key
-      include Dry.Equalizer(:name, :members, :coercer)
 
+      # A specialized key type which handles nested hashes
+      #
       # @api private
-      attr_reader :members
+      class Hash < self
+        include Dry.Equalizer(:name, :members, :coercer)
 
-      # @api private
-      def initialize(id, members:, **opts)
-        super(id, **opts)
-        @members = members
-      end
+        # @api private
+        attr_reader :members
 
-      # @api private
-      def read(source)
-        super if source.is_a?(::Hash)
-      end
+        # @api private
+        def initialize(id, members:, **opts)
+          super(id, **opts)
+          @members = members
+        end
 
-      def write(source, target)
-        read(source) { |value|
-          target[coerced_name] = value.is_a?(::Hash) ? members.write(value) : value
-        }
-      end
+        # @api private
+        def read(source)
+          super if source.is_a?(::Hash)
+        end
 
-      # @api private
-      def coercible(&coercer)
-        new(coercer: coercer, members: members.coercible(&coercer))
-      end
+        def write(source, target)
+          read(source) { |value|
+            target[coerced_name] = value.is_a?(::Hash) ? members.write(value) : value
+          }
+        end
 
-      # @api private
-      def stringified
-        new(name: name.to_s, members: members.stringified)
-      end
+        # @api private
+        def coercible(&coercer)
+          new(coercer: coercer, members: members.coercible(&coercer))
+        end
 
-      # @api private
-      def to_dot_notation
-        [name].product(members.flat_map(&:to_dot_notation)).map { |e| e.join(DOT) }
-      end
+        # @api private
+        def stringified
+          new(name: name.to_s, members: members.stringified)
+        end
 
-      # @api private
-      def dump
-        {name => members.map(&:dump)}
+        # @api private
+        def to_dot_notation
+          [name].product(members.flat_map(&:to_dot_notation)).map { |e| e.join(DOT) }
+        end
+
+        # @api private
+        def dump
+          {name => members.map(&:dump)}
+        end
       end
-    end
 
-    # A specialized key type which handles nested arrays
-    #
-    # @api private
-    class Key::Array < Key
-      include Dry.Equalizer(:name, :member, :coercer)
+      # A specialized key type which handles nested arrays
+      #
+      # @api private
+      class Array < self
+        include Dry.Equalizer(:name, :member, :coercer)
 
-      attr_reader :member
+        attr_reader :member
 
-      # @api private
-      def initialize(id, member:, **opts)
-        super(id, **opts)
-        @member = member
-      end
+        # @api private
+        def initialize(id, member:, **opts)
+          super(id, **opts)
+          @member = member
+        end
 
-      # @api private
-      def write(source, target)
-        read(source) { |value|
-          target[coerced_name] = if value.is_a?(::Array)
-                                   value.map { |el| el.is_a?(::Hash) ? member.write(el) : el }
-                                 else
-                                   value
-                                 end
-        }
-      end
+        # @api private
+        def write(source, target)
+          read(source) { |value|
+            target[coerced_name] =
+              if value.is_a?(::Array)
+                value.map { |el| el.is_a?(::Hash) ? member.write(el) : el }
+              else
+                value
+              end
+          }
+        end
 
-      # @api private
-      def coercible(&coercer)
-        new(coercer: coercer, member: member.coercible(&coercer))
-      end
+        # @api private
+        def coercible(&coercer)
+          new(coercer: coercer, member: member.coercible(&coercer))
+        end
 
-      # @api private
-      def stringified
-        new(name: name.to_s, member: member.stringified)
-      end
+        # @api private
+        def stringified
+          new(name: name.to_s, member: member.stringified)
+        end
 
-      # @api private
-      def to_dot_notation
-        [:"#{name}[]"].product(member.to_dot_notation).map { |el| el.join(DOT) }
-      end
+        # @api private
+        def to_dot_notation
+          [:"#{name}[]"].product(member.to_dot_notation).map { |el| el.join(DOT) }
+        end
 
-      # @api private
-      def dump
-        [name, member.dump]
+        # @api private
+        def dump
+          [name, member.dump]
+        end
       end
     end
   end

data/lib/dry/schema/key_coercer.rb

@@ -17,8 +17,8 @@ module Dry
       attr_reader :key_map, :coercer
 
       # @api private
-      def self.new(*args, &coercer)
-        fetch_or_store(*args, coercer) { super(*args, &coercer) }
+      def self.new(*args)
+        fetch_or_store(*args) { super }
       end
 
       # @api private