dry-schema 1.3.4 → 1.5.0

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

@@ -1,67 +1,42 @@
 # frozen_string_literal: true
 
-require 'dry/equalizer'
+require "dry/initializer"
+require "dry/equalizer"
 
-require 'dry/schema/constants'
+require "dry/schema/constants"
 
 module Dry
   module Schema
     module Messages
-      # Template wraps a string with interpolation tokens and defines evaluator function
-      # dynamically
-      #
       # @api private
       class Template
-        include Dry::Equalizer(:text)
+        extend Dry::Initializer
+        include Dry::Equalizer(:messages, :key, :options)
 
-        TOKEN_REGEXP = /%{(\w*)}/
-
-        # !@attribute [r] text
-        # @return [String]
-        attr_reader :text
-
-        # !@attribute [r] tokens
-        # @return [Hash]
-        attr_reader :tokens
-
-        # !@attribute [r] evaluator
-        # @return [Proc]
-        attr_reader :evaluator
+        option :messages
+        option :key
+        option :options
 
         # @api private
-        def self.[](input)
-          new(*parse(input))
+        def data(data = EMPTY_HASH)
+          ensure_message!
+          messages.interpolatable_data(key, options, **options, **data)
         end
 
         # @api private
-        def self.parse(input)
-          tokens = input.scan(TOKEN_REGEXP).flatten(1).map(&:to_sym)
-          text = input.gsub('%', '#')
-
-          evaluator = <<-RUBY.strip
-            -> (#{tokens.map { |token| "#{token}:" }.join(", ")}) { "#{text}" }
-          RUBY
-
-          [text, tokens, eval(evaluator, binding, __FILE__, __LINE__ - 3)]
+        def call(data = EMPTY_HASH)
+          ensure_message!
+          messages.interpolate(key, options, **data)
         end
+        alias_method :[], :call
 
-        # @api private
-        def initialize(text, tokens, evaluator)
-          @text = text
-          @tokens = tokens
-          @evaluator = evaluator
-        end
+        private
 
-        # @api private
-        def data(input)
-          tokens.each_with_object({}) { |k, h| h[k] = input[k] }
-        end
+        def ensure_message!
+          return if messages.key?(key, options)
 
-        # @api private
-        def call(data = EMPTY_HASH)
-          data.empty? ? evaluator.() : evaluator.(data)
+          raise KeyError, "No message found for template, template=#{inspect}"
         end
-        alias_method :[], :call
       end
     end
   end

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

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require 'yaml'
-require 'pathname'
+require "yaml"
+require "pathname"
 
-require 'dry/equalizer'
-require 'dry/schema/constants'
-require 'dry/schema/messages/abstract'
+require "dry/equalizer"
+require "dry/schema/constants"
+require "dry/schema/messages/abstract"
 
 module Dry
   module Schema
@@ -13,7 +13,13 @@ module Dry
     #
     # @api public
     class Messages::YAML < Messages::Abstract
-      LOCALE_TOKEN = '%<locale>s'
+      LOCALE_TOKEN = "%<locale>s"
+      TOKEN_REGEXP = /%{(\w*)}/.freeze
+      EMPTY_CONTEXT = Object.new.tap { |ctx|
+        def ctx.context
+          binding
+        end
+      }.freeze.context
 
       include Dry::Equalizer(:data)
 
@@ -22,7 +28,7 @@ module Dry
       # @return [Hash]
       attr_reader :data
 
-      # Translation function     
+      # Translation function
       #
       # @return [Proc]
       attr_reader :t
@@ -45,21 +51,26 @@ module Dry
         hash.each do |key, value|
           flat_hash(value, [*path, key], keys) if value.is_a?(Hash)
 
-          if value.is_a?(String) && hash['text'] != value
+          if value.is_a?(String) && hash["text"] != value
             keys[[*path, key].join(DOT)] = {
               text: value,
               meta: EMPTY_HASH
             }
-          elsif value.is_a?(Hash) && value['text'].is_a?(String)
+          elsif value.is_a?(Hash) && value["text"].is_a?(String)
             keys[[*path, key].join(DOT)] = {
-              text: value['text'],
-              meta: value.dup.delete_if { |k| k == 'text' }.map { |k, v| [k.to_sym, v] }.to_h
+              text: value["text"],
+              meta: value.dup.delete_if { |k| k == "text" }.map { |k, v| [k.to_sym, v] }.to_h
             }
           end
         end
         keys
       end
 
+      # @api private
+      def self.cache
+        @cache ||= Concurrent::Map.new { |h, k| h[k] = Concurrent::Map.new }
+      end
+
       # @api private
       def initialize(data: EMPTY_HASH, config: nil)
         super()
@@ -68,6 +79,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
@@ -112,12 +135,48 @@ module Dry
 
       # @api private
       def prepare
-        @data = config.load_paths.map { |path| load_translations(path) }.reduce(:merge)
+        @data = config.load_paths.map { |path| load_translations(path) }.reduce({}, :merge)
         self
       end
 
+      # @api private
+      def interpolatable_data(key, options, **data)
+        tokens = evaluation_context(key, options).fetch(:tokens)
+        data.select { |k,| tokens.include?(k) }
+      end
+
+      # @api private
+      def interpolate(key, options, **data)
+        evaluator = evaluation_context(key, options).fetch(:evaluator)
+        data.empty? ? evaluator.() : evaluator.(**data)
+      end
+
       private
 
+      # @api private
+      def evaluation_context(key, options)
+        cache.fetch_or_store(get(key, options).fetch(:text)) do |input|
+          tokens = input.scan(TOKEN_REGEXP).flatten(1).map(&:to_sym).to_set
+          text = input.gsub("%", "#")
+
+          # rubocop:disable Security/Eval
+          evaluator = eval(<<~RUBY, EMPTY_CONTEXT, __FILE__, __LINE__ + 1)
+            -> (#{tokens.map { |token| "#{token}:" }.join(", ")}) { "#{text}" }
+          RUBY
+          # rubocop:enable Security/Eval
+
+          {
+            tokens: tokens,
+            evaluator: evaluator
+          }
+        end
+      end
+
+      # @api private
+      def cache
+        @cache ||= self.class.cache[self]
+      end
+
       # @api private
       def load_translations(path)
         data = self.class.flat_hash(YAML.load_file(path))
@@ -131,7 +190,7 @@ module Dry
       def evaluated_key(key, options)
         return key unless key.include?(LOCALE_TOKEN)
 
-        key % { locale: options[:locale] || default_locale }
+        key % {locale: options[:locale] || default_locale}
       end
     end
   end

data/lib/dry/schema/params.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/path.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'dry/schema/constants'
+require "dry/schema/constants"
 
 module Dry
   module Schema
@@ -8,6 +8,7 @@ module Dry
     #
     # @api private
     class Path
+      include Dry.Equalizer(:keys)
       include Comparable
       include Enumerable
 
@@ -23,7 +24,7 @@ module Dry
       # @return [Path]
       #
       # @api private
-      def self.[](spec)
+      def self.call(spec)
         case spec
         when Symbol, Array
           new(Array[*spec])
@@ -34,10 +35,15 @@ module Dry
         when Path
           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 Path"
         end
       end
 
+      # @api private
+      def self.[](spec)
+        call(spec)
+      end
+
       # Extract a list of keys from a hash
       #
       # @api private
@@ -52,6 +58,28 @@ module Dry
         @keys = keys
       end
 
+      # @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
+
+        hash
+      end
+
       # @api private
       def each(&block)
         keys.each(&block)
@@ -83,8 +111,19 @@ module Dry
       end
 
       # @api private
-      def key_matches(other)
-        map { |key| (idx = other.index(key)) && keys[idx].equal?(key) }
+      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) }
+        )
+      end
+
+      # @api private
+      def key_matches(other, meth = :map)
+        public_send(meth) { |key| (idx = other.index(key)) && keys[idx].equal?(key) }
       end
 
       # @api private

data/lib/dry/schema/predicate.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'dry/equalizer'
-require 'dry/logic/operators'
+require "dry/equalizer"
+require "dry/logic/operators"
 
 module Dry
   module Schema

data/lib/dry/schema/predicate_inferrer.rb

@@ -1,196 +1,16 @@
 # frozen_string_literal: true
 
-require 'dry/core/cache'
+require "dry/types/predicate_inferrer"
 
 module Dry
   module Schema
-    # PredicateInferrer is used internally by `Macros::Value`
-    # for inferring type-check predicates from type specs.
-    #
     # @api private
-    class PredicateInferrer
-      extend Dry::Core::Cache
+    class PredicateInferrer < ::Dry::Types::PredicateInferrer
+      Compiler = ::Class.new(superclass::Compiler)
 
-      TYPE_TO_PREDICATE = {
-        DateTime => :date_time?,
-        FalseClass => :false?,
-        Integer => :int?,
-        NilClass => :nil?,
-        String => :str?,
-        TrueClass => :true?,
-        BigDecimal => :decimal?
-      }.freeze
-
-      REDUCED_TYPES = {
-        [[[:true?], [:false?]]] => %i[bool?]
-      }.freeze
-
-      HASH = %i[hash?].freeze
-
-      ARRAY = %i[array?].freeze
-
-      NIL = %i[nil?].freeze
-
-      # Compiler reduces type AST into a list of predicates
-      #
-      # @api private
-      class Compiler
-        # @return [PredicateRegistry]
-        # @api private
-        attr_reader :registry
-
-        # @api private
-        def initialize(registry)
-          @registry = registry
-        end
-
-        # @api private
-        def infer_predicate(type)
-          [TYPE_TO_PREDICATE.fetch(type) { :"#{type.name.split('::').last.downcase}?" }]
-        end
-
-        # @api private
-        def visit(node)
-          meth, rest = node
-          public_send(:"visit_#{meth}", rest)
-        end
-
-        # @api private
-        def visit_nominal(node)
-          type = node[0]
-          predicate = infer_predicate(type)
-
-          if registry.key?(predicate[0])
-            predicate
-          else
-            [type?: type]
-          end
-        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_node, right_node, = node
-          left = visit(left_node)
-          right = visit(right_node)
-
-          if left.eql?(NIL)
-            right
-          else
-            [[left, right]]
-          end
-        end
-
-        # @api private
-        def visit_constrained(node)
-          other, rules = node
-          predicates = visit(rules)
-
-          if predicates.empty?
-            visit(other)
-          else
-            [*visit(other), *merge_predicates(predicates)]
-          end
-        end
-
-        # @api private
-        def visit_any(_)
-          EMPTY_ARRAY
-        end
-
-        # @api private
-        def visit_and(node)
-          left, right = node
-          visit(left) + visit(right)
-        end
-
-        # @api private
-        def visit_predicate(node)
-          pred, args = node
-
-          if pred.equal?(:type?)
-            EMPTY_ARRAY
-          elsif registry.key?(pred)
-            *curried, _ = args
-            values = curried.map { |_, v| v }
-
-            if values.empty?
-              [pred]
-            else
-              [pred => values[0]]
-            end
-          else
-            EMPTY_ARRAY
-          end
-        end
-
-        private
-
-        # @api private
-        def merge_predicates(nodes)
-          preds, merged = nodes.each_with_object([[], {}]) do |predicate, (ps, h)|
-            if predicate.is_a?(::Hash)
-              h.update(predicate)
-            else
-              ps << predicate
-            end
-          end
-
-          merged.empty? ? preds : [*preds, merged]
-        end
-      end
-
-      # @return [Compiler]
-      # @api private
-      attr_reader :compiler
-
-      # @api private
-      def initialize(registry)
+      def initialize(registry = PredicateRegistry.new)
         @compiler = Compiler.new(registry)
       end
-
-      # Infer predicate identifier from the provided type
-      #
-      # @return [Symbol]
-      #
-      # @api private
-      def [](type)
-        self.class.fetch_or_store(type.hash) do
-          predicates = compiler.visit(type.to_ast)
-
-          if predicates.is_a?(Hash)
-            predicates
-          else
-            REDUCED_TYPES[predicates] || predicates
-          end
-        end
-      end
     end
   end
 end