dry-schema 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ebc7203aa64419493d5557a5228e8ae17da67a89b7dab86556897aad7856138e
-  data.tar.gz: '083cad2ab1b35ecfac75a5d37a868f36145cce8ea31bf03dc10b3ad84233b498'
+  metadata.gz: bfbb04d5a9d9537294ec0e1d6fce172c2a6feb8a26ec13157ccc3f15120eee6f
+  data.tar.gz: 1c85541e6b71d1d44fc6abeb99350ef51abf7f8e2279556055f8f66cbb9e2373
 SHA512:
-  metadata.gz: 0db3366b58c3fd06ad10958de4215ae5b2ff67f244873ff8b48b96da9bfcf08678a06ef3302099862891630b825596c6a4adfecac9140e8e5045ca7acc200b34
-  data.tar.gz: 04e3fa2ee8d50aaac7c6bcdaacb1611252ce06af397499cf0fbc0ed21fb33e62c55b9ab0179b4df9160bbd0efe1c6bed1c60ac628c06f23f992879df8c6326ed
+  metadata.gz: c8b8b1023ed9256358d8ed96998be33070fe82c983e7d511e38f01d18da1fc1702ac2ea82f3fa02a83d9494d3822a3ce304662cc806ec6f4a16198d1db040444
+  data.tar.gz: fe668ebfb35ecee7ddc41c34d77fbde0abb9d3c8e98c192657036e8503bbde708c72b783a9f5ae1e6b9a366bee26b2217c78b4652e17d88219b3c4edaa74d6b9

data/CHANGELOG.md

@@ -1,3 +1,32 @@
+# 0.2.0 2019-02-26
+
+### Added
+
+* New `hash` macro which prepends `hash?` type-check and allows nested schema definition (solnic)
+* New `array` macro which works like `each` but prepends `array?` type-check (solnic)
+
+### Fixed
+
+* Rule name translation works correctly with I18n (issue #52) (solnic)
+* Rule name translation works correctly with namespaced messages (both I18n and plain YAML) (issue #57) (solnic)
+* Error messages under namespaces are correctly resolved for overridden names (issue #53) (solnic)
+* Namespaced error messages work correctly when schemas are reused within other schemas (issue #49) (solnic)
+* Child schema can override inherited rules now (issue #66) (skryukov)
+* Hints are correctly generated for disjunction that use type-check predicates (issue #24) (solnic)
+* Hints are correctly generated for nested schemas (issue #26) (solnic)
+* `filled` macro respects inferred type-check predicates and puts them in front (solnic)
+* Value coercion works correctly with re-usable nested schemas (issue #25) (solnic)
+
+### Changed
+
+* [BREAKING] **Messages are now configured under `dry_schema` namespace by default** (issue #38) (solnic)
+* [BREAKING] Hints are now an optional feature provided by `:hints` extension, to load it do `Dry::Schema.load_extensions(:hints)` (solnic)
+* [BREAKING] Hints generation was improved in general, output of `Result#messages` and `Result#hints` changed in some cases (solnic)
+* [BREAKING] `schema` macro no longer prepends `hash?` check, for this behavior use the new `hash` macro (see #31) (solnic)
+* [BREAKING] Support for MRI < 2.4 was dropped (solnic)
+
+[Compare v0.1.1...v0.2.0](https://github.com/dry-rb/dry-schema/compare/v0.1.1...v0.2.0)
+
 # 0.1.1 2019-02-17
 
 ### Added

data/config/errors.yml

@@ -1,91 +1,92 @@
 en:
-  errors:
-    or: "or"
-    array?: "must be an array"
+  dry_schema:
+    errors:
+      or: "or"
+      array?: "must be an array"
 
-    empty?: "must be empty"
+      empty?: "must be empty"
 
-    excludes?: "must not include %{value}"
+      excludes?: "must not include %{value}"
 
-    excluded_from?:
-      arg:
-        default: "must not be one of: %{list}"
-        range: "must not be one of: %{list_left} - %{list_right}"
-    exclusion?: "must not be one of: %{list}"
+      excluded_from?:
+        arg:
+          default: "must not be one of: %{list}"
+          range: "must not be one of: %{list_left} - %{list_right}"
+      exclusion?: "must not be one of: %{list}"
 
-    eql?: "must be equal to %{left}"
+      eql?: "must be equal to %{left}"
 
-    not_eql?: "must not be equal to %{left}"
+      not_eql?: "must not be equal to %{left}"
 
-    filled?: "must be filled"
+      filled?: "must be filled"
 
-    format?: "is in invalid format"
+      format?: "is in invalid format"
 
-    number?: "must be a number"
+      number?: "must be a number"
 
-    odd?: "must be odd"
+      odd?: "must be odd"
 
-    even?: "must be even"
+      even?: "must be even"
 
-    gt?: "must be greater than %{num}"
+      gt?: "must be greater than %{num}"
 
-    gteq?: "must be greater than or equal to %{num}"
+      gteq?: "must be greater than or equal to %{num}"
 
-    hash?: "must be a hash"
+      hash?: "must be a hash"
 
-    included_in?:
-      arg:
-        default: "must be one of: %{list}"
-        range: "must be one of: %{list_left} - %{list_right}"
-    inclusion?: "must be one of: %{list}"
+      included_in?:
+        arg:
+          default: "must be one of: %{list}"
+          range: "must be one of: %{list_left} - %{list_right}"
+      inclusion?: "must be one of: %{list}"
 
-    includes?: "must include %{value}"
+      includes?: "must include %{value}"
 
-    bool?: "must be boolean"
+      bool?: "must be boolean"
 
-    true?: "must be true"
+      true?: "must be true"
 
-    false?: "must be false"
+      false?: "must be false"
 
-    int?: "must be an integer"
+      int?: "must be an integer"
 
-    float?: "must be a float"
+      float?: "must be a float"
 
-    decimal?: "must be a decimal"
+      decimal?: "must be a decimal"
 
-    date?: "must be a date"
+      date?: "must be a date"
 
-    date_time?: "must be a date time"
+      date_time?: "must be a date time"
 
-    time?: "must be a time"
+      time?: "must be a time"
 
-    key?: "is missing"
+      key?: "is missing"
 
-    attr?: "is missing"
+      attr?: "is missing"
 
-    lt?: "must be less than %{num}"
+      lt?: "must be less than %{num}"
 
-    lteq?: "must be less than or equal to %{num}"
+      lteq?: "must be less than or equal to %{num}"
 
-    max_size?: "size cannot be greater than %{num}"
+      max_size?: "size cannot be greater than %{num}"
 
-    min_size?: "size cannot be less than %{num}"
+      min_size?: "size cannot be less than %{num}"
 
-    nil?: "cannot be defined"
+      nil?: "cannot be defined"
 
-    str?: "must be a string"
+      str?: "must be a string"
 
-    type?: "must be %{type}"
+      type?: "must be %{type}"
 
-    size?:
-      arg:
-        default: "size must be %{size}"
-        range: "size must be within %{size_left} - %{size_right}"
+      size?:
+        arg:
+          default: "size must be %{size}"
+          range: "size must be within %{size_left} - %{size_right}"
 
-      value:
-        string:
-          arg:
-            default: "length must be %{size}"
-            range: "length must be within %{size_left} - %{size_right}"
-    not:
-      empty?: "cannot be empty"
+        value:
+          string:
+            arg:
+              default: "length must be %{size}"
+              range: "length must be within %{size_left} - %{size_right}"
+      not:
+        empty?: "cannot be empty"

data/lib/dry/schema/compiler.rb

@@ -1,4 +1,5 @@
 require 'dry/logic/rule_compiler'
+require 'dry/schema/namespaced_rule'
 require 'dry/schema/predicate_registry'
 
 module Dry
@@ -16,6 +17,22 @@ module Dry
         super
       end
 
+      # Build a special rule that will produce namespaced failures
+      #
+      # This is needed for schemas that are namespaced and they are
+      # used as nested schemas
+      #
+      # @param [Array] node
+      # @param [Hash] opts
+      #
+      # @return [NamespacedRule]
+      #
+      # @api private
+      def visit_namespace(node, opts = EMPTY_HASH)
+        namespace, rest = node
+        NamespacedRule.new(namespace, visit(rest))
+      end
+
       # Return true if a given predicate is supported by this compiler
       #
       # @param [Symbol] predicate

data/lib/dry/schema/dsl.rb

@@ -263,7 +263,7 @@ module Dry
       #
       # @api protected
       def rules
-        macros.map { |m| [m.name, m.to_rule] }.to_h.merge(parent_rules)
+        parent_rules.merge(macros.map { |m| [m.name, m.to_rule] }.to_h)
       end
 
       # Build a key map from defined types

data/lib/dry/schema/extensions.rb

@@ -1,3 +1,7 @@
 Dry::Schema.register_extension(:monads) do
   require 'dry/schema/extensions/monads'
 end
+
+Dry::Schema.register_extension(:hints) do
+  require 'dry/schema/extensions/hints'
+end

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

@@ -0,0 +1,52 @@
+require 'dry/schema/message'
+require 'dry/schema/message_compiler'
+
+require 'dry/schema/extensions/hints/message_compiler_methods'
+require 'dry/schema/extensions/hints/message_set_methods'
+require 'dry/schema/extensions/hints/result_methods'
+
+module Dry
+  module Schema
+    # Hint-specific Message extensions
+    #
+    # @see Message
+    #
+    # @api public
+    class Message
+      # @see Message::Or
+      #
+      # @api public
+      class Or
+        # @api private
+        def hint?
+          false
+        end
+      end
+
+      # @api private
+      def hint?
+        false
+      end
+    end
+
+    # A hint message sub-type
+    #
+    # @api private
+    class Hint < Message
+      def self.[](predicate, path, text, options)
+        Hint.new(predicate, path, text, options)
+      end
+
+      # @api private
+      def hint?
+        true
+      end
+    end
+
+    module Extensions
+      MessageCompiler.prepend(Hints::MessageCompilerMethods)
+      MessageSet.prepend(Hints::MessageSetMethods)
+      Result.prepend(Hints::ResultMethods)
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+module Dry
+  module Schema
+    module Extensions
+      module Hints
+        module MessageCompilerMethods
+          HINT_TYPE_EXCLUSION = %i[
+            key? nil? bool? str? int? float? decimal?
+            date? date_time? time? hash? array?
+          ].freeze
+
+          HINT_OTHER_EXCLUSION = %i[format? filled?].freeze
+
+          attr_reader :hints
+
+          def initialize(*args)
+            super
+            @hints = @options.fetch(:hints, true)
+          end
+
+          # @api private
+          def hints?
+            hints.equal?(true)
+          end
+
+          # @api private
+          def filter(messages, opts)
+            Array(messages).flatten.map { |msg| msg unless exclude?(msg, opts) }.compact.uniq
+          end
+
+          # @api private
+          def exclude?(messages, opts)
+            Array(messages).all? do |msg|
+              hints = opts.hints.reject { |hint| msg == hint }.reject { |hint| hint.predicate == :filled? }
+              key_failure = opts.key_failure?(msg.path)
+              predicate = msg.predicate
+
+              (HINT_TYPE_EXCLUSION.include?(predicate) && !key_failure) ||
+                (msg.predicate == :filled? && key_failure) ||
+                  (!key_failure && HINT_TYPE_EXCLUSION.include?(predicate) && !hints.empty? && hints.any? { |hint| hint.path == msg.path }) ||
+                    HINT_OTHER_EXCLUSION.include?(predicate)
+            end
+          end
+
+          # @api private
+          def message_type(options)
+            options[:message_type].equal?(:hint) ? Hint : Message
+          end
+
+          # @api private
+          def visit_hint(node, opts)
+            if hints?
+              filter(visit(node, opts.(message_type: :hint)), opts)
+            end
+          end
+
+          # @api private
+          def visit_predicate(node, opts)
+            message = super
+            opts.current_messages << message
+            message
+          end
+
+          # @api private
+          def visit_each(node, opts)
+            # TODO: we can still generate a hint for elements here!
+            []
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Dry
+  module Schema
+    module Extensions
+      module Hints
+        module MessageSetMethods
+          attr_reader :hints, :failures
+
+          # @api private
+          def initialize(messages, options = EMPTY_HASH)
+            super
+            @hints = messages.select(&:hint?)
+          end
+
+          # @api public
+          def to_h
+            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
+  end
+end

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

@@ -0,0 +1,38 @@
+module Dry
+  module Schema
+    module Extensions
+      module Hints
+        module ResultMethods
+          # @see Result#errors
+          #
+          # @api public
+          def errors(options = EMPTY_HASH)
+            message_set(options.merge(hints: false)).dump
+          end
+
+          # Get all messages including hints
+          #
+          # @see #message_set
+          #
+          # @return [Hash<Symbol=>Array>]
+          #
+          # @api public
+          def messages(options = EMPTY_HASH)
+            message_set(options).dump
+          end
+
+          # Get hints exclusively without errors
+          #
+          # @see #message_set
+          #
+          # @return [Hash<Symbol=>Array>]
+          #
+          # @api public
+          def hints(options = EMPTY_HASH)
+            message_set(options.merge(failures: false)).dump
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/schema/macros.rb

@@ -1,5 +1,6 @@
 require 'dry/schema/macros/each'
 require 'dry/schema/macros/filled'
+require 'dry/schema/macros/schema'
 require 'dry/schema/macros/hash'
 require 'dry/schema/macros/maybe'
 require 'dry/schema/macros/optional'