dry-schema 1.6.2 → 1.9.0

data/lib/dry/schema/path.rb

@@ -32,10 +32,10 @@ module Dry
           new(spec.split(DOT).map(&:to_sym))
         when Hash
           new(keys_from_hash(spec))
-        when Path
+        when self
           spec
         else
-          raise ArgumentError, "+spec+ must be either a Symbol, Array, Hash or a Path"
+          raise ArgumentError, "+spec+ must be either a Symbol, Array, Hash or a #{name}"
         end
       end
 
@@ -60,24 +60,9 @@ module Dry
 
       # @api private
       def to_h(value = EMPTY_ARRAY.dup)
-        curr_idx = 0
-        last_idx = keys.size - 1
-        hash = EMPTY_HASH.dup
-        node = hash
-
-        while curr_idx <= last_idx
-          node =
-            node[keys[curr_idx]] =
-              if curr_idx == last_idx
-                value.is_a?(Array) ? value : [value]
-              else
-                EMPTY_HASH.dup
-              end
-
-          curr_idx += 1
-        end
+        value = [value] unless value.is_a?(Array)
 
-        hash
+        keys.reverse_each.reduce(value) { |result, key| {key => result} }
       end
 
       # @api private
@@ -85,59 +70,27 @@ module Dry
         keys.each(&block)
       end
 
-      # @api private
-      def index(key)
-        keys.index(key)
-      end
-
-      def without_index
-        self.class.new(to_a[0..-2])
-      end
-
       # @api private
       def include?(other)
-        if !same_root?(other)
-          false
-        elsif index?
-          if other.index?
-            last.equal?(other.last)
-          else
-            without_index.include?(other)
-          end
-        elsif other.index? && key_matches(other, :select).size < 2
-          false
-        else
-          self >= other && !other.key_matches(self).include?(nil)
-        end
+        keys[0, other.keys.length].eql?(other.keys)
       end
 
       # @api private
       def <=>(other)
-        raise ArgumentError, "Can't compare paths from different branches" unless same_root?(other)
+        return keys.length <=> other.keys.length if include?(other) || other.include?(self)
 
-        return 0 if keys.eql?(other.keys)
+        first_uncommon_index = (self & other).keys.length
 
-        res = key_matches(other).compact.reject { |value| value.equal?(false) }
-
-        res.size < count ? 1 : -1
+        keys[first_uncommon_index] <=> other.keys[first_uncommon_index]
       end
 
       # @api private
       def &(other)
-        unless same_root?(other)
-          raise ArgumentError, "#{other.inspect} doesn't have the same root #{inspect}"
-        end
-
         self.class.new(
-          key_matches(other, :select).compact.reject { |value| value.equal?(false) }
+          keys.take_while.with_index { |key, index| other.keys[index].eql?(key) }
         )
       end
 
-      # @api private
-      def key_matches(other, meth = :map)
-        public_send(meth) { |key| (idx = other.index(key)) && keys[idx].equal?(key) }
-      end
-
       # @api private
       def last
         keys.last
@@ -148,10 +101,7 @@ module Dry
         root.equal?(other.root)
       end
 
-      # @api private
-      def index?
-        last.is_a?(Integer)
-      end
+      EMPTY = new(EMPTY_ARRAY).freeze
     end
   end
 end

data/lib/dry/schema/predicate.rb

@@ -28,8 +28,8 @@ module Dry
         # @return [Array]
         #
         # @api private
-        def to_ast(*args)
-          [:not, predicate.to_ast(*args)]
+        def to_ast(...)
+          [:not, predicate.to_ast(...)]
         end
         alias_method :ast, :to_ast
       end

data/lib/dry/schema/predicate_inferrer.rb

@@ -9,6 +9,8 @@ module Dry
       Compiler = ::Class.new(superclass::Compiler)
 
       def initialize(registry = PredicateRegistry.new)
+        super
+
         @compiler = Compiler.new(registry)
       end
     end

data/lib/dry/schema/primitive_inferrer.rb

@@ -9,6 +9,8 @@ module Dry
       Compiler = ::Class.new(superclass::Compiler)
 
       def initialize
+        super
+
         @compiler = Compiler.new
       end
     end

data/lib/dry/schema/processor.rb

@@ -28,8 +28,8 @@ module Dry
       include Dry::Logic::Operators
 
       setting :key_map_type
-      setting :type_registry_namespace, :strict
-      setting :filter_empty_string, false
+      setting :type_registry_namespace, default: :strict
+      setting :filter_empty_string, default: false
 
       option :steps, default: -> { ProcessorSteps.new }
 
@@ -53,7 +53,7 @@ module Dry
         # @api public
         def define(&block)
           @definition ||= DSL.new(
-            processor_type: self, parent: superclass.definition, **config, &block
+            processor_type: self, parent: superclass.definition, **config.to_h, &block
           )
           self
         end
@@ -84,14 +84,14 @@ module Dry
       #
       # @api public
       def call(input)
-        Result.new(input, input: input, message_compiler: message_compiler) do |result|
+        Result.new(input.dup, message_compiler: message_compiler) do |result|
           steps.call(result)
         end
       end
       alias_method :[], :call
 
       # @api public
-      def xor(other)
+      def xor(_other)
         raise NotImplementedError, "composing schemas using `xor` operator is not supported yet"
       end
       alias_method :^, :xor
@@ -123,7 +123,7 @@ module Dry
       # @api public
       def inspect
         <<~STR.strip
-          #<#{self.class.name} keys=#{key_map.map(&:dump)} rules=#{rules.map { |k, v| [k, v.to_s] }.to_h}>
+          #<#{self.class.name} keys=#{key_map.map(&:dump)} rules=#{rules.transform_values(&:to_s)}>
         STR
       end
 

data/lib/dry/schema/processor_steps.rb

@@ -87,6 +87,7 @@ module Dry
       def after(name, &block)
         after_steps[name] ||= EMPTY_ARRAY.dup
         after_steps[name] << Step.new(type: :after, name: name, executor: block)
+        after_steps[name].sort_by!(&:path)
         self
       end
 
@@ -100,6 +101,7 @@ module Dry
       def before(name, &block)
         before_steps[name] ||= EMPTY_ARRAY.dup
         before_steps[name] << Step.new(type: :before, name: name, executor: block)
+        before_steps[name].sort_by!(&:path)
         self
       end
 
@@ -120,18 +122,20 @@ module Dry
       # @api private
       def merge_callbacks(left, right)
         left.merge(right) do |_key, oldval, newval|
-          oldval + newval
+          (oldval + newval).sort_by(&:path)
         end
       end
 
       # @api private
       def import_callbacks(path, other)
         other.before_steps.each do |name, steps|
-          (before_steps[name] ||= []).concat(steps.map { |step| step.scoped(path) })
+          before_steps[name] ||= []
+          before_steps[name].concat(steps.map { |step| step.scoped(path) }).sort_by!(&:path)
         end
 
         other.after_steps.each do |name, steps|
-          (after_steps[name] ||= []).concat(steps.map { |step| step.scoped(path) })
+          after_steps[name] ||= []
+          after_steps[name].concat(steps.map { |step| step.scoped(path) }).sort_by!(&:path)
         end
       end
     end

data/lib/dry/schema/result.rb

@@ -15,24 +15,21 @@ module Dry
     class Result
       include Dry::Equalizer(:output, :errors)
 
-      extend Dry::Initializer
+      extend Dry::Initializer[undefined: false]
 
       # @api private
-      param :output
+      param :output, reader: false
 
-      # Dump result to a hash returning processed and validated data
+      # A list of failure ASTs produced by rule result objects
       #
-      # @return [Hash]
-      alias_method :to_h, :output
-
       # @api private
-      param :results, default: -> { EMPTY_ARRAY.dup }
+      option :result_ast, default: -> { EMPTY_ARRAY.dup }
 
       # @api private
       option :message_compiler
 
       # @api private
-      option :parent, default: -> { nil }
+      option :path, optional: true, reader: false
 
       # @api private
       def self.new(*, **)
@@ -48,8 +45,8 @@ module Dry
       # @return [Result]
       #
       # @api private
-      def at(path, &block)
-        new(Path[path].reduce(output) { |a, e| a[e] }, parent: self, &block)
+      def at(at_path, &block)
+        new(@output, path: Path.new([*path, *Path[at_path]]), &block)
       end
 
       # @api private
@@ -57,7 +54,7 @@ module Dry
         self.class.new(
           output,
           message_compiler: message_compiler,
-          results: results,
+          result_ast: result_ast,
           **opts,
           &block
         )
@@ -70,14 +67,35 @@ module Dry
       end
 
       # @api private
-      def replace(hash)
-        @output = hash
+      def path
+        @path || Path::EMPTY
+      end
+
+      # Dump result to a hash returning processed and validated data
+      #
+      # @return [Hash]
+      def output
+        path.equal?(Path::EMPTY) ? @output : @output.dig(*path)
+      end
+      alias_method :to_h, :output
+
+      # @api private
+      def replace(value)
+        if value.is_a?(output.class)
+          output.replace(value)
+        elsif path.equal?(Path::EMPTY)
+          @output = value
+        else
+          value_holder = path.keys.length > 1 ? @output.dig(*path.to_a[0..-2]) : @output
+
+          value_holder[path.last] = value
+        end
+
         self
       end
 
       # @api private
       def concat(other)
-        results.concat(other)
         result_ast.concat(other.map(&:to_ast))
         self
       end
@@ -164,16 +182,14 @@ module Dry
       #
       # @api public
       def inspect
-        "#<#{self.class}#{to_h.inspect} errors=#{errors.to_h.inspect}>"
+        "#<#{self.class}#{to_h.inspect} errors=#{errors.to_h.inspect} path=#{path.keys.inspect}>"
       end
 
-      if RUBY_VERSION >= "2.7"
-        # Pattern matching support
-        #
-        # @api private
-        def deconstruct_keys(_)
-          output
-        end
+      # Pattern matching support
+      #
+      # @api private
+      def deconstruct_keys(_)
+        output
       end
 
       # Add a new error AST node
@@ -182,15 +198,6 @@ module Dry
       def add_error(node)
         result_ast << node
       end
-
-      private
-
-      # A list of failure ASTs produced by rule result objects
-      #
-      # @api private
-      def result_ast
-        @result_ast ||= results.map(&:to_ast)
-      end
     end
   end
 end

data/lib/dry/schema/step.rb

@@ -17,53 +17,34 @@ module Dry
       attr_reader :executor
 
       # @api private
-      class Scoped
-        # @api private
-        attr_reader :path
-
-        # @api private
-        attr_reader :step
-
-        # @api private
-        def initialize(path, step)
-          @path = Path[path]
-          @step = step
-        end
-
-        # @api private
-        def scoped(new_path)
-          self.class.new(Path[[*new_path, *path]], step)
-        end
-
-        # @api private
-        def call(result)
-          result.at(path) do |scoped_result|
-            output = step.(scoped_result).to_h
-            target = Array(path)[0..-2].reduce(result) { |a, e| a[e] }
-
-            target.update(path.last => output)
-          end
-        end
-      end
+      attr_reader :path
 
       # @api private
-      def initialize(type:, name:, executor:)
+      def initialize(type:, name:, executor:, path: Path::EMPTY)
         @type = type
         @name = name
         @executor = executor
+        @path = path
         validate_name(name)
       end
 
       # @api private
       def call(result)
-        output = executor.(result)
-        result.replace(output) if output.is_a?(Hash)
+        scoped_result = path.equal?(Path::EMPTY) ? result : result.at(path)
+
+        output = executor.(scoped_result)
+        scoped_result.replace(output) if output.is_a?(Hash)
         output
       end
 
       # @api private
-      def scoped(path)
-        Scoped.new(path, self)
+      def scoped(parent_path)
+        self.class.new(
+          type: type,
+          name: name,
+          executor: executor,
+          path: Path.new([*parent_path, *path])
+        )
       end
 
       private

data/lib/dry/schema/trace.rb

@@ -89,6 +89,10 @@ module Dry
         captures.map(&:to_ast).map(&compiler.method(:visit)).reduce(:and)
       end
 
+      def respond_to_missing?(meth, include_private = false)
+        super || (meth.to_s.end_with?(QUESTION_MARK) && compuiler.support?(meth))
+      end
+
       # @api private
       def method_missing(meth, *args, &block)
         if meth.to_s.end_with?(QUESTION_MARK)
@@ -96,7 +100,7 @@ module Dry
             ::Kernel.raise InvalidSchemaError, "#{meth} predicate cannot be used in this context"
           end
 
-          unless compiler.supports?(meth)
+          unless compiler.support?(meth)
             ::Kernel.raise ::ArgumentError, "#{meth} predicate is not defined"
           end
 

data/lib/dry/schema/type_registry.rb

@@ -37,8 +37,7 @@ module Dry
       def [](name)
         key = [namespace, name].compact.join(DOT)
 
-        type = types.registered?(key) ? types[key] : types[name.to_s]
-        type
+        types.registered?(key) ? types[key] : types[name.to_s]
       end
     end
   end

data/lib/dry/schema/version.rb

@@ -2,6 +2,6 @@
 
 module Dry
   module Schema
-    VERSION = "1.6.2"
+    VERSION = "1.9.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dry-schema
 version: !ruby/object:Gem::Version
-  version: 1.6.2
+  version: 1.9.0
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-04-15 00:00:00.000000000 Z
+date: 2022-02-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -30,20 +30,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '0.13'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.3
+        version: 0.13.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '0.13'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.3
+        version: 0.13.0
 - !ruby/object:Gem::Dependency
   name: dry-core
   requirement: !ruby/object:Gem::Requirement
@@ -148,10 +148,11 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: |
+description: |+
   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.
+
 email:
 - piotr.solnica@gmail.com
 executables: []
@@ -177,6 +178,8 @@ files:
 - lib/dry/schema/extensions/hints/result_methods.rb
 - lib/dry/schema/extensions/info.rb
 - lib/dry/schema/extensions/info/schema_compiler.rb
+- lib/dry/schema/extensions/json_schema.rb
+- lib/dry/schema/extensions/json_schema/schema_compiler.rb
 - lib/dry/schema/extensions/monads.rb
 - lib/dry/schema/extensions/struct.rb
 - lib/dry/schema/json.rb
@@ -245,7 +248,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="