dry-schema 1.4.3 → 1.5.4

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

@@ -73,7 +73,7 @@ module Dry
           end
 
           # @api private
-          def visit_each(node, opts)
+          def visit_each(_node, _opts)
             # TODO: we can still generate a hint for elements here!
             []
           end

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

@@ -37,53 +37,6 @@ module Dry
             @to_h ||= failures ? messages_map : messages_map(hints)
           end
           alias_method :to_hash, :to_h
-
-          private
-
-          # @api private
-          def unique_paths
-            messages.uniq(&:path).map(&:path)
-          end
-
-          # @api private
-          def messages_map(messages = self.messages)
-            return EMPTY_HASH if empty?
-
-            messages.reduce(placeholders) { |hash, msg|
-              node = msg.path.reduce(hash) { |a, e| a.is_a?(Hash) ? a[e] : a.last[e] }
-              (node[0].is_a?(::Array) ? node[0] : node) << msg.dump
-              hash
-            }
-          end
-
-          # @api private
-          #
-          # rubocop:disable Metrics/AbcSize
-          # rubocop:disable Metrics/PerceivedComplexity
-          def initialize_placeholders!
-            @placeholders = unique_paths.each_with_object(EMPTY_HASH.dup) { |path, hash|
-              curr_idx = 0
-              last_idx = path.size - 1
-              node = hash
-
-              while curr_idx <= last_idx
-                key = path[curr_idx]
-
-                next_node =
-                  if node.is_a?(Array) && key.is_a?(Symbol)
-                    node_hash = (node << [] << {}).last
-                    node_hash[key] || (node_hash[key] = curr_idx < last_idx ? {} : [])
-                  else
-                    node[key] || (node[key] = curr_idx < last_idx ? {} : [])
-                  end
-
-                node = next_node
-                curr_idx += 1
-              end
-            }
-          end
-          # rubocop:enable Metrics/AbcSize
-          # rubocop:enable Metrics/PerceivedComplexity
         end
       end
     end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "dry/schema/extensions/info/schema_compiler"
+
+module Dry
+  module Schema
+    # Info extension
+    #
+    # @api public
+    module Info
+      module SchemaMethods
+        # Return information about keys and types
+        #
+        # @return [Hash<Symbol=>Hash>]
+        #
+        # @api public
+        def info
+          compiler = SchemaCompiler.new
+          compiler.call(to_ast)
+          compiler.to_h
+        end
+      end
+    end
+
+    Processor.include(Info::SchemaMethods)
+  end
+end

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "dry/schema/constants"
+
+module Dry
+  module Schema
+    # @api private
+    module Info
+      # @api private
+      class SchemaCompiler
+        PREDICATE_TO_TYPE = {
+          array?: "array",
+          bool?: "bool",
+          date?: "date",
+          date_time?: "date_time",
+          decimal?: "float",
+          float?: "float",
+          hash?: "hash",
+          int?: "integer",
+          nil?: "nil",
+          str?: "string",
+          time?: "time"
+        }.freeze
+
+        # @api private
+        attr_reader :keys
+
+        # @api private
+        def initialize
+          @keys = EMPTY_HASH.dup
+        end
+
+        # @api private
+        def to_h
+          {keys: keys}
+        end
+
+        # @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.each { |child| target.visit(child, opts) }
+
+          return unless key
+
+          target_info = opts[:member] ? {member: target.to_h} : target.to_h
+          type = opts[:member] ? "array" : "hash"
+
+          keys.update(key => {**keys[key], type: type, **target_info})
+        end
+
+        # @api private
+        def visit_and(node, opts = EMPTY_HASH)
+          left, right = node
+
+          visit(left, opts)
+          visit(right, opts)
+        end
+
+        # @api private
+        def visit_implication(node, opts = EMPTY_HASH)
+          node.each do |el|
+            visit(el, opts.merge(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
+          visit(rest, opts.merge(key: name, required: true))
+        end
+
+        # @api private
+        def visit_predicate(node, opts = EMPTY_HASH)
+          name, rest = node
+
+          key = opts[:key]
+
+          if name.equal?(:key?)
+            keys[rest[0][1]] = {required: opts.fetch(:required, true)}
+          else
+            type = PREDICATE_TO_TYPE[name]
+            keys[key][:type] = type if type
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'dry/monads/result'
+require "dry/monads/result"
 
 module Dry
   module Schema

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "dry/struct"
+require "dry/schema/predicate_inferrer"
+require "dry/schema/primitive_inferrer"
+require "dry/schema/macros/dsl"
+require "dry/schema/macros/hash"
+
+module Dry
+  module Schema
+    module Macros
+      Hash.prepend(::Module.new {
+        def call(*args)
+          if args.size >= 1 && args[0].is_a?(::Class) && args[0] <= ::Dry::Struct
+            if block_given?
+              raise ArgumentError, "blocks are not supported when using "\
+                                   "a struct class (#{name.inspect} => #{args[0]})"
+            end
+
+            super(args[0].schema, *args.drop(1))
+            type(schema_dsl.types[name].constructor(args[0]))
+          else
+            super
+          end
+        end
+      })
+    end
+
+    PredicateInferrer::Compiler.send(:alias_method, :visit_struct, :visit_hash)
+    PrimitiveInferrer::Compiler.send(:alias_method, :visit_struct, :visit_hash)
+  end
+end

data/lib/dry/schema/json.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'dry/schema/processor'
+require "dry/schema/processor"
 
 module Dry
   module Schema

data/lib/dry/schema/key.rb

@@ -64,6 +64,11 @@ module Dry
         new(name: name.to_s)
       end
 
+      # @api private
+      def to_dot_notation
+        [name.to_s]
+      end
+
       # @api private
       def new(**new_opts)
         self.class.new(id, name: name, coercer: coercer, **new_opts)
@@ -118,9 +123,14 @@ module Dry
         new(name: name.to_s, members: members.stringified)
       end
 
+      # @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) }
+        {name => members.map(&:dump)}
       end
     end
 
@@ -155,6 +165,11 @@ module Dry
         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 dump
         [name, member.dump]

data/lib/dry/schema/key_coercer.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'dry/core/cache'
-require 'dry/equalizer'
+require "dry/core/cache"
+require "dry/equalizer"
 
 module Dry
   module Schema
@@ -32,8 +32,8 @@ module Dry
       end
 
       # @api private
-      def call(source)
-        key_map.write(source.to_h)
+      def call(result)
+        key_map.write(result.to_h)
       end
       alias_method :[], :call
     end

data/lib/dry/schema/key_map.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require 'dry/equalizer'
-require 'dry/core/cache'
-require 'dry/schema/constants'
-require 'dry/schema/key'
+require "dry/equalizer"
+require "dry/core/cache"
+require "dry/schema/constants"
+require "dry/schema/key"
 
 module Dry
   module Schema
@@ -100,6 +100,11 @@ module Dry
         self.class.new(map(&:stringified))
       end
 
+      # @api private
+      def to_dot_notation
+        @to_dot_notation ||= map(&:to_dot_notation).flatten
+      end
+
       # Iterate over keys
       #
       # @api public

data/lib/dry/schema/key_validator.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "dry/initializer"
+require "dry/schema/constants"
+
+module Dry
+  module Schema
+    # @api private
+    class KeyValidator
+      extend Dry::Initializer
+
+      INDEX_REGEX = /\[\d+\]/.freeze
+      DIGIT_REGEX = /\A\d+\z/.freeze
+      BRACKETS = "[]"
+
+      # @api private
+      option :key_map
+
+      # @api private
+      def call(result)
+        input = result.to_h
+
+        input_paths = key_paths(input)
+        key_paths = key_map.to_dot_notation
+
+        input_paths.each do |path|
+          error_path =
+            if path[INDEX_REGEX]
+              key = path.gsub(INDEX_REGEX, BRACKETS)
+
+              if key_paths.none? { |key_path| key_path.include?(key) }
+                arr = path.gsub(INDEX_REGEX) { |m| ".#{m[1]}" }
+                arr.split(DOT).map { |s| DIGIT_REGEX.match?(s) ? s.to_i : s.to_sym }
+              end
+            elsif key_paths.none? { |key_path| key_path.include?(path) }
+              path
+            end
+
+          next unless error_path
+
+          result.add_error([:unexpected_key, [error_path, input]])
+        end
+
+        result
+      end
+
+      private
+
+      # @api private
+      def key_paths(hash)
+        hash.flat_map { |key, _|
+          case (value = hash[key])
+          when Hash
+            [key].product(key_paths(hash[key])).map { |keys| keys.join(DOT) }
+          when Array
+            hashes_or_arrays = value.select { |e| e.is_a?(Array) || e.is_a?(Hash) }
+            hashes_or_arrays.flat_map.with_index { |el, idx|
+              key_paths(el).map { |path| ["#{key}[#{idx}]", *path].join(DOT) }
+            }
+          else
+            key.to_s
+          end
+        }
+      end
+    end
+  end
+end

data/lib/dry/schema/macros.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require 'dry/schema/macros/array'
-require 'dry/schema/macros/each'
-require 'dry/schema/macros/filled'
-require 'dry/schema/macros/schema'
-require 'dry/schema/macros/hash'
-require 'dry/schema/macros/maybe'
-require 'dry/schema/macros/optional'
-require 'dry/schema/macros/required'
+require "dry/schema/macros/array"
+require "dry/schema/macros/each"
+require "dry/schema/macros/filled"
+require "dry/schema/macros/schema"
+require "dry/schema/macros/hash"
+require "dry/schema/macros/maybe"
+require "dry/schema/macros/optional"
+require "dry/schema/macros/required"

data/lib/dry/schema/macros/array.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'dry/schema/macros/dsl'
+require "dry/schema/macros/dsl"
 
 module Dry
   module Schema
@@ -13,16 +13,29 @@ module Dry
         def value(*args, **opts, &block)
           type(:array)
 
-          extract_type_spec(*args, set_type: false) do |*predicates, type_spec:|
+          extract_type_spec(*args, set_type: false) do |*predicates, type_spec:, type_rule:|
             type(schema_dsl.array[type_spec]) if type_spec
 
             is_hash_block = type_spec.equal?(:hash)
 
             if predicates.any? || opts.any? || !is_hash_block
-              super(*predicates, type_spec: type_spec, **opts, &(is_hash_block ? nil : block))
+              super(
+                *predicates, type_spec: type_spec, type_rule: type_rule, **opts,
+                &(is_hash_block ? nil : block)
+              )
             end
 
-            hash(&block) if is_hash_block
+            is_op = args.size.equal?(2) && args[1].is_a?(Logic::Operations::Abstract)
+
+            if is_hash_block && !is_op
+              hash(&block)
+            elsif is_op
+              hash = Value.new(schema_dsl: schema_dsl.new, name: name).hash(args[1])
+
+              trace.captures.concat(hash.trace.captures)
+
+              type(schema_dsl.types[name].of(hash.schema_dsl.types[name]))
+            end
           end
 
           self