dry-schema 0.1.1 → 0.2.0

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

@@ -35,10 +35,21 @@ module Dry
           end
         end
 
-        # Specify a nested schema
+        # Specify a nested hash without enforced hash? type-check
         #
         # @api public
         def schema(*args, &block)
+          append_macro(Macros::Schema) do |macro|
+            macro.call(*args, &block)
+          end
+        end
+
+        # Specify a nested hash with enforced hash? type-check
+        #
+        # @see #schema
+        #
+        # @api public
+        def hash(*args, &block)
           append_macro(Macros::Hash) do |macro|
             macro.call(*args, &block)
           end
@@ -53,6 +64,16 @@ module Dry
           end
         end
 
+        # Like `each`, but prepends `array?` check
+        #
+        # @api public
+        def array(*args, &block)
+          value(:array)
+          append_macro(Macros::Each) do |macro|
+            macro.value(*args, &block)
+          end
+        end
+
         private
 
         # @api private

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

@@ -7,16 +7,20 @@ module Dry
       #
       # @api public
       class Filled < Value
-        def call(*args, &block)
-          if args.include?(:empty?)
+        def call(*predicates, **opts, &block)
+          if predicates.include?(:empty?)
             raise ::Dry::Schema::InvalidSchemaError, "Using filled with empty? predicate is invalid"
           end
 
-          if args.include?(:filled?)
+          if predicates.include?(:filled?)
             raise ::Dry::Schema::InvalidSchemaError, "Using filled with filled? is redundant"
           end
 
-          value(:filled?, *args, &block)
+          if opts[:type_spec].equal?(true)
+            value(predicates[0], :filled?, *predicates[1..predicates.size-1], **opts, &block)
+          else
+            value(:filled?, *predicates, **opts, &block)
+          end
         end
       end
     end

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

@@ -1,4 +1,4 @@
-require 'dry/schema/macros/value'
+require 'dry/schema/macros/schema'
 
 module Dry
   module Schema
@@ -6,38 +6,11 @@ module Dry
       # Macro used to specify a nested schema
       #
       # @api public
-      class Hash < Value
+      class Hash < Schema
         # @api private
         def call(*args, &block)
           trace << hash?
-
-          super(*args) unless args.empty?
-
-          if block
-            definition = schema_dsl.new(&block)
-
-            parent_type = schema_dsl.types[name]
-            definition_schema = definition.type_schema
-
-            schema_type =
-              if parent_type.respond_to?(:of)
-                parent_type.of(definition_schema)
-              else
-                definition_schema
-              end
-
-            final_type =
-              if schema_dsl.maybe?(parent_type)
-                schema_type.optional
-              else
-                schema_type
-              end
-
-            schema_dsl.set_type(name, final_type)
-
-            trace << definition.to_rule
-          end
-
+          super(*args, &block)
           self
         end
       end

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

@@ -35,7 +35,7 @@ module Dry
         #
         # @api public
         def value(*args, **opts, &block)
-          extract_type_spec(*args) do |*predicates|
+          extract_type_spec(*args) do |*predicates, type_spec:|
             super(*predicates, **opts, &block)
           end
         end
@@ -48,8 +48,8 @@ module Dry
         #
         # @api public
         def filled(*args, **opts, &block)
-          extract_type_spec(*args) do |*predicates|
-            super(*predicates, **opts, &block)
+          extract_type_spec(*args) do |*predicates, type_spec:|
+            super(*predicates, type_spec: type_spec, **opts, &block)
           end
         end
 
@@ -61,7 +61,7 @@ module Dry
         #
         # @api public
         def maybe(*args, **opts, &block)
-          extract_type_spec(*args, nullable: true) do |*predicates|
+          extract_type_spec(*args, nullable: true) do |*predicates, type_spec:|
             append_macro(Macros::Maybe) do |macro|
               macro.call(*predicates, **opts, &block)
             end
@@ -104,7 +104,7 @@ module Dry
         def extract_type_spec(*args, nullable: false)
           type_spec = args[0]
 
-          if type_spec.kind_of?(Schema::Processor) || type_spec.is_a?(Symbol) && type_spec.to_s.end_with?(QUESTION_MARK)
+          if type_spec.kind_of?(Dry::Schema::Processor) || type_spec.is_a?(Symbol) && type_spec.to_s.end_with?(QUESTION_MARK)
             type_spec = nil
           end
 
@@ -129,7 +129,7 @@ module Dry
             end
           end
 
-          yield(*predicates)
+          yield(*predicates, type_spec: !type_spec.nil?)
         end
       end
     end

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

@@ -0,0 +1,44 @@
+require 'dry/schema/macros/value'
+
+module Dry
+  module Schema
+    module Macros
+      # Macro used to specify a nested schema
+      #
+      # @api public
+      class Schema < Value
+        # @api private
+        def call(*args, &block)
+          super(*args) unless args.empty?
+
+          if block
+            definition = schema_dsl.new(&block)
+
+            parent_type = schema_dsl.types[name]
+            definition_schema = definition.type_schema
+
+            schema_type =
+              if parent_type.respond_to?(:of)
+                parent_type.of(definition_schema)
+              else
+                definition_schema
+              end
+
+            final_type =
+              if schema_dsl.maybe?(parent_type)
+                schema_type.optional
+              else
+                schema_type
+              end
+
+            schema_dsl.set_type(name, final_type)
+
+            trace << definition.to_rule
+          end
+
+          self
+        end
+      end
+    end
+  end
+end

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

@@ -9,6 +9,15 @@ module Dry
       class Value < DSL
         # @api private
         def call(*predicates, **opts, &block)
+          schema = predicates.detect { |predicate| predicate.is_a?(Processor) }
+
+          if schema
+            current_type = schema_dsl.types[name]
+            updated_type = current_type.respond_to?(:of) ? current_type.of(schema.type_schema) : schema.type_schema
+
+            schema_dsl.set_type(name, updated_type)
+          end
+
           trace.evaluate(*predicates, **opts, &block)
 
           trace.append(new(chain: false).instance_exec(&block)) if block

data/lib/dry/schema/message.rb

@@ -14,6 +14,8 @@ module Dry
       #
       # @api public
       class Or
+        include Enumerable
+
         # @api private
         attr_reader :left
 
@@ -34,16 +36,21 @@ module Dry
           @path = left.path
         end
 
-        # @api private
-        def hint?
-          false
-        end
-
         # Return a string representation of the message
         #
         # @api public
         def to_s
-          [left, right].uniq.join(" #{messages[:or].()} ")
+          uniq.join(" #{messages[:or].()} ")
+        end
+
+        # @api private
+        def each(&block)
+          to_a.each(&block)
+        end
+
+        # @api private
+        def to_a
+          [left, right]
         end
       end
 
@@ -75,29 +82,10 @@ module Dry
         text
       end
 
-      # @api private
-      def hint?
-        false
-      end
-
       # @api private
       def eql?(other)
         other.is_a?(String) ? text == other : super
       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
   end
 end

data/lib/dry/schema/message_compiler.rb

@@ -19,9 +19,8 @@ module Dry
         @messages = messages
         @options = options
         @full = @options.fetch(:full, false)
-        @hints = @options.fetch(:hints, true)
-        @locale = @options.fetch(:locale, messages.default_locale)
-        @default_lookup_options = { locale: locale }
+        @locale = @options[:locale]
+        @default_lookup_options = @locale ? { locale: locale } : EMPTY_HASH
       end
 
       # @api private
@@ -29,11 +28,6 @@ module Dry
         @full
       end
 
-      # @api private
-      def hints?
-        @hints
-      end
-
       # @api private
       def with(new_options)
         return self if new_options.empty?
@@ -42,40 +36,35 @@ module Dry
 
       # @api private
       def call(ast)
-        MessageSet[ast.map { |node| visit(node) }, failures: options.fetch(:failures, true)]
+        current_messages = EMPTY_ARRAY.dup
+        compiled_messages = ast.map { |node| visit(node, EMPTY_OPTS.dup(current_messages)) }
+
+        MessageSet[compiled_messages, failures: options.fetch(:failures, true)]
       end
 
       # @api private
-      def visit(node, *args)
-        __send__(:"visit_#{node[0]}", node[1], *args)
+      def visit(node, opts = EMPTY_OPTS.dup)
+        __send__(:"visit_#{node[0]}", node[1], opts)
       end
 
       # @api private
-      def visit_failure(node, opts = EMPTY_OPTS.dup)
+      def visit_failure(node, opts)
         rule, other = node
         visit(other, opts.(rule: rule))
       end
 
       # @api private
-      def visit_hint(node, opts = EMPTY_OPTS.dup)
-        if hints?
-          visit(node, opts.(message_type: :hint))
-        end
-      end
-
-      # @api private
-      def visit_each(node, opts = EMPTY_OPTS.dup)
-        # TODO: we can still generate a hint for elements here!
-        []
+      def visit_hint(node, opts)
+        nil
       end
 
       # @api private
-      def visit_not(node, opts = EMPTY_OPTS.dup)
+      def visit_not(node, opts)
         visit(node, opts.(not: true))
       end
 
       # @api private
-      def visit_and(node, opts = EMPTY_OPTS.dup)
+      def visit_and(node, opts)
         left, right = node.map { |n| visit(n, opts) }
 
         if right
@@ -86,7 +75,7 @@ module Dry
       end
 
       # @api private
-      def visit_or(node, opts = EMPTY_OPTS.dup)
+      def visit_or(node, opts)
         left, right = node.map { |n| visit(n, opts) }
 
         if [left, right].flatten.map(&:path).uniq.size == 1
@@ -99,7 +88,14 @@ module Dry
       end
 
       # @api private
-      def visit_predicate(node, base_opts = EMPTY_OPTS.dup)
+      def visit_namespace(node, opts)
+        ns, rest = node
+        self.class.new(messages.namespaced(ns), options).visit(rest, opts)
+      end
+
+      # @api private
+      def visit_predicate(node, opts)
+        base_opts = opts.dup
         predicate, args = node
 
         *arg_vals, val = args.map(&:last)
@@ -121,9 +117,7 @@ module Dry
 
         text = message_text(rule, template, tokens, options)
 
-        message_class = options[:message_type] == :hint ? Hint : Message
-
-        message_class[
+        message_type(options)[
           predicate, path, text,
           args: arg_vals,
           input: input,
@@ -132,13 +126,18 @@ module Dry
       end
 
       # @api private
-      def visit_key(node, opts = EMPTY_OPTS.dup)
+      def message_type(*)
+        Message
+      end
+
+      # @api private
+      def visit_key(node, opts)
         name, other = node
         visit(other, opts.(path: name))
       end
 
       # @api private
-      def visit_set(node, opts = EMPTY_OPTS.dup)
+      def visit_set(node, opts)
         node.map { |el| visit(el, opts) }
       end
 
@@ -149,7 +148,7 @@ module Dry
       end
 
       # @api private
-      def visit_xor(node, opts = EMPTY_OPTS.dup)
+      def visit_xor(node, opts)
         left, right = node
         [visit(left, opts), visit(right, opts)].uniq
       end

data/lib/dry/schema/message_compiler/visitor_opts.rb

@@ -1,3 +1,6 @@
+require 'dry/schema/constants'
+require 'dry/schema/message'
+
 module Dry
   module Schema
     # @api private
@@ -12,6 +15,7 @@ module Dry
           opts[:path] = EMPTY_ARRAY
           opts[:rule] = nil
           opts[:message_type] = :failure
+          opts[:current_messages] = EMPTY_ARRAY.dup
           opts
         end
 
@@ -24,6 +28,28 @@ module Dry
         def call(other)
           merge(other.update(path: [*path, *other[:path]]))
         end
+
+        def dup(current_messages = EMPTY_ARRAY.dup)
+          opts = super()
+          opts[:current_messages] = current_messages
+          opts
+        end
+
+        def key_failure?(path)
+          failures.any? { |f| f.path == path && f.predicate.equal?(:key?) }
+        end
+
+        def failures
+          current_messages.reject(&:hint?)
+        end
+
+        def hints
+          current_messages.select(&:hint?)
+        end
+
+        def current_messages
+          self[:current_messages]
+        end
       end
     end
   end