dry-validation-rust 0.1.0.pre5

data/lib/dry/validation/rust/message_set.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module Dry
+  module Validation
+    module Rust
+      # A collection of validation messages with filtering and rendering views.
+      #
+      # Message sets preserve individual {Message} objects until a caller asks
+      # for a nested error hash with {#to_h}. Use {#with} with `full: true` to
+      # render field names into message text.
+      #
+      # @example Read nested errors from a contract result
+      #   result.errors.to_h # => { name: ["is missing"] }
+      class MessageSet
+        include Enumerable
+
+        # @return [Hash] rendering options applied to this message set.
+        attr_reader :options
+
+        # Creates a message set from messages and optional rendering options.
+        #
+        # @param messages [Array<Message>] messages to include
+        # @param options [Hash] rendering options, such as `full: true`
+        # @return [MessageSet]
+        def initialize(messages = [], options = {})
+          @messages = messages.dup
+          @options = options
+        end
+
+        # Iterates over messages.
+        #
+        # @yield [message] each message in the set
+        # @yieldparam message [Message]
+        # @return [Enumerator, MessageSet] an enumerator without a block, or this set with one
+        # @example Print each message text
+        #   result.errors.each { |message| puts message.text }
+        def each(&)
+          @messages.each(&)
+        end
+
+        # Returns an immutable snapshot of the messages.
+        #
+        # @return [Array<Message>] frozen message-object view
+        def messages
+          readonly_messages
+        end
+
+        # Returns messages at or below a key or path.
+        #
+        # @param key [Symbol, String, Array, Hash] key or supported path specification
+        # @return [MessageSet] messages whose paths start with `key`
+        # @example Select nested address messages
+        #   result.errors[:address].to_h # => { city: ["is missing"] }
+        def [](key)
+          wanted = Path.parse(key)
+          self.class.new(@messages.select { |message| Path.prefix?(message.path, wanted) }, options)
+        end
+
+        # Adds a message and invalidates derived views.
+        #
+        # @param message [Message] message to append
+        # @return [MessageSet] this set
+        def add(message)
+          @messages << message
+          @readonly_messages = nil
+          @to_h = nil
+          self
+        end
+
+        # Returns whether this set contains no messages.
+        #
+        # @return [Boolean]
+        def empty?
+          @messages.empty?
+        end
+
+        # Returns messages satisfying every supplied message predicate.
+        #
+        # Each predicate must be a public predicate method on a message and
+        # return a truthy value. A message without a requested predicate is
+        # excluded.
+        #
+        # @param predicates [Array<Symbol, String>] message predicate names
+        # @return [MessageSet] matching messages
+        # @example Select base-level messages
+        #   result.errors.filter(:base?)
+        def filter(*predicates)
+          self.class.new(
+            @messages.select do |message|
+              predicates.all? { |predicate| message.respond_to?(predicate) && message.public_send(predicate) }
+            end,
+            options
+          )
+        end
+
+        # Returns a copy with rendering options, including full-message text.
+        #
+        # With `full: true`, non-base message text is prefixed with its
+        # humanized path (for example, `:first_name` becomes `"first name"`).
+        #
+        # @param new_options [Hash] rendering options to merge into {#options}
+        # @return [MessageSet] a new set using the merged options
+        # @example Render full messages
+        #   result.errors.with(full: true).messages.map(&:text)
+        #   # => ["name is missing"]
+        def with(new_options = {})
+          merged = options.merge(new_options)
+          return self.class.new(@messages, merged) unless merged[:full]
+
+          self.class.new(@messages.map { |message| full_message(message) }, merged)
+        end
+
+        # Returns messages grouped into a nested Hash by path.
+        #
+        # @return [Hash] nested error messages keyed by their paths
+        # @example Read errors as a hash
+        #   result.errors.to_h # => { address: { city: ["is missing"] } }
+        def to_h
+          @to_h ||= build_nested_hash
+        end
+
+        # Freezes this set and its cached derived Hash.
+        #
+        # @return [MessageSet] this frozen set
+        def freeze
+          @messages.freeze
+          # Keep the derived representation so callers of a frozen set reuse it.
+          to_h.freeze
+          super
+        end
+
+        private
+
+        def readonly_messages
+          @readonly_messages ||= @messages.dup.freeze
+        end
+
+        def build_nested_hash
+          @messages.each_with_object({}) do |message, result|
+            insert(result, message.path.empty? ? [nil] : message.path, message.payload)
+          end
+        end
+
+        def insert(root, path, payload)
+          leaf = path.last
+          parent = path[0...-1].reduce(root) { |node, part| node[part] ||= {} }
+          (parent[leaf] ||= []) << payload
+        end
+
+        def full_message(message)
+          return message if message.base?
+
+          label = message.path.map { |part| part.is_a?(Integer) ? part : part.to_s.tr('_', ' ') }.join(' ')
+          message.with(text: "#{label} #{message.text}")
+        end
+      end
+    end
+  end
+end

data/lib/dry/validation/rust/native.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Dry
+  module Validation
+    module Rust
+      # @api private
+      module Native; end
+    end
+  end
+end
+
+begin
+  require 'dry_validation_rust/native'
+rescue LoadError => e
+  source_extension = File.expand_path('../../../../ext/dry_validation_rust/native', __dir__)
+  begin
+    require source_extension
+  rescue LoadError
+    raise LoadError, <<~MESSAGE
+      dry-validation-rust could not load its native extension.
+      Build it with `bundle exec rake compile` (source checkout) or reinstall the gem.
+      Original error: #{e.message}
+    MESSAGE
+  end
+end

data/lib/dry/validation/rust/path.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Dry
+  module Validation
+    module Rust
+      # Normalizes the path forms accepted by dry-validation's public rule API.
+      # @api private
+      module Path
+        module_function
+
+        def parse(spec)
+          case spec
+          when nil then []
+          when Symbol then [spec]
+          when String then spec.split('.').map!(&:to_sym)
+          when Array then spec.dup
+          when Hash
+            key, value = spec.first
+            [key, *parse(value)]
+          else
+            raise ArgumentError, '+spec+ must be a Symbol, String, Array, or Hash'
+          end
+        end
+
+        def expand(spec)
+          return [parse(spec)] unless spec.is_a?(Hash)
+
+          spec.flat_map do |key, value|
+            if value.is_a?(Array)
+              value.map { |child| [key, *parse(child)] }
+            else
+              [[key, *parse(value)]]
+            end
+          end
+        end
+
+        def fetch(data, path, undefined = Undefined)
+          current = data
+          parse(path).each do |key|
+            if current.is_a?(Array) && key.is_a?(Integer)
+              return undefined unless key >= 0 && key < current.length
+
+              current = current[key]
+            elsif current.respond_to?(:key?) && current.key?(key)
+              current = current[key]
+            else
+              return undefined
+            end
+          end
+          current
+        end
+
+        def key?(data, path)
+          !fetch(data, path).equal?(Undefined)
+        end
+
+        def prefix?(candidate, prefix)
+          candidate[0, prefix.length] == prefix
+        end
+
+        Undefined = Object.new.freeze
+      end
+    end
+  end
+end

data/lib/dry/validation/rust/path_trie.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Dry
+  module Validation
+    module Rust
+      class PathTrie
+        TERMINAL = Object.new.freeze
+        private_constant :TERMINAL
+
+        def initialize
+          @root = {}
+        end
+
+        def add(path)
+          node = @root
+          path.each { |part| node = node[part] ||= {} }
+          node[TERMINAL] = true
+        end
+
+        def prefix?(path)
+          return false if path.empty?
+
+          node = @root
+          path.each do |part|
+            return true if node.key?(TERMINAL)
+
+            node = node[part]
+            return false unless node
+          end
+          true
+        end
+
+        def freeze
+          freeze_node(@root)
+          super
+        end
+
+        def ==(other)
+          other.is_a?(self.class) && @root == other.instance_variable_get(:@root)
+        end
+
+        alias eql? ==
+
+        def hash
+          @root.hash
+        end
+
+        private
+
+        def freeze_node(node)
+          node.each_value { |child| freeze_node(child) if child.is_a?(Hash) }
+          node.freeze
+        end
+      end
+    end
+  end
+end

data/lib/dry/validation/rust/result.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'contract/result'

data/lib/dry/validation/rust/rule.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative 'block_keyword_parameters'
+
+module Dry
+  module Validation
+    module Rust
+      class Rule
+        attr_reader :paths, :default_path, :block, :keyword_params, :macro_calls
+
+        def initialize(paths:, default_path: paths.first || [], block: nil)
+          @paths = paths
+          @default_path = default_path
+          assign_block(block)
+          @macro_calls = []
+          @each = false
+        end
+
+        def validate(*macros, &new_block)
+          assign_block(new_block) if new_block
+          @macro_calls = parse_macros(macros)
+          self
+        end
+
+        def each(*macros, &new_block)
+          raise ArgumentError, 'rule.each requires exactly one root key' unless paths.length == 1
+
+          @each = true
+          assign_block(new_block) if new_block
+          @macro_calls = parse_macros(macros)
+          self
+        end
+
+        def each?
+          @each
+        end
+
+        def inspect
+          "#<#{self.class} paths=#{paths.inspect} each=#{each?}>"
+        end
+
+        private
+
+        def assign_block(block)
+          @block = block
+          @keyword_params = block ? BlockKeywordParameters.extract(block) : BlockKeywordParameters::EMPTY
+        end
+
+        def parse_macros(specs)
+          specs.flat_map do |spec|
+            case spec
+            when Hash
+              spec.map { |name, args| [name.to_sym, *Array(args)] }
+            else
+              [[spec.to_sym]]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/validation/rust/schema/dsl.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Dry
+  module Validation
+    module Rust
+      class Schema
+        # @api private
+        class DSL
+          attr_reader :mode, :fields, :before_hooks, :after_hooks
+
+          def initialize(mode:, fields: [], before_hooks: [], after_hooks: [])
+            @mode = mode.to_sym
+            @fields = fields
+            @before_hooks = before_hooks
+            @after_hooks = after_hooks
+          end
+
+          def required(name, &)
+            add_field(name, required: true, &)
+          end
+
+          def optional(name, &)
+            add_field(name, required: false, &)
+          end
+
+          def import(schema)
+            unless schema.is_a?(Schema)
+              raise UnsupportedFeatureError, 'only schemas built by Dry::Validation::Rust can be imported'
+            end
+
+            schema.fields.each do |field|
+              if fields.any? { |existing| existing.name == field.name }
+                raise ArgumentError, "key #{field.name.inspect} is already defined"
+              end
+
+              fields << field.deep_dup
+            end
+            before_hooks.concat(schema.send(:before_hooks))
+            after_hooks.concat(schema.send(:after_hooks))
+            self
+          end
+
+          def before(name, &block)
+            ProcessorHooks.register(before_hooks, name, block)
+            self
+          end
+
+          def after(name, &block)
+            ProcessorHooks.register(after_hooks, name, block)
+            self
+          end
+
+          def compile(validate_keys: false, messages: MessageConfig.new)
+            Schema.new(
+              mode: mode, fields: fields, before_hooks: before_hooks, after_hooks: after_hooks,
+              validate_keys: validate_keys, messages: messages
+            )
+          end
+
+          private
+
+          def add_field(name, required:, &block)
+            raise ArgumentError, "Key +#{name}+ is not a symbol" unless name.is_a?(Symbol)
+            raise ArgumentError, "key #{name.inspect} is already defined" if fields.any? { |field| field.name == name }
+
+            definition = FieldDefinition.new(name: name, required: required)
+            fields << definition
+            builder = FieldBuilder.new(definition, mode: mode)
+            builder.value(&block) if block
+            builder
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/validation/rust/schema/field_builder.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module Dry
+  module Validation
+    module Rust
+      class Schema
+        # @api private
+        class FieldBuilder
+          attr_reader :definition, :mode
+
+          def initialize(definition, mode:)
+            @definition = definition
+            @mode = mode
+          end
+
+          def value(*specs, **predicates, &block)
+            apply_specs(specs, predicates)
+            if block
+              nested_value_block? ? nested_target(block) : PredicateBlock.new(definition).instance_eval(&block)
+            end
+            self
+          end
+
+          def filled(*specs, **predicates, &)
+            definition.filled = true
+            value(*specs, **predicates, &)
+          end
+
+          def maybe(*specs, **predicates, &)
+            definition.nullable = true
+            value(*specs, **predicates, &)
+          end
+
+          def hash(schema = nil, &block)
+            definition.type = :hash
+            nested = DSL.new(mode: mode)
+            nested.import(schema) if schema
+            nested.instance_eval(&block) if block
+            definition.children = nested.fields
+            self
+          end
+
+          def array(member_type = nil, **predicates, &block)
+            definition.type = :array
+            predicates.each { |name, argument| definition.add_predicate(name, argument: argument) }
+
+            if member_type
+              member = FieldDefinition.new(name: nil, required: true)
+              if member_type.is_a?(Schema)
+                member.type = :hash
+                member.children = member_type.fields.map(&:deep_dup)
+              elsif custom_type?(member_type)
+                raise UnsupportedFeatureError,
+                      'custom dry-types array members are not supported by the Ruby fallback yet'
+              else
+                assign_type(member, member_type)
+              end
+              definition.member = member
+            end
+
+            if block
+              definition.member ||= FieldDefinition.new(name: nil, required: true)
+              definition.member.type = :hash
+              nested = DSL.new(mode: mode)
+              nested.instance_eval(&block)
+              definition.member.children = nested.fields
+            end
+            self
+          end
+
+          def each(member_type = nil, **predicates, &)
+            array(member_type, **predicates, &)
+          end
+
+          def method_missing(name, *args, **kwargs, &block)
+            if name.to_s.end_with?('?') && block.nil?
+              argument = if kwargs.empty?
+                           args.length <= 1 ? args.first : args
+                         else
+                           kwargs
+                         end
+              definition.add_predicate(name, argument: argument.nil? || argument)
+              return self
+            end
+
+            super
+          end
+
+          def respond_to_missing?(name, include_private = false)
+            name.to_s.end_with?('?') || super
+          end
+
+          private
+
+          def apply_specs(specs, predicates)
+            remaining = specs.dup
+            assign_type(definition, remaining.shift) if remaining.first && type_spec?(remaining.first)
+
+            remaining.each do |predicate|
+              case predicate
+              when Symbol then definition.add_predicate(predicate)
+              when Hash then predicate.each { |name, argument| definition.add_predicate(name, argument: argument) }
+              else
+                raise UnsupportedFeatureError,
+                      "unsupported type or predicate specification: #{predicate.class.name}"
+              end
+            end
+            predicates.each { |name, argument| definition.add_predicate(name, argument: argument) }
+          end
+
+          def type_spec?(spec)
+            builtin_type?(spec) || custom_type?(spec)
+          end
+
+          def assign_type(target, type)
+            if builtin_type?(type)
+              target.type = type == :datetime ? :date_time : type
+            elsif custom_type?(type)
+              target.type = :any
+              target.ruby_type = type
+            else
+              raise UnsupportedFeatureError,
+                    "unsupported type or predicate specification: #{type.class.name}"
+            end
+          end
+
+          def builtin_type?(type)
+            type.is_a?(Symbol) && TYPES.include?(type)
+          end
+
+          def custom_type?(type)
+            !type.is_a?(Symbol) && type.respond_to?(:try)
+          end
+
+          def nested_value_block?
+            definition.type == :hash || (definition.type == :array && definition.member&.type == :hash)
+          end
+
+          def nested_target(block)
+            if definition.type == :hash
+              nested = DSL.new(mode: mode)
+              nested.instance_eval(&block)
+              definition.children = nested.fields
+            else
+              definition.member ||= FieldDefinition.new(name: nil, required: true)
+              definition.member.type = :hash
+              nested = DSL.new(mode: mode)
+              nested.instance_eval(&block)
+              definition.member.children = nested.fields
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/validation/rust/schema/field_definition.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Dry
+  module Validation
+    module Rust
+      class Schema
+        # @api private
+        class FieldDefinition
+          attr_accessor :name, :required, :nullable, :filled, :type, :member, :ruby_type
+          attr_reader :children, :predicates
+
+          def initialize(name:, required:)
+            @name = name&.to_sym
+            @required = required
+            @nullable = false
+            @filled = false
+            @type = :any
+            @member = nil
+            @ruby_type = nil
+            @children = []
+            @children_by_name = {}
+            @predicates = []
+          end
+
+          def children=(children)
+            @children = children
+            @children_by_name = children.to_h { |child| [child.name, child] }
+          end
+
+          def child_at(name)
+            @children_by_name[name.to_sym]
+          end
+
+          def add_predicate(name, argument: true)
+            normalized_name = name.to_s.delete_suffix('?').to_sym
+            unless (NATIVE_PREDICATES | RUBY_PREDICATES).include?(normalized_name)
+              raise UnsupportedFeatureError,
+                    "predicate #{normalized_name.inspect} is not supported natively; move it to a contract rule"
+            end
+
+            predicates << Predicate.new(name: normalized_name, argument: argument)
+          end
+
+          def to_native_h
+            {
+              name: name&.to_s,
+              required: required,
+              nullable: nullable,
+              filled: filled,
+              type: normalized_type.to_s,
+              member: member&.to_native_h,
+              children: children.map(&:to_native_h),
+              predicates: predicates.filter_map do |predicate|
+                next unless NATIVE_PREDICATES.include?(predicate.name)
+
+                { name: predicate.name.to_s, argument: predicate.argument }
+              end
+            }
+          end
+
+          def normalized_type
+            type == :datetime ? :date_time : type
+          end
+
+          def deep_dup
+            self.class.new(name: name, required: required).tap do |copy|
+              copy.nullable = nullable
+              copy.filled = filled
+              copy.type = type
+              copy.ruby_type = ruby_type
+              copy.member = member&.deep_dup
+              copy.children = children.map(&:deep_dup)
+              predicates.each do |predicate|
+                copy.predicates << predicate.with(argument: duplicate_value(predicate.argument))
+              end
+            end
+          end
+
+          private
+
+          def duplicate_value(value)
+            case value
+            when Array
+              value.map { |item| duplicate_value(item) }
+            when Hash
+              value.each_with_object({}) do |(key, item), copy|
+                copy[duplicate_value(key)] = duplicate_value(item)
+              end
+            else
+              value.dup
+            end
+          rescue TypeError
+            value
+          end
+        end
+      end
+    end
+  end
+end