dry-schema 0.1.0 → 1.0.0

data/lib/dry/schema/params.rb

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

data/lib/dry/schema/path.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'dry/schema/constants'
+
+module Dry
+  module Schema
+    # Path represents a list of keys in a hash
+    #
+    # @api private
+    class Path
+      include Comparable
+      include Enumerable
+
+      # @return [Array<Symbol>]
+      attr_reader :keys
+
+      alias_method :root, :first
+
+      # Coerce a spec into a path object
+      #
+      # @param [Path, Symbol, String, Hash, Array<Symbol>] spec
+      #
+      # @return [Path]
+      #
+      # @api private
+      def self.[](spec)
+        case spec
+        when Symbol, Array
+          new(Array[*spec])
+        when String
+          new(spec.split(DOT).map(&:to_sym))
+        when Hash
+          new(keys_from_hash(spec))
+        when Path
+          spec
+        else
+          raise ArgumentError, '+spec+ must be either a Symbol, Array, Hash or a Path'
+        end
+      end
+
+      # Extract a list of keys from a hash
+      #
+      # @api private
+      def self.keys_from_hash(hash)
+        hash.inject([]) { |a, (k, v)|
+          v.is_a?(Hash) ? a.concat([k, *keys_from_hash(v)]) : a.concat([k, v])
+        }
+      end
+
+      # @api private
+      def initialize(keys)
+        @keys = keys
+      end
+
+      # @api private
+      def each(&block)
+        keys.each(&block)
+      end
+
+      # @api private
+      def index(key)
+        keys.index(key)
+      end
+
+      # @api private
+      def include?(other)
+        return false unless same_root?(other)
+        return false if index? && other.index? && !last.equal?(other.last)
+        self >= other
+      end
+
+      # @api private
+      def <=>(other)
+        raise ArgumentError, "Can't compare paths from different branches" unless same_root?(other)
+
+        return 0 if keys.eql?(other.keys)
+
+        res =
+          map { |key| (idx = other.index(key)) && keys[idx].equal?(key) }
+            .compact
+            .reject { |value| value.equal?(false) }
+
+        res.size < count ? 1 : -1
+      end
+
+      # @api private
+      def last
+        keys.last
+      end
+
+      # @api private
+      def same_root?(other)
+        root.equal?(other.root)
+      end
+
+      # @api private
+      def index?
+        last.is_a?(Integer)
+      end
+    end
+  end
+end

data/lib/dry/schema/predicate.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'dry/equalizer'
 require 'dry/logic/operators'
 
@@ -19,6 +21,10 @@ module Dry
           @predicate = predicate
         end
 
+        # Dump negated predicate to an AST
+        #
+        # @return [Array]
+        #
         # @api private
         def to_ast(*args)
           [:not, predicate.to_ast(*args)]
@@ -51,6 +57,9 @@ module Dry
 
       # Negate a predicate
       #
+      # @example
+      #   required(:name).value(:string) { !empty? }
+      #
       # @return [Negation]
       #
       # @api public
@@ -65,11 +74,17 @@ module Dry
         end
       end
 
+      # Compile predicate to a rule object
+      #
       # @api private
       def to_rule
         compiler.visit(to_ast)
       end
 
+      # Dump predicate to an AST
+      #
+      # @return [Array]
+      #
       # @api private
       def to_ast(*)
         [:predicate, [name, compiler.predicates.arg_list(name, *args)]]

data/lib/dry/schema/predicate_inferrer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'dry/core/cache'
 
 module Dry
@@ -9,40 +11,131 @@ module Dry
     class PredicateInferrer
       extend Dry::Core::Cache
 
-      TYPE_TO_PREDICATE = Hash.new do |hash, type|
-        primitive = type.meta[:maybe] ? type.right.primitive : type.primitive
-
-        if hash.key?(primitive)
-          hash[primitive]
-        else
-          :"#{primitive.name.split('::').last.downcase}?"
-        end
-      end
-
-      TYPE_TO_PREDICATE.update(
+      TYPE_TO_PREDICATE = {
+        DateTime => :date_time?,
         FalseClass => :false?,
         Integer => :int?,
         NilClass => :nil?,
         String => :str?,
         TrueClass => :true?
-      ).freeze
+      }.freeze
+
+      REDUCED_TYPES = {
+        %i[true? false?] => :bool?
+      }.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)
+            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, right = node
+
+          predicates = [visit(left), visit(right)]
+
+          if predicates.first == :nil?
+            predicates[1..predicates.size - 1]
+          else
+            predicates
+          end
+        end
+
+        # @api private
+        def visit_constrained(node)
+          other, * = node
+          visit(other)
+        end
+
+        # @api private
+        def visit_any(_)
+          nil
+        end
+      end
+
+      # @return [Compiler]
+      # @api private
+      attr_reader :compiler
+
+      # @api private
+      def initialize(registry)
+        @compiler = Compiler.new(registry)
+      end
 
       # Infer predicate identifier from the provided type
       #
       # @return [Symbol]
       #
       # @api private
-      def self.[](type)
-        fetch_or_store(type.hash) {
-          predicates =
-            if type.is_a?(Dry::Types::Sum) && !type.meta[:maybe]
-              [self[type.left], self[type.right]]
-            else
-              TYPE_TO_PREDICATE[type]
-            end
-
-          Array(predicates).flatten
-        }
+      def [](type)
+        self.class.fetch_or_store(type.hash) do
+          predicates = compiler.visit(type.to_ast)
+
+          if predicates.is_a?(Hash)
+            predicates
+          else
+            Array(REDUCED_TYPES[predicates] || predicates).flatten
+          end
+        end
       end
     end
   end

data/lib/dry/schema/predicate_registry.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'dry/logic/predicates'
 
 module Dry

data/lib/dry/schema/processor.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'dry/configurable'
 require 'dry/initializer'
 
@@ -15,7 +17,7 @@ module Dry
     #   1. Prepare input hash using a key map
     #   2. Apply pre-coercion filtering rules (optional step, used only when `filter` was used)
     #   3. Apply value coercions based on type specifications
-    #   4. Apply rules 
+    #   4. Apply rules
     #
     # @see Params
     # @see JSON
@@ -30,42 +32,42 @@ module Dry
 
       param :steps, default: -> { EMPTY_ARRAY.dup }
 
-      # Define a schema for your processor class
-      #
-      # @see Params
-      # @see JSON
-      #
-      # @return [Class]
-      #
-      # @api public
-      def self.define(&block)
-        @__definition__ ||= DSL.new(
-          processor_type: self, parent: superclass.definition, **config, &block
-        )
-        self
-      end
+      class << self
+        # Return DSL configured via #define
+        #
+        # @return [DSL]
+        # @api private
+        attr_reader :definition
 
-      # Return DSL configured via #define
-      #
-      # @return [DSL]
-      #
-      # @api private
-      def self.definition
-        @__definition__
-      end
+        # Define a schema for your processor class
+        #
+        # @see Schema#define
+        # @see Schema#Params
+        # @see Schema#JSON
+        #
+        # @return [Class]
+        #
+        # @api public
+        def define(&block)
+          @definition ||= DSL.new(
+            processor_type: self, parent: superclass.definition, **config, &block
+          )
+          self
+        end
 
-      # Build a new processor object
-      #
-      # @return [Processor]
-      #
-      # @api public
-      def self.new(&block)
-        if block
-          super.tap(&block)
-        elsif definition
-          definition.call
-        else
-          raise ArgumentError, 'Cannot create a schema without a definition'
+        # Build a new processor object
+        #
+        # @return [Processor]
+        #
+        # @api public
+        def new(&block)
+          if block
+            super.tap(&block)
+          elsif definition
+            definition.call
+          else
+            raise ArgumentError, 'Cannot create a schema without a definition'
+          end
         end
       end
 
@@ -94,6 +96,16 @@ module Dry
           end
         end
       end
+      alias_method :[], :call
+
+      # Return a proc that acts like a schema object
+      #
+      # @return [Proc]
+      #
+      # @api public
+      def to_proc
+        ->(input) { call(input) }
+      end
 
       # Return the key map
       #
@@ -101,7 +113,18 @@ module Dry
       #
       # @api public
       def key_map
-        @__key_map__ ||= steps.detect { |s| s.is_a?(KeyCoercer) }.key_map
+        @key_map ||= steps.detect { |s| s.is_a?(KeyCoercer) }.key_map
+      end
+
+      # Return string represntation
+      #
+      # @return [String]
+      #
+      # @api public
+      def inspect
+        <<~STR.strip
+          #<#{self.class.name} keys=#{key_map.map(&:dump)} rules=#{rules.map { |k, v| [k, v.to_s] }.to_h}>
+        STR
       end
 
       # Return the type schema
@@ -110,7 +133,16 @@ module Dry
       #
       # @api private
       def type_schema
-        @__type_schema__ ||= steps.detect { |s| s.is_a?(ValueCoercer) }.type_schema
+        @type_schema ||= steps.detect { |s| s.is_a?(ValueCoercer) }.type_schema
+      end
+
+      # Return the rules config
+      #
+      # @return [Dry::Types::Config]
+      #
+      # @api private
+      def config
+        @config ||= rule_applier.config
       end
 
       # Return AST representation of the rules
@@ -142,8 +174,7 @@ module Dry
       #
       # @api private
       def rule_applier
-        # TODO: make this more explicit through class types
-        @__rule_applier__ ||= steps.last
+        @rule_applier ||= steps.last
       end
       alias_method :to_rule, :rule_applier
     end

data/lib/dry/schema/result.rb

@@ -1,6 +1,10 @@
+# frozen_string_literal: true
+
 require 'dry/initializer'
 require 'dry/equalizer'
 
+require 'dry/schema/path'
+
 module Dry
   module Schema
     # Processing result
@@ -15,8 +19,11 @@ module Dry
 
       # @api private
       param :output
+
+      # Dump result to a hash returning processed and validated data
+      #
+      # @return [Hash]
       alias_method :to_h, :output
-      alias_method :to_hash, :output
 
       # @api private
       param :results, default: -> { EMPTY_ARRAY.dup }
@@ -66,15 +73,15 @@ module Dry
         output.key?(name)
       end
 
-      # Check if a given key resulted in an error
+      # Check if there's an error for the provided spec
       #
-      # @param [Symbol] name
+      # @param [Symbol, Hash<Symbol=>Symbol>] spec
       #
       # @return [Boolean]
       #
       # @api public
-      def error?(name)
-        errors.key?(name)
+      def error?(spec)
+        message_set.any? { |msg| Path[msg.path].include?(Path[spec]) }
       end
 
       # Check if the result is successful
@@ -99,33 +106,11 @@ module Dry
       #
       # @see #message_set
       #
-      # @return [Hash<Symbol=>Array>]
+      # @return [MessageSet]
       #
       # @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.merge(hints: true)).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
+        message_set(options)
       end
 
       # Return the message set
@@ -148,7 +133,7 @@ module Dry
       #
       # @api public
       def inspect
-        "#<#{self.class}#{to_h.inspect} errors=#{errors.inspect}>"
+        "#<#{self.class}#{to_h.inspect} errors=#{errors.to_h.inspect}>"
       end
 
       private
@@ -157,7 +142,7 @@ module Dry
       #
       # @api private
       def result_ast
-        @__result__ast ||= results.map(&:to_ast)
+        @result_ast ||= results.map(&:to_ast)
       end
     end
   end

data/lib/dry/schema/rule_applier.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'dry/initializer'
 
 require 'dry/schema/constants'
@@ -18,10 +20,10 @@ module Dry
       param :rules
 
       # @api private
-      option :config, default: proc { Config.new }
+      option :config, default: -> { Config.new }
 
       # @api private
-      option :message_compiler, default: proc { MessageCompiler.new(Messages.setup(config)) }
+      option :message_compiler, default: -> { MessageCompiler.new(Messages.setup(config.messages)) }
 
       # @api private
       def call(input)
@@ -29,6 +31,7 @@ module Dry
 
         rules.each do |name, rule|
           next if input.error?(name)
+
           result = rule.(input)
           results << result if result.failure?
         end
@@ -38,7 +41,11 @@ module Dry
 
       # @api private
       def to_ast
-        [:set, rules.values.map(&:to_ast)]
+        if config.messages.namespace
+          [:namespace, [config.messages.namespace, [:set, rules.values.map(&:to_ast)]]]
+        else
+          [:set, rules.values.map(&:to_ast)]
+        end
       end
     end
   end

data/lib/dry/schema/trace.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'dry/schema/constants'
 require 'dry/schema/compiler'
 require 'dry/schema/predicate'
@@ -27,10 +29,15 @@ module Dry
       end
 
       # @api private
-      def evaluate(*predicates, **opts, &block)
+      def evaluate(*predicates, **opts)
+        pred_opts = opts.dup
+        pred_opts.delete(:type_spec)
+
         predicates.each do |predicate|
           if predicate.respond_to?(:call)
             append(predicate)
+          elsif predicate.is_a?(::Hash)
+            evaluate_hash_predicates(predicate)
           elsif predicate.is_a?(::Array)
             append(predicate.map { |pred| __send__(pred) }.reduce(:|))
           else
@@ -38,10 +45,16 @@ module Dry
           end
         end
 
-        opts.each do |predicate, *args|
+        evaluate_hash_predicates(pred_opts)
+
+        self
+      end
+
+      # @api private
+      def evaluate_hash_predicates(predicates)
+        predicates.each do |predicate, *args|
           append(__send__(predicate, *args))
         end
-
         self
       end
 

data/lib/dry/schema/type_registry.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'dry/schema/constants'
 require 'dry/schema/types'
 
@@ -16,12 +18,12 @@ module Dry
       attr_reader :namespace
 
       # @api private
-      def self.new(types = Dry::Types, namespace = nil)
+      def self.new(types = Dry::Types, namespace = :nominal)
         super
       end
 
       # @api private
-      def initialize(types, namespace = nil)
+      def initialize(types, namespace = :nominal)
         @types = types
         @namespace = namespace
       end
@@ -39,4 +41,4 @@ module Dry
       end
     end
   end
-end
+end

data/lib/dry/schema/types.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'dry/types'
 
 module Dry
@@ -6,7 +8,7 @@ module Dry
     #
     # @api public
     module Types
-      include Dry::Types.module
+      include Dry.Types
     end
   end
 end