dry-schema 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 149b82a73e8cd4d31c55fe1cf2bee1a7ebfb2afd696677522293da435f0224b1
-  data.tar.gz: ca76ca603a34906e61cfbd075e9667c97ee191591520e89b8a5d2e949c124426
+  metadata.gz: af5d9afb30c697c7ff8e028dff66ed3a1e28a8d0ed9c6f03ac4bd0e0ff73a364
+  data.tar.gz: 94c6bb4243dfc12bd478e715e716deb1fd9b278761d1822324ed7b8920b0de55
 SHA512:
-  metadata.gz: 0b94f326035f884457e2b6ce84ed427d2ec31011529cb8c4a987ff8c26a1bf4b66581ccd1e14ebe91cd4a0efbd05c9c04be6c47cfe959fa0f08687515f02d364
-  data.tar.gz: 356ae43e85fc3afdc0e8abd2628c06315ce5ed97d3ec74c40a3a32dd73b1300851c0f1f8c674abb73d3d8723292dfe0bf370ec5f5fcf1fd7f21fc5a8eb16633c
+  metadata.gz: cf8a06bf211c79bed5ccfc9e02800e47318535036a47b626c29438cae91e3388c380bd9b8b936391718f88c784318f9ef5e88d41a19d06240d9773d2ee7b8270
+  data.tar.gz: 7eaa15a99a94bdcd301fed7d636879a0ef7241d7cf5721bd87ef053c8684ece4b65a0a6aa6fb2f10d7d0947bb66b27548f575749b83190ea2db3bab04f4f08d2

data/CHANGELOG.md

@@ -1,3 +1,34 @@
+# 0.4.0 2019-03-26
+
+### Added
+
+* Schemas are now compatible with procs via `#to_proc` (issue #53) (solnic)
+* Support for configuring `top_namespace` for localized messages (solnic)
+* Support for configuring more than one load path for localized messages (solnic)
+* Support for inferring predicates from arbitrary types (issue #101) (solnic)
+
+### Fixed
+
+* Handling of messages for `optional` keys without value rules works correctly (issue #87) (solnic)
+* Message structure for `optional` keys with an array of hashes no longer duplicates keys (issue #89) (solnic)
+* Inferring `:date_time?` predicate works correctly with `DateTime` types (issue #97) (solnic)
+
+### Changed
+
+* [BREAKING] Updated to work with `dry-types 0.15.0`  (flash-gordon)
+* [BREAKING] `Result#{errors,messages,hints}` returns `MessageSet` object now which is an enumerable coercible to a hash (solnic)
+* [BREAKING] `Messages` backend classes no longer use global configuration (solnic)
+* [BREAKING] Passing a non-symbol key name in the DSL will raise `ArgumentError` (issue #29) (solnic)
+* [BREAKING] Configuration for message backends is now nested under `messages` key with following settings:
+  * `messages.backend` - previously `messages`
+  * `messages.load_paths` - previously `messages_path`
+  * `messages.namespace` - previously `namespace`
+  * `messages.top_namespace` - **new setting** see above
+* [BREAKING] `Messages::I18n` uses `I18.store_translations` instead of messing with `I18n.load_path` (solnic)
+* Schemas (`Params` and `JSON`) have nicer inspect (solnic)
+
+[Compare v0.3.0...v0.4.0](https://github.com/dry-rb/dry-schema/compare/v0.3.0...v0.4.0)
+
 # 0.3.0 2018-03-04
 
 ### Fixed

data/config/errors.yml

@@ -1,7 +1,7 @@
 en:
   dry_schema:
+    or: "or"
     errors:
-      or: "or"
       array?: "must be an array"
 
       empty?: "must be empty"

data/lib/dry/schema.rb

@@ -38,15 +38,6 @@ module Dry
     def self.JSON(**options, &block)
       define(**options, processor_type: JSON, &block)
     end
-
-    # Return configured paths to message files
-    #
-    # @return [Array<String>]
-    #
-    # @api public
-    def self.messages_paths
-      Messages::Abstract.config.paths
-    end
   end
 end
 

data/lib/dry/schema/config.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
 
-require 'delegate'
+require 'dry/equalizer'
 require 'dry/configurable'
 
+require 'dry/schema/constants'
 require 'dry/schema/predicate_registry'
 
 module Dry
@@ -12,42 +13,35 @@ module Dry
     # @see DSL#configure
     #
     # @api public
-    class Config < SimpleDelegator
-      extend Dry::Configurable
+    class Config
+      include Dry::Configurable
+      include Dry::Equalizer(:predicates, :messages)
 
-      setting :predicates, Schema::PredicateRegistry.new
-      setting :messages, :yaml
-      setting :messages_file
-      setting :namespace
-      setting :rules, {}
+      setting(:predicates, Schema::PredicateRegistry.new)
 
-      # Build a new config object with defaults filled in
-      #
-      # @api private
-      def self.new
-        super(struct.new(*settings.map { |key| config.public_send(key) }))
+      setting(:messages) do
+        setting(:backend, :yaml)
+        setting(:namespace)
+        setting(:load_paths, Set[DEFAULT_MESSAGES_PATH], &:dup)
+        setting(:top_namespace, DEFAULT_MESSAGES_ROOT)
       end
 
-      # Build a struct with defined settings
+      # Return configured predicate registry
       #
-      # @return [Struct]
+      # @return [Schema::PredicateRegistry]
       #
-      # @api private
-      def self.struct
-        ::Struct.new(*settings)
+      # @api public
+      def predicates
+        config.predicates
       end
 
-      # Expose configurable object to the provided block
-      #
-      # This method is used by `DSL#configure`
+      # Return configuration for message backend
       #
-      # @return [Config]
+      # @return [Dry::Configurable::Config]
       #
-      # @api private
-      def configure(&block)
-        yield(__getobj__)
-        values.freeze
-        freeze
+      # @api public
+      def messages
+        config.messages
       end
     end
   end

data/lib/dry/schema/constants.rb

@@ -1,15 +1,29 @@
 # frozen_string_literal: true
 
+require 'pathname'
 require 'dry/core/constants'
 
 module Dry
   module Schema
     include Core::Constants
 
-    InvalidSchemaError = Class.new(StandardError)
-    MissingMessageError = Class.new(StandardError)
-
+    LIST_SEPARATOR = ', '
     QUESTION_MARK = '?'
     DOT = '.'
+
+    DEFAULT_MESSAGES_PATH = Pathname(__dir__).join('../../../config/errors.yml').realpath.freeze
+    DEFAULT_MESSAGES_ROOT = 'dry_schema'
+
+    InvalidSchemaError = Class.new(StandardError)
+
+    MissingMessageError = Class.new(StandardError) do
+      # @api private
+      def initialize(path)
+        *rest, rule = path
+        super(<<~STR)
+          Message template for #{rule.inspect} under #{rest.join(DOT).inspect} was not found
+        STR
+      end
+    end
   end
 end

data/lib/dry/schema/dsl.rb

@@ -103,7 +103,7 @@ module Dry
       # @example
       #   Dry::Schema.define do
       #     configure do |config|
-      #       config.messages = :i18n
+      #       config.messages.backend = :i18n
       #     end
       #   end
       #
@@ -162,6 +162,8 @@ module Dry
       #
       # @api public
       def key(name, macro:, &block)
+        raise ArgumentError, "Key +#{name}+ is not a symbol" unless name.is_a?(::Symbol)
+
         set_type(name, Types::Any)
 
         macro = macro.new(
@@ -214,7 +216,11 @@ module Dry
       #
       # @api private
       def type_schema
-        type_registry['hash'].schema(types.merge(parent_types)).safe
+        if parent
+          parent.type_schema.schema(types)
+        else
+          type_registry['hash'].schema(types).safe
+        end
       end
 
       # Return a new DSL instance using the same processor type
@@ -236,18 +242,11 @@ module Dry
       # @api private
       def set_type(name, spec)
         type = resolve_type(spec)
-        meta = { omittable: true, maybe: maybe?(type) }
+        meta = { required: false, maybe: type.optional? }
 
         types[name] = type.meta(meta)
       end
 
-      # Check if the given type is a maybe sum
-      #
-      # @api private
-      def maybe?(type)
-        type.is_a?(Dry::Types::Sum) && type.left.primitive.equal?(NilClass)
-      end
-
       protected
 
       # Build a rule applier
@@ -265,16 +264,14 @@ module Dry
       #
       # @api protected
       def rules
-        parent_rules.merge(macros.map { |m| [m.name, m.to_rule] }.to_h)
+        parent_rules.merge(macros.map { |m| [m.name, m.to_rule] }.to_h.compact)
       end
 
       # Build a key map from defined types
       #
       # @api protected
       def key_map(types = self.types)
-        keys = types.keys.each_with_object([]) { |key_name, arr|
-          arr << key_spec(key_name, types[key_name])
-        }
+        keys = types.map { |key, type| key_spec(key, type) }
         km = KeyMap.new(keys)
 
         if key_map_type
@@ -338,8 +335,8 @@ module Dry
       #
       # @api private
       def key_spec(name, type)
-        if type.respond_to?(:member_types)
-          { name => key_map(type.member_types) }
+        if type.respond_to?(:keys)
+          { name => key_map(type.name_key_map) }
         elsif type.respond_to?(:member)
           kv = key_spec(name, type.member)
           kv.equal?(name) ? name : kv.flatten(1)
@@ -369,12 +366,6 @@ module Dry
         parent&.rules || EMPTY_HASH
       end
 
-      # @api private
-      def parent_types
-        # TODO: this is awful, it'd be nice if we had `Dry::Types::Hash::Schema#merge`
-        parent&.type_schema&.member_types || EMPTY_HASH
-      end
-
       # @api private
       def parent_key_map
         parent&.key_map || EMPTY_ARRAY

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

@@ -11,19 +11,14 @@ module Dry
           def initialize(messages, options = EMPTY_HASH)
             super
             @hints = messages.select(&:hint?)
+            @failures = options.fetch(:failures, true)
           end
 
           # @api public
           def to_h
-            failures? ? messages_map : messages_map(hints)
+            failures ? messages_map : messages_map(hints)
           end
           alias_method :to_hash, :to_h
-          alias_method :dump, :to_h
-
-          # @api private
-          def failures?
-            options[:failures].equal?(true)
-          end
         end
       end
     end

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

@@ -9,7 +9,7 @@ module Dry
           #
           # @api public
           def errors(options = EMPTY_HASH)
-            message_set(options.merge(hints: false)).dump
+            message_set(options.merge(hints: false))
           end
 
           # Get all messages including hints
@@ -20,7 +20,7 @@ module Dry
           #
           # @api public
           def messages(options = EMPTY_HASH)
-            message_set(options).dump
+            message_set(options)
           end
 
           # Get hints exclusively without errors
@@ -31,7 +31,7 @@ module Dry
           #
           # @api public
           def hints(options = EMPTY_HASH)
-            message_set(options.merge(failures: false)).dump
+            message_set(options.merge(failures: false))
           end
         end
       end

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

@@ -11,7 +11,7 @@ module Dry
         if success?
           Success(output)
         else
-          Failure(message_set(options).dump)
+          Failure(message_set(options).to_h)
         end
       end
     end

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

@@ -13,7 +13,6 @@ module Dry
         def call(*args, &block)
           trace << hash?
           super(*args, &block)
-          self
         end
       end
     end

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

@@ -14,8 +14,18 @@ module Dry
       #
       # @api public
       class Key < DSL
+        # @!attribute [r] filter_schema
+        #   @return [Schema::DSL]
+        #   @api private
         option :filter_schema, optional: true, default: proc { schema_dsl&.new }
 
+        # @!attribute [r] predicate_inferrer
+        #   @return [PredicateInferrer]
+        #   @api private
+        option :predicate_inferrer, default: proc {
+          PredicateInferrer.new(compiler.predicates)
+        }
+
         # Specify predicates that should be used to filter out values
         # before coercion is applied
         #
@@ -116,16 +126,11 @@ module Dry
 
           if type_spec
             type(nullable && !type_spec.is_a?(::Array) ? [:nil, type_spec] : type_spec)
-            type_predicates = PredicateInferrer[schema_dsl.types[name]]
 
-            unless predicates.include?(type_predicates)
-              type_predicates.each do |pred|
-                unless compiler.supports?(pred)
-                  raise ArgumentError, "Predicate +#{pred.inspect}+ inferred from #{type_spec.inspect} type spec is not supported"
-                end
-              end
+            type_predicates = predicate_inferrer[schema_dsl.types[name]]
 
-              if type_predicates.size.equal?(1)
+            unless predicates.include?(type_predicates)
+              if type_predicates.is_a?(::Array) && type_predicates.size.equal?(1)
                 predicates.unshift(type_predicates[0])
               else
                 predicates.unshift(type_predicates)

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

@@ -13,6 +13,11 @@ module Dry
         def operation
           :then
         end
+
+        # @api private
+        def to_rule
+          super unless trace.captures.empty?
+        end
       end
     end
   end

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

@@ -27,7 +27,7 @@ module Dry
               end
 
             final_type =
-              if schema_dsl.maybe?(parent_type)
+              if parent_type.optional?
                 schema_type.optional
               else
                 schema_type

data/lib/dry/schema/message.rb

@@ -11,7 +11,7 @@ module Dry
     class Message
       include Dry::Equalizer(:predicate, :path, :text, :options)
 
-      attr_reader :predicate, :path, :text, :rule, :args, :options
+      attr_reader :predicate, :path, :text, :args, :options
 
       # A message sub-type used by OR operations
       #
@@ -43,7 +43,7 @@ module Dry
         #
         # @api public
         def to_s
-          uniq.join(" #{messages[:or].()} ")
+          uniq.join(" #{messages[:or]} ")
         end
 
         # @api private
@@ -67,15 +67,10 @@ module Dry
       # @api private
       def initialize(predicate, path, text, options)
         @predicate = predicate
-        @path = path.dup
+        @path = path
         @text = text
         @options = options
-        @rule = options[:rule]
         @args = options[:args] || EMPTY_ARRAY
-
-        if predicate == :key?
-          @path << rule
-        end
       end
 
       # Return a string representation of the message

data/lib/dry/schema/message_compiler.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'dry/initializer'
+
 require 'dry/schema/constants'
 require 'dry/schema/message'
 require 'dry/schema/message_set'
@@ -11,28 +13,43 @@ module Dry
     #
     # @api private
     class MessageCompiler
-      attr_reader :messages, :options, :locale, :default_lookup_options
+      extend Dry::Initializer
+
+      resolve_key_predicate = proc { |node, opts|
+        *arg_vals, val = node.map(&:last)
+        [[*opts.path, arg_vals[0]], arg_vals[1..arg_vals.size - 1], val]
+      }
+
+      resolve_predicate = proc { |node, opts|
+        [Array(opts.path), *node.map(&:last)]
+      }
+
+      DEFAULT_PREDICATE_RESOLVERS = Hash
+        .new(resolve_predicate).update(key?: resolve_key_predicate).freeze
 
       EMPTY_OPTS = VisitorOpts.new
-      LIST_SEPARATOR = ', '
 
-      # @api private
-      def initialize(messages, options = {})
-        @messages = messages
-        @options = options
-        @full = @options.fetch(:full, false)
-        @locale = @options[:locale]
-        @default_lookup_options = @locale ? { locale: locale } : EMPTY_HASH
-      end
+      param :messages
+
+      option :full, default: -> { false }
+      option :locale, default: -> { :en }
+      option :predicate_resolvers, default: -> { DEFAULT_PREDICATE_RESOLVERS }
+
+      attr_reader :options
+
+      attr_reader :default_lookup_options
 
       # @api private
-      def full?
-        @full
+      def initialize(messages, options = EMPTY_HASH)
+        super
+        @options = options
+        @default_lookup_options = options[:locale] ? { locale: locale } : EMPTY_HASH
       end
 
       # @api private
       def with(new_options)
         return self if new_options.empty?
+
         self.class.new(messages, options.merge(new_options))
       end
 
@@ -56,7 +73,7 @@ module Dry
       end
 
       # @api private
-      def visit_hint(node, opts)
+      def visit_hint(*)
         nil
       end
 
@@ -81,7 +98,7 @@ module Dry
         left, right = node.map { |n| visit(n, opts) }
 
         if [left, right].flatten.map(&:path).uniq.size == 1
-          Message::Or.new(left, right, -> k { messages[k, default_lookup_options] })
+          Message::Or.new(left, right, proc { |k| messages.translate(k, default_lookup_options) })
         elsif right.is_a?(Array)
           right
         else
@@ -97,33 +114,23 @@ module Dry
 
       # @api private
       def visit_predicate(node, opts)
-        base_opts = opts.dup
         predicate, args = node
 
-        *arg_vals, val = args.map(&:last)
         tokens = message_tokens(args)
+        path, *arg_vals, input = predicate_resolvers[predicate].(args, opts)
 
-        input = val != Undefined ? val : nil
-
-        options = base_opts.update(lookup_options(arg_vals: arg_vals, input: input))
-        msg_opts = options.update(tokens)
-
-        rule = msg_opts[:rule]
-        path = msg_opts[:path]
-
-        template = messages[rule] || messages[predicate, msg_opts]
+        options = opts.dup.update(
+          path: path.last, **tokens, **lookup_options(arg_vals: arg_vals, input: input)
+        ).to_h
 
-        unless template
-          raise MissingMessageError, "message for #{predicate} was not found"
-        end
+        template = messages[predicate, options] || raise(MissingMessageError, path)
 
-        text = message_text(rule, template, tokens, options)
+        text = message_text(template, tokens, options)
 
         message_type(options)[
           predicate, path, text,
           args: arg_vals,
-          input: input,
-          rule: rule || msg_opts[:name]
+          input: input
         ]
       end
 
@@ -156,28 +163,26 @@ module Dry
       end
 
       # @api private
-      def lookup_options(arg_vals: [], input: nil)
+      def lookup_options(arg_vals:, input:)
         default_lookup_options.merge(
           arg_type: arg_vals.size == 1 && arg_vals[0].class,
-          val_type: input.class
+          val_type: input.equal?(Undefined) ? NilClass : input.class
         )
       end
 
       # @api private
-      def message_text(rule, template, tokens, opts)
+      def message_text(template, tokens, options)
         text = template[template.data(tokens)]
 
-        if full?
-          rule_name = rule ? (messages.rule(rule, opts) || rule) : (opts[:name] || opts[:path].last)
-          "#{rule_name} #{text}"
-        else
-          text
-        end
+        return text unless full
+
+        rule = options[:path]
+        "#{messages.rule(rule, options) || rule} #{text}"
       end
 
       # @api private
       def message_tokens(args)
-        args.each_with_object({}) { |arg, hash|
+        args.each_with_object({}) do |arg, hash|
           case arg[1]
           when Array
             hash[arg[0]] = arg[1].join(LIST_SEPARATOR)
@@ -187,7 +192,7 @@ module Dry
           else
             hash[arg[0]] = arg[1]
           end
-        }
+        end
       end
     end
   end