dry-schema 0.1.0 → 1.0.0

data/lib/dry/schema/dsl.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'dry/initializer'
 
 require 'dry/schema/constants'
@@ -50,29 +52,23 @@ module Dry
 
       include ::Dry::Equalizer(:options)
 
-      # @!attribute [r] compiler
-      #   @return [Compiler] The rule compiler object
+      # @return [Compiler] The rule compiler object
       option :compiler, default: -> { Compiler.new }
 
-      # @!attribute [r] processor_type
-      #   @return [Compiler] The type of the processor (Params, JSON, or a custom sub-class)
+      # @return [Compiler] The type of the processor (Params, JSON, or a custom sub-class)
       option :processor_type, default: -> { Processor }
 
-      # @!attribute [r] macros
-      #   @return [Array] An array with macros defined within the DSL
+      # @return [Array] An array with macros defined within the DSL
       option :macros, default: -> { EMPTY_ARRAY.dup }
 
-      # @!attribute [r] types
-      #   @return [Compiler] A key=>type map defined within the DSL
+      # @return [Compiler] A key=>type map defined within the DSL
       option :types, default: -> { EMPTY_HASH.dup }
 
-      # @!attribute [r] parent
-      #   @return [DSL] An optional parent DSL object that will be used to merge keys and rules
+      # @return [DSL] An optional parent DSL object that will be used to merge keys and rules
       option :parent, optional: true
 
-      # @!attribute [r] config
-      #   @return [Config] Configuration object exposed via `#configure` method
-      option :config, optional: true, default: -> { Config.new }
+      # @return [Config] Configuration object exposed via `#configure` method
+      option :config, optional: true, default: proc { parent ? parent.config.dup : Config.new }
 
       # Build a new DSL object and evaluate provided block
       #
@@ -90,7 +86,7 @@ module Dry
       # @return [DSL]
       #
       # @api public
-      def self.new(options = EMPTY_HASH, &block)
+      def self.new(**options, &block)
         dsl = super
         dsl.instance_eval(&block) if block
         dsl
@@ -101,7 +97,7 @@ module Dry
       # @example
       #   Dry::Schema.define do
       #     configure do |config|
-      #       config.messages = :i18n
+      #       config.messages.backend = :i18n
       #     end
       #   end
       #
@@ -160,6 +156,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(
@@ -203,7 +201,7 @@ module Dry
       #
       # @api public
       def array
-        -> member_type { type_registry["array"].of(resolve_type(member_type)) }
+        -> member_type { type_registry['array'].of(resolve_type(member_type)) }
       end
 
       # Return type schema used by the value coercer
@@ -212,7 +210,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).lax
+        end
       end
 
       # Return a new DSL instance using the same processor type
@@ -234,16 +236,25 @@ 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
+      # Resolve type object from the provided spec
+      #
+      # @param [Symbol, Array<Symbol>, Dry::Types::Type] spec
+      #
+      # @return [Dry::Types::Type]
       #
       # @api private
-      def maybe?(type)
-        type.is_a?(Dry::Types::Sum) && type.left.primitive.equal?(NilClass)
+      def resolve_type(spec)
+        case spec
+        when ::Dry::Types::Type then spec
+        when ::Array then spec.map { |s| resolve_type(s) }.reduce(:|)
+        else
+          type_registry[spec]
+        end
       end
 
       protected
@@ -263,16 +274,14 @@ 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.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
@@ -336,8 +345,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)
@@ -346,33 +355,11 @@ module Dry
         end
       end
 
-      # Resolve type object from the provided spec
-      #
-      # @param [Symbol, Array<Symbol>, Dry::Types::Type]
-      #
-      # @return [Dry::Types::Type]
-      #
-      # @api private
-      def resolve_type(spec)
-        case spec
-        when ::Dry::Types::Type then spec
-        when ::Array then spec.map { |s| resolve_type(s) }.reduce(:|)
-        else
-          type_registry[spec]
-        end
-      end
-
       # @api private
       def parent_rules
         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/compiler_methods.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Dry
+  module Schema
+    module Extensions
+      module Hints
+        # Tweaks AND visitor to enable :hints
+        #
+        # @api private
+        module CompilerMethods
+          # @api private
+          def visit_and(node)
+            super.with(hints: true)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Dry
+  module Schema
+    module Extensions
+      module Hints
+        # Adds support for processing [:hint, ...] nodes produced by dry-logic
+        #
+        # @api private
+        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
+
+          # @api private
+          attr_reader :hints
+
+          # @api private
+          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,44 @@
+# frozen_string_literal: true
+
+module Dry
+  module Schema
+    module Extensions
+      module Hints
+        # Hint extensions for MessageSet
+        #
+        # @api public
+        module MessageSetMethods
+          # Filtered message hints from all messages
+          #
+          # @return [Array<Message::Hint>]
+          attr_reader :hints
+          
+          # Configuration option to enable/disable showing errors
+          #
+          # @return [Boolean]
+          attr_reader :failures
+
+          # @api private
+          def initialize(messages, options = EMPTY_HASH)
+            super
+            @hints = messages.select(&:hint?)
+            @failures = options.fetch(:failures, true)
+          end
+
+          # Dump message set to a hash with either all messages or just hints
+          #
+          # @see MessageSet#to_h
+          # @see ResultMethods#hints
+          #
+          # @return [Hash<Symbol=>Array<String>>]
+          #
+          # @api public
+          def to_h
+            @to_h ||= failures ? messages_map : messages_map(hints)
+          end
+          alias_method :to_hash, :to_h
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Dry
+  module Schema
+    module Extensions
+      module Hints
+        # Get errors exclusively without hints
+        #
+        # @api public
+        module ResultMethods
+          # Return error messages exclusively
+          #
+          # @see Result#errors
+          #
+          # @return [MessageSet]
+          #
+          # @api public
+          def errors(options = EMPTY_HASH)
+            message_set(options.merge(hints: false))
+          end
+
+          # Get all messages including hints
+          #
+          # @see #message_set
+          #
+          # @return [MessageSet]
+          #
+          # @api public
+          def messages(options = EMPTY_HASH)
+            message_set(options)
+          end
+
+          # Get hints exclusively without errors
+          #
+          # @see #message_set
+          #
+          # @return [MessageSet]
+          #
+          # @api public
+          def hints(options = EMPTY_HASH)
+            message_set(options.merge(failures: false))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'dry/schema/compiler'
+require 'dry/schema/message'
+require 'dry/schema/message_compiler'
+
+require 'dry/schema/extensions/hints/compiler_methods'
+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
+      # Hints extension for Or messages
+      #
+      # @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
+      # @api private
+      def hint?
+        true
+      end
+    end
+
+    # Hints extensions
+    module Extensions
+      Compiler.prepend(Hints::CompilerMethods)
+      MessageCompiler.prepend(Hints::MessageCompilerMethods)
+      MessageSet.prepend(Hints::MessageSetMethods)
+      Result.prepend(Hints::ResultMethods)
+    end
+  end
+end

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

@@ -1,18 +1,29 @@
+# frozen_string_literal: true
+
 require 'dry/monads/result'
 
 module Dry
   module Schema
+    # Monad extension for Result
+    #
+    # @api public
     class Result
       include Dry::Monads::Result::Mixin
 
-      def to_monad(options = EMPTY_HASH)
+      # Turn result into a monad
+      #
+      # This makes result objects work with dry-monads (or anything with a compatible interface)
+      #
+      # @return [Dry::Monads::Success,Dry::Monads::Failure]
+      #
+      # @api public
+      def to_monad
         if success?
-          Success(output)
+          Success(self)
         else
-          Failure(messages(options))
+          Failure(self)
         end
       end
-      alias_method :to_result, :to_monad
     end
   end
 end

data/lib/dry/schema/extensions.rb

@@ -1,3 +1,9 @@
+# frozen_string_literal: true
+
 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/json.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'dry/schema/processor'
 
 module Dry
@@ -5,7 +7,7 @@ module Dry
     # JSON schema type
     #
     # @see Processor
-    # @see Schema.JSON
+    # @see Schema#JSON
     #
     # @api public
     class JSON < Processor
@@ -13,4 +15,4 @@ module Dry
       config.type_registry = config.type_registry.namespaced(:json)
     end
   end
-end
+end

data/lib/dry/schema/key.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Dry
   module Schema
     # Key objects used by key maps
@@ -10,19 +12,13 @@ module Dry
 
       include Dry.Equalizer(:name, :coercer)
 
-      # @!attribute[r] id
-      #   @return [Symbol] The key identifier
-      #   @api public
+      # @return [Symbol] The key identifier
       attr_reader :id
 
-      # @!attribute[r] name
-      #   @return [Symbol, String, Object] The actual key name expected in an input hash
-      #   @api public
+      # @return [Symbol, String, Object] The actual key name expected in an input hash
       attr_reader :name
 
-      # @!attribute[r] id
-      #   @return [Proc, #call] A key name coercer function
-      #   @api public
+      # @return [Proc, #call] A key name coercer function
       attr_reader :coercer
 
       # @api private
@@ -44,6 +40,8 @@ module Dry
 
       # @api private
       def read(source)
+        return unless source.is_a?(::Hash)
+
         if source.key?(name)
           yield(source[name])
         elsif source.key?(coerced_name)
@@ -163,4 +161,4 @@ module Dry
       end
     end
   end
-end
+end

data/lib/dry/schema/key_coercer.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require 'dry/core/cache'
+require 'dry/equalizer'
 
 module Dry
   module Schema
@@ -7,6 +10,7 @@ module Dry
     # @api private
     class KeyCoercer
       extend Dry::Core::Cache
+      include ::Dry::Equalizer(:key_map, :coercer)
 
       TO_SYM = :to_sym.to_proc.freeze
 
@@ -26,10 +30,10 @@ module Dry
       def initialize(key_map, &coercer)
         @key_map = key_map.coercible(&coercer)
       end
-      
+
       # @api private
       def call(source)
-        key_map.write(Hash(source))
+        key_map.write(source.to_h)
       end
       alias_method :[], :call
     end

data/lib/dry/schema/key_map.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'dry/equalizer'
 require 'dry/core/cache'
 require 'dry/schema/constants'
@@ -19,8 +21,7 @@ module Dry
       include Dry.Equalizer(:keys)
       include Enumerable
 
-      # @!attribute[r] keys
-      #   @return [Array<Key>] A list of defined key objects
+      # @return [Array<Key>] A list of defined key objects
       attr_reader :keys
 
       # Coerce a list of key specs into a key map
@@ -39,7 +40,7 @@ module Dry
 
       # Build new, or returned a cached instance of a key map
       #
-      # @param [Array<Symbol, Array, Hash<Symbol=>Array>>
+      # @param [Array<Symbol>, Array, Hash<Symbol=>Array>] args
       #
       # @return [KeyMap]
       def self.new(*args)
@@ -130,4 +131,4 @@ module Dry
       end
     end
   end
-end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'dry/schema/macros/dsl'
+
+module Dry
+  module Schema
+    module Macros
+      # Macro used to specify predicates for each element of an array
+      #
+      # @api private
+      class Array < DSL
+        # @api private
+        def value(*args, **opts, &block)
+          type(:array)
+
+          extract_type_spec(*args, set_type: false) do |*predicates, type_spec:|
+            type(schema_dsl.array[type_spec]) if type_spec
+
+            is_hash_block = type_spec.equal?(:hash)
+
+            if predicates.any? || opts.any? || !is_hash_block
+              super(*predicates, type_spec: type_spec, **opts, &(is_hash_block ? nil : block))
+            end
+
+            hash(&block) if is_hash_block
+          end
+
+          self
+        end
+
+        # @api private
+        def to_ast(*)
+          [:and, [trace.array?.to_ast, [:each, trace.to_ast]]]
+        end
+        alias_method :ast, :to_ast
+      end
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'dry/initializer'
 
 require 'dry/schema/constants'