dry-schema 1.2.0 → 1.4.1

data/lib/dry/schema/processor_steps.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'dry/initializer'
+
+module Dry
+  module Schema
+    # Steps for the Dry::Schema::Processor
+    #
+    # There are 4 main steps:
+    #
+    #   1. `key_coercer` - Prepare input hash using a key map
+    #   2. `filter_schema` - Apply pre-coercion filtering rules
+    #      (optional step, used only when `filter` was used)
+    #   3. `value_coercer` - Apply value coercions based on type specifications
+    #   4. `rule_applier` - Apply rules
+    #
+    # @see Processor
+    #
+    # @api public
+    class ProcessorSteps
+      extend Dry::Initializer
+
+      STEPS_IN_ORDER = %i[key_coercer filter_schema value_coercer rule_applier].freeze
+
+      option :steps, default: -> { EMPTY_HASH.dup }
+      option :before_steps, default: -> { EMPTY_HASH.dup }
+      option :after_steps, default: -> { EMPTY_HASH.dup }
+
+      # Executes steps and callbacks in order
+      #
+      # @param [Result] result
+      #
+      # @return [Result]
+      #
+      # @api public
+      def call(result)
+        STEPS_IN_ORDER.each do |name|
+          before_steps[name]&.each { |step| process_step(step, result) }
+          process_step(steps[name], result)
+          after_steps[name]&.each { |step| process_step(step, result) }
+        end
+        result
+      end
+
+      # Returns step by name
+      #
+      # @param [Symbol] name The step name
+      #
+      # @api public
+      def [](name)
+        steps[name]
+      end
+
+      # Sets step by name
+      #
+      # @param [Symbol] name The step name
+      #
+      # @api public
+      def []=(name, value)
+        validate_step_name(name)
+        steps[name] = value
+      end
+
+      # Add passed block before mentioned step
+      #
+      # @param [Symbol] name The step name
+      #
+      # @return [ProcessorSteps]
+      #
+      # @api public
+      def after(name, &block)
+        validate_step_name(name)
+        after_steps[name] ||= EMPTY_ARRAY.dup
+        after_steps[name] << block.to_proc
+        self
+      end
+
+      # Add passed block before mentioned step
+      #
+      # @param [Symbol] name The step name
+      #
+      # @return [ProcessorSteps]
+      #
+      # @api public
+      def before(name, &block)
+        validate_step_name(name)
+        before_steps[name] ||= EMPTY_ARRAY.dup
+        before_steps[name] << block.to_proc
+        self
+      end
+
+      # @api private
+      def process_step(step, result)
+        return unless step
+
+        output = step.(result)
+        result.replace(output) if output.is_a?(::Hash)
+      end
+
+      # @api private
+      def validate_step_name(name)
+        return if STEPS_IN_ORDER.include?(name)
+
+        raise ArgumentError, "Undefined step name #{name}. Available names: #{STEPS_IN_ORDER}"
+      end
+
+      # @api private
+      def initialize_copy(source)
+        super
+        @steps = source.steps.dup
+        @before_steps = source.before_steps.dup
+        @after_steps = source.after_steps.dup
+      end
+    end
+  end
+end

data/lib/dry/schema/trace.rb

@@ -29,33 +29,28 @@ module Dry
       end
 
       # @api private
-      def evaluate(*predicates, **opts)
-        pred_opts = opts.dup
-        pred_opts.delete(:type_spec)
-
-        predicates.each do |predicate|
-          if predicate.respond_to?(:call)
-            append(predicate)
-          elsif predicate.is_a?(::Hash)
-            evaluate_hash_predicates(predicate)
-          elsif predicate.is_a?(::Array)
-            append(predicate.map { |pred| __send__(pred) }.reduce(:|))
-          else
-            append(__send__(predicate))
-          end
+      def evaluate(*args, type_spec: ::Dry::Schema::Undefined, **opts)
+        predicates = opts.empty? ? args : args.push(opts)
+        evaluate_predicates(predicates).each do |rule|
+          append(rule)
         end
 
-        evaluate_hash_predicates(pred_opts)
-
         self
       end
 
       # @api private
-      def evaluate_hash_predicates(predicates)
-        predicates.each do |predicate, *args|
-          append(__send__(predicate, *args))
+      def evaluate_predicates(predicates)
+        predicates.flat_map do |predicate|
+          if predicate.respond_to?(:call)
+            predicate
+          elsif predicate.is_a?(::Array)
+            predicate.map { |pred| evaluate_predicates(pred).reduce(:&) }.reduce(:|)
+          elsif predicate.is_a?(::Hash)
+            predicate.map { |pred, *args| __send__(pred, *args) }
+          else
+            __send__(predicate)
+          end
         end
-        self
       end
 
       # @api private

data/lib/dry/schema/type_registry.rb

@@ -18,12 +18,12 @@ module Dry
       attr_reader :namespace
 
       # @api private
-      def self.new(types = Dry::Types, namespace = :nominal)
+      def self.new(types = Dry::Types, namespace = :strict)
         super
       end
 
       # @api private
-      def initialize(types, namespace = :nominal)
+      def initialize(types, namespace = :strict)
         @types = types
         @namespace = namespace
       end

data/lib/dry/schema/version.rb

@@ -2,6 +2,6 @@
 
 module Dry
   module Schema
-    VERSION = '1.2.0'
+    VERSION = '1.4.1'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dry-schema
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.4.1
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-13 00:00:00.000000000 Z
+date: 2019-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -106,14 +106,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -217,8 +217,8 @@ files:
 - lib/dry/schema/predicate.rb
 - lib/dry/schema/predicate_inferrer.rb
 - lib/dry/schema/predicate_registry.rb
-- lib/dry/schema/primitive_inferrer.rb
 - lib/dry/schema/processor.rb
+- lib/dry/schema/processor_steps.rb
 - lib/dry/schema/result.rb
 - lib/dry/schema/rule_applier.rb
 - lib/dry/schema/trace.rb

data/lib/dry/schema/primitive_inferrer.rb

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-require 'dry/core/cache'
-
-module Dry
-  module Schema
-    # PrimitiveInferrer is used internally by `Macros::Filled`
-    # for inferring a list of possible primitives that a given
-    # type can handle.
-    #
-    # @api private
-    class PrimitiveInferrer
-      extend Dry::Core::Cache
-
-      # Compiler reduces type AST into a list of primitives
-      #
-      # @api private
-      class Compiler
-        # @api private
-        def visit(node)
-          meth, rest = node
-          public_send(:"visit_#{meth}", rest)
-        end
-
-        # @api private
-        def visit_nominal(node)
-          type, _ = node
-          type
-        end
-
-        # @api private
-        def visit_hash(_)
-          Hash
-        end
-
-        # @api private
-        def visit_array(_)
-          Array
-        end
-
-        # @api private
-        def visit_lax(node)
-          visit(node)
-        end
-
-        # @api private
-        def visit_constructor(node)
-          other, * = node
-          visit(other)
-        end
-
-        # @api private
-        def visit_enum(node)
-          other, * = node
-          visit(other)
-        end
-
-        # @api private
-        def visit_sum(node)
-          left, right = node
-
-          [visit(left), visit(right)].flatten(1)
-        end
-
-        # @api private
-        def visit_constrained(node)
-          other, * = node
-          visit(other)
-        end
-
-        # @api private
-        def visit_any(_)
-          Object
-        end
-      end
-
-      # @return [Compiler]
-      # @api private
-      attr_reader :compiler
-
-      # @api private
-      def initialize
-        @compiler = Compiler.new
-      end
-
-      # Infer predicate identifier from the provided type
-      #
-      # @return [Symbol]
-      #
-      # @api private
-      def [](type)
-        self.class.fetch_or_store(type.hash) do
-          Array(compiler.visit(type.to_ast)).freeze
-        end
-      end
-    end
-  end
-end