dry-schema 1.3.0 → 1.4.0

data/lib/dry/schema/messages/i18n.rb

@@ -79,6 +79,15 @@ module Dry
         self
       end
 
+      # @api private
+      def cache_key(predicate, options)
+        if options[:locale]
+          super
+        else
+          [*super, I18n.locale]
+        end
+      end
+
       private
 
       # @api private

data/lib/dry/schema/messages/namespaced.rb

@@ -55,7 +55,7 @@ module Dry
         end
 
         # @api private
-        def lookup_paths(tokens)
+        def filled_lookup_paths(tokens)
           super(tokens.merge(root: "#{tokens[:root]}.#{namespace}")) + super
         end
 
@@ -64,6 +64,11 @@ module Dry
           base_paths = messages.rule_lookup_paths(tokens)
           base_paths.map { |key| key.gsub('dry_schema', "dry_schema.#{namespace}") } + base_paths
         end
+
+        # @api private
+        def cache_key(predicate, options)
+          messages.cache_key(predicate, options)
+        end
       end
     end
   end

data/lib/dry/schema/messages/yaml.rb

@@ -68,6 +68,18 @@ module Dry
         @t = proc { |key, locale: default_locale| get("%<locale>s.#{key}", locale: locale) }
       end
 
+      # Get an array of looked up paths
+      #
+      # @param [Symbol] predicate
+      # @param [Hash] options
+      #
+      # @return [String]
+      #
+      # @api public
+      def looked_up_paths(predicate, options)
+        super.map { |path| path % { locale: options[:locale] || default_locale } }
+      end
+
       # Get a message for the given key and its options
       #
       # @param [Symbol] key

data/lib/dry/schema/namespaced_rule.rb

@@ -29,9 +29,10 @@ module Dry
       end
 
       # @api private
-      def ast(input=Undefined)
+      def ast(input = Undefined)
         [:namespace, [namespace, rule.ast(input)]]
       end
+      alias_method :to_ast, :ast
     end
   end
 end

data/lib/dry/schema/path.rb

@@ -65,8 +65,10 @@ module Dry
       # @api private
       def include?(other)
         return false unless same_root?(other)
-        return false if index? && other.index? && !last.equal?(other.last)
-        self >= other
+        return last.equal?(other.last) if index? && other.index?
+        return self.class.new([*to_a[0..-2]]).include?(other) if index?
+
+        self >= other && !other.key_matches(self).include?(nil)
       end
 
       # @api private
@@ -75,14 +77,16 @@ module Dry
 
         return 0 if keys.eql?(other.keys)
 
-        res =
-          map { |key| (idx = other.index(key)) && keys[idx].equal?(key) }
-            .compact
-            .reject { |value| value.equal?(false) }
+        res = key_matches(other).compact.reject { |value| value.equal?(false) }
 
         res.size < count ? 1 : -1
       end
 
+      # @api private
+      def key_matches(other)
+        map { |key| (idx = other.index(key)) && keys[idx].equal?(key) }
+      end
+
       # @api private
       def last
         keys.last

data/lib/dry/schema/predicate_registry.rb

@@ -1,35 +1,14 @@
 # frozen_string_literal: true
 
 require 'dry/logic/predicates'
+require 'dry/types/predicate_registry'
 
 module Dry
   module Schema
     # A registry with predicate objects from `Dry::Logic::Predicates`
     #
     # @api private
-    class PredicateRegistry
-      # @api private
-      attr_reader :predicates
-
-      # @api private
-      attr_reader :has_predicate
-
-      # @api private
-      def initialize(predicates = Dry::Logic::Predicates)
-        @predicates = predicates
-        @has_predicate = ::Kernel.instance_method(:respond_to?).bind(@predicates)
-      end
-
-      # @api private
-      def [](name)
-        predicates[name]
-      end
-
-      # @api private
-      def key?(name)
-        has_predicate.(name)
-      end
-
+    class PredicateRegistry < Dry::Types::PredicateRegistry
       # @api private
       def arg_list(name, *values)
         predicate = self[name]

data/lib/dry/schema/processor.rb

@@ -5,6 +5,7 @@ require 'dry/initializer'
 
 require 'dry/schema/type_registry'
 require 'dry/schema/type_container'
+require 'dry/schema/processor_steps'
 require 'dry/schema/rule_applier'
 require 'dry/schema/key_coercer'
 require 'dry/schema/value_coercer'
@@ -12,14 +13,9 @@ require 'dry/schema/value_coercer'
 module Dry
   module Schema
     # Processes input data using objects configured within the DSL
+    # Processing is split into steps represented by `ProcessorSteps`.
     #
-    # Processing is split into 4 main steps:
-    #
-    #   1. Prepare input hash using a key map
-    #   2. Apply pre-coercion filtering rules (optional step, used only when `filter` was used)
-    #   3. Apply value coercions based on type specifications
-    #   4. Apply rules
-    #
+    # @see ProcessorSteps
     # @see Params
     # @see JSON
     #
@@ -29,10 +25,10 @@ module Dry
       extend Dry::Configurable
 
       setting :key_map_type
-      setting :type_registry_namespace, :nominal
+      setting :type_registry_namespace, :strict
       setting :filter_empty_string, false
 
-      option :steps, default: -> { EMPTY_ARRAY.dup }
+      option :steps, default: -> { ProcessorSteps.new }
 
       option :schema_dsl
 
@@ -77,16 +73,6 @@ module Dry
         end
       end
 
-      # Append a step
-      #
-      # @return [Processor]
-      #
-      # @api private
-      def <<(step)
-        steps << step
-        self
-      end
-
       # Apply processing steps to the provided input
       #
       # @param [Hash] input
@@ -96,10 +82,7 @@ module Dry
       # @api public
       def call(input)
         Result.new(input, message_compiler: message_compiler) do |result|
-          steps.each do |step|
-            output = step.(result)
-            result.replace(output) if output.is_a?(::Hash)
-          end
+          steps.call(result)
         end
       end
       alias_method :[], :call
@@ -119,7 +102,7 @@ module Dry
       #
       # @api public
       def key_map
-        @key_map ||= steps.detect { |s| s.is_a?(KeyCoercer) }.key_map
+        steps[:key_coercer].key_map
       end
 
       # Return string represntation
@@ -139,7 +122,7 @@ module Dry
       #
       # @api private
       def type_schema
-        @type_schema ||= steps.detect { |s| s.is_a?(ValueCoercer) }.type_schema
+        steps[:value_coercer].type_schema
       end
 
       # Return the rules config
@@ -180,7 +163,7 @@ module Dry
       #
       # @api private
       def rule_applier
-        @rule_applier ||= steps.last
+        steps[:rule_applier]
       end
       alias_method :to_rule, :rule_applier
 

data/lib/dry/schema/processor_steps.rb

@@ -0,0 +1,101 @@
+# 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 }
+
+      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
+
+      # Return 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
+    end
+  end
+end

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.3.0'
+    VERSION = '1.4.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dry-schema
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.4.0
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-06 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