dry-schema 0.1.0

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

@@ -0,0 +1,18 @@
+require 'dry/schema/macros/dsl'
+
+module Dry
+  module Schema
+    module Macros
+      # Macro used to specify predicates for each element of an array
+      #
+      # @api public
+      class Each < DSL
+        # @api private
+        def to_ast(*)
+          [:each, trace.to_ast]
+        end
+        alias_method :ast, :to_ast
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'dry/schema/macros/value'
+
+module Dry
+  module Schema
+    module Macros
+      # Macro used to prepend `:filled?` predicate
+      #
+      # @api public
+      class Filled < Value
+        def call(*args, &block)
+          if args.include?(:empty?)
+            raise ::Dry::Schema::InvalidSchemaError, "Using filled with empty? predicate is invalid"
+          end
+
+          if args.include?(:filled?)
+            raise ::Dry::Schema::InvalidSchemaError, "Using filled with filled? is redundant"
+          end
+
+          value(:filled?, *args, &block)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+require 'dry/schema/macros/value'
+
+module Dry
+  module Schema
+    module Macros
+      # Macro used to specify a nested schema
+      #
+      # @api public
+      class Hash < Value
+        # @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
+
+          self
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,137 @@
+require 'dry/schema/predicate_inferrer'
+require 'dry/schema/processor'
+require 'dry/schema/macros/dsl'
+require 'dry/schema/constants'
+
+module Dry
+  module Schema
+    module Macros
+      # Base macro for specifying rules applied to a value found under the key
+      #
+      # @see DSL#key
+      #
+      # @api public
+      class Key < DSL
+        option :filter_schema, optional: true, default: proc { schema_dsl&.new }
+
+        # Specify predicates that should be used to filter out values
+        # before coercion is applied
+        #
+        # @see Macros::DSL#value
+        #
+        # @return [Macros::Key]
+        #
+        # @api public
+        def filter(*args, &block)
+          filter_schema.optional(name).value(*args, &block)
+          self
+        end
+
+        # Set type specification and predicates
+        #
+        # @see Macros::DSL#value
+        #
+        # @return [Macros::Key]
+        #
+        # @api public
+        def value(*args, **opts, &block)
+          extract_type_spec(*args) do |*predicates|
+            super(*predicates, **opts, &block)
+          end
+        end
+
+        # Set type specification and predicates for a filled value
+        #
+        # @see Macros::DSL#value
+        #
+        # @return [Macros::Key]
+        #
+        # @api public
+        def filled(*args, **opts, &block)
+          extract_type_spec(*args) do |*predicates|
+            super(*predicates, **opts, &block)
+          end
+        end
+
+        # Set type specification and predicates for a maybe value
+        #
+        # @see Macros::DSL#value
+        #
+        # @return [Macros::Key]
+        #
+        # @api public
+        def maybe(*args, **opts, &block)
+          extract_type_spec(*args, nullable: true) do |*predicates|
+            append_macro(Macros::Maybe) do |macro|
+              macro.call(*predicates, **opts, &block)
+            end
+          end
+        end
+
+        # Set type spec
+        #
+        # @param [Symbol, Array, Dry::Types::Type]
+        #
+        # @return [Macros::Key]
+        #
+        # @api public
+        def type(spec)
+          schema_dsl.set_type(name, spec)
+          self
+        end
+
+        # Coerce macro to a rule
+        #
+        # @return [Dry::Logic::Rule]
+        #
+        # @api private
+        def to_rule
+          if trace.captures.empty?
+            super
+          else
+            [super, trace.to_rule(name)].reduce(operation)
+          end
+        end
+
+        # @api private
+        def to_ast
+          [:predicate, [:key?, [[:name, name], [:input, Undefined]]]]
+        end
+
+        private
+
+        # @api private
+        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)
+            type_spec = nil
+          end
+
+          predicates = Array(type_spec ? args[1..-1] : args)
+
+          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
+
+              if type_predicates.size.equal?(1)
+                predicates.unshift(type_predicates[0])
+              else
+                predicates.unshift(type_predicates)
+              end
+            end
+          end
+
+          yield(*predicates)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require 'dry/schema/macros/dsl'
+
+module Dry
+  module Schema
+    module Macros
+      # Macro used to specify predicates for a value that can be `nil`
+      #
+      # @api public
+      class Maybe < DSL
+        # @api private
+        def call(*args, **opts, &block)
+          if args.include?(:empty?)
+            raise ::Dry::Schema::InvalidSchemaError, "Using maybe with empty? predicate is invalid"
+          end
+
+          if args.include?(:nil?)
+            raise ::Dry::Schema::InvalidSchemaError, "Using maybe with nil? predicate is redundant"
+          end
+
+          value(*args, **opts, &block)
+
+          self
+        end
+
+        # @api private
+        def to_ast
+          [:implication,
+           [
+             [:not, [:predicate, [:nil?, [[:input, Undefined]]]]],
+             trace.to_rule.to_ast
+           ]
+          ]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+require 'dry/schema/macros/key'
+
+module Dry
+  module Schema
+    module Macros
+      # A Key specialization used for keys that can be skipped
+      #
+      # @api public
+      class Optional < Key
+        # @api private
+        def operation
+          :then
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+require 'dry/schema/macros/key'
+
+module Dry
+  module Schema
+    module Macros
+      # A Key specialization used for keys that must be present
+      #
+      # @api public
+      class Required < Key
+        # @api private
+        def operation
+          :and
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'dry/schema/macros/dsl'
+
+module Dry
+  module Schema
+    module Macros
+      # A macro used for specifying predicates to be applied to values from a hash
+      #
+      # @api public
+      class Value < DSL
+        # @api private
+        def call(*predicates, **opts, &block)
+          trace.evaluate(*predicates, **opts, &block)
+
+          trace.append(new(chain: false).instance_exec(&block)) if block
+
+          if trace.captures.empty?
+            raise ArgumentError, 'wrong number of arguments (given 0, expected at least 1)'
+          end
+
+          self
+        end
+
+        # @api private
+        def respond_to_missing?(meth, include_private = false)
+          super || meth.to_s.end_with?(QUESTION_MARK)
+        end
+
+        private
+
+        # @api private
+        def method_missing(meth, *args, &block)
+          if meth.to_s.end_with?(QUESTION_MARK)
+            trace.__send__(meth, *args, &block)
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/schema/message.rb

@@ -0,0 +1,103 @@
+require 'dry/equalizer'
+
+module Dry
+  module Schema
+    # Message objects used by message sets
+    #
+    # @api public
+    class Message
+      include Dry::Equalizer(:predicate, :path, :text, :options)
+
+      attr_reader :predicate, :path, :text, :rule, :args, :options
+
+      # A message sub-type used by OR operations
+      #
+      # @api public
+      class Or
+        # @api private
+        attr_reader :left
+
+        # @api private
+        attr_reader :right
+
+        # @api private
+        attr_reader :path
+
+        # @api private
+        attr_reader :messages
+
+        # @api private
+        def initialize(left, right, messages)
+          @left = left
+          @right = right
+          @messages = messages
+          @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]} ")
+        end
+      end
+
+      # Build a new message object
+      #
+      # @api private
+      def self.[](predicate, path, text, options)
+        Message.new(predicate, path, text, options)
+      end
+
+      # @api private
+      def initialize(predicate, path, text, options)
+        @predicate = predicate
+        @path = path.dup
+        @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
+      #
+      # @api public
+      def to_s
+        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