dry-validation-rust 0.1.0.pre5

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Dry
+  module Validation
+    module Rust
+      class Schema
+        # @api private
+        class PredicateBlock
+          ARITY_MAP = {
+            gt: 1, gteq: 1, lt: 1, lteq: 1, min_size: 1, max_size: 1, size: 1,
+            format: 1, included_in: 1, excluded_from: 1, eql: 1, not_eql: 1,
+            odd: 0, even: 0
+          }.freeze
+
+          def initialize(definition)
+            @definition = definition
+          end
+
+          def method_missing(name, *args, **kwargs, &block)
+            if name.to_s.end_with?('?') && block.nil?
+              validate_arity(name, args, kwargs)
+              argument = if kwargs.empty?
+                           args.length <= 1 ? args.first : args
+                         else
+                           kwargs
+                         end
+              @definition.add_predicate(name, argument: argument.nil? || argument)
+              return self
+            end
+
+            raise UnsupportedFeatureError,
+                  "unsupported predicate composition expression: #{name.inspect}"
+          end
+
+          def respond_to_missing?(name, include_private = false)
+            name.to_s.end_with?('?') || super
+          end
+
+          private
+
+          def validate_arity(name, args, kwargs)
+            normalized_name = name.to_s.delete_suffix('?').to_sym
+            expected = ARITY_MAP[normalized_name]
+            return unless expected
+
+            argument_count = args.length + (kwargs.empty? ? 0 : 1)
+            return if argument_count == expected
+
+            article = expected == 1 ? 'exactly one argument' : 'no arguments'
+            raise ArgumentError, "#{name} expects #{article}, got #{argument_count}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Dry
+  module Validation
+    module Rust
+      class Schema
+        # @api private
+        class ProcessorHooks
+          STAGES = %i[value_coercer].freeze
+
+          def self.deep_dup(value)
+            case value
+            when Hash
+              value.each_with_object({}) do |(key, item), copy|
+                copy[deep_dup(key)] = deep_dup(item)
+              end
+            when Array
+              value.map { |item| deep_dup(item) }
+            else
+              value.dup
+            end
+          rescue TypeError
+            value
+          end
+
+          def self.register(hooks, name, block)
+            unless STAGES.include?(name)
+              raise ArgumentError, "Undefined step name #{name.inspect}. Available names: #{STAGES.inspect}"
+            end
+            raise ArgumentError, 'processor hooks require a block' unless block
+
+            hooks << block
+          end
+
+          def self.apply(hooks, data)
+            hooks.each do |hook|
+              replacement = hook.call(data)
+              data = replacement if replacement.is_a?(Hash)
+            end
+            data
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Dry
+  module Validation
+    module Rust
+      class Schema
+        Result = Data.define(:output, :messages, :error_prefixes) do
+          class << self
+            alias_method :build, :new
+            private :build
+
+            # Creates a structural validation result and caches its schema-error path index.
+            #
+            # @param output [Hash] coerced schema output
+            # @param messages [Array<Message>] schema validation failures
+            # @return [Result] immutable schema validation result
+            def new(output = nil, messages = nil, **kwargs)
+              unknown = kwargs.keys - %i[output messages]
+              unless unknown.empty?
+                raise ArgumentError,
+                      "unknown keyword#{'s' if unknown.length > 1}: #{unknown.map(&:inspect).join(', ')}"
+              end
+
+              output = kwargs.fetch(:output) if kwargs.key?(:output)
+              messages = kwargs.fetch(:messages) if kwargs.key?(:messages)
+              prefixes = PathTrie.new
+              messages.each { |message| prefixes.add(message.path) }
+
+              build(output, messages, prefixes.freeze)
+            end
+          end
+
+          # Returns the immutable schema-error path index.
+          #
+          # @return [PathTrie] cached schema-error path index
+
+          alias_method :to_h, :output
+
+          def success?
+            messages.empty?
+          end
+
+          def failure?
+            !success?
+          end
+
+          def errors(options = {})
+            MessageSet.new(messages, options).with(options)
+          end
+
+          def error?(spec)
+            path = Path.parse(spec)
+            messages.any? { |message| Path.prefix?(message.path, path) }
+          end
+
+          def [](key)
+            output[key]
+          end
+
+          def key?(key)
+            output.key?(key)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Dry
+  module Validation
+    module Rust
+      class Schema
+        # @api private
+        class RubyTypeProcessor
+          def self.apply(definitions, data, messages, message_backend)
+            error_paths = messages.to_set(&:path)
+            apply_at(definitions, data, [], messages, error_paths, message_backend)
+          end
+
+          def self.apply_at(definitions, data, prefix, messages, error_paths, message_backend)
+            return unless data.is_a?(Hash)
+
+            definitions.each do |field|
+              next unless data.key?(field.name)
+
+              path = [*prefix, field.name]
+              if field.ruby_type && !error_paths.include?(path)
+                result = field.ruby_type.try(data[field.name])
+                data[field.name] = result.input
+                unless result.success?
+                  messages << Message.new(
+                    text: message_backend.message(
+                      code: :type, predicate: nil, args: [], type: field.type, fallback: 'is invalid'
+                    ),
+                    path: path, code: :type, source: :schema
+                  )
+                  error_paths << path
+                end
+              end
+
+              apply_at(field.children, data[field.name], path, messages, error_paths, message_backend)
+            end
+          end
+
+          private_class_method :apply_at
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,323 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'date'
+require 'time'
+require 'bigdecimal'
+require_relative 'generated_predicates'
+
+module Dry
+  module Validation
+    module Rust
+      # A compiled schema that validates and coerces input hashes.
+      #
+      # @example Define and call a schema
+      #   schema = Dry::Validation::Rust::Schema.Params do
+      #     required(:age).value(:integer)
+      #   end
+      #   result = schema.call("age" => "25")
+      #   result.to_h # => { age: 25 }
+      class Schema
+        # Type symbols supported by schema fields.
+        #
+        # @return [Array<Symbol>]
+        TYPES = %i[
+          any nil bool true false integer float decimal string symbol array hash
+          date date_time datetime time
+        ].freeze
+        # @api private
+        Predicate = Data.define(:name, :argument) do
+          def initialize(name:, argument: true)
+            super(name: name.to_s.delete_suffix('?').to_sym, argument: argument)
+          end
+        end
+      end
+
+      require_relative 'schema/result'
+      require_relative 'schema/processor_hooks'
+      require_relative 'schema/field_definition'
+      require_relative 'schema/predicate_block'
+      require_relative 'schema/field_builder'
+      require_relative 'schema/ruby_type_processor'
+      require_relative 'schema/dsl'
+
+      class Schema
+        # @return [Symbol] the schema input mode.
+        attr_reader :mode
+
+        # @api private
+        # @return [Array<FieldDefinition>] the compiled top-level field definitions.
+        attr_reader :fields
+
+        # @api private
+        # @return [Native::Engine] the native engine that executes this schema.
+        attr_reader :engine
+
+        # Builds a schema from a DSL block and optional schemas to import.
+        #
+        # @param mode [Symbol] the input mode, such as `:schema`, `:params`, or `:json`.
+        # @param external_schemas [Array<Schema>] compiled schemas whose fields are imported.
+        # @yield the schema DSL block.
+        # @return [Schema] the compiled schema.
+        def self.define(mode = :schema, *external_schemas, &block)
+          dsl = DSL.new(mode: mode)
+          external_schemas.each { |schema| dsl.import(schema) }
+          dsl.instance_eval(&block) if block
+          dsl.compile
+        end
+
+        # Builds a schema that coerces web request parameter input.
+        #
+        # @param external_schemas [Array<Schema>] compiled schemas whose fields are imported.
+        # @yield the schema DSL block.
+        # @return [Schema] the compiled params-mode schema.
+        def self.Params(*external_schemas, &) = define(:params, *external_schemas, &)
+
+        # Builds a schema that coerces JSON-compatible input.
+        #
+        # @param external_schemas [Array<Schema>] compiled schemas whose fields are imported.
+        # @yield the schema DSL block.
+        # @return [Schema] the compiled JSON-mode schema.
+        def self.JSON(*external_schemas, &) = define(:json, *external_schemas, &)
+
+        # Compiles field definitions into a native schema plan.
+        #
+        # @api private
+        #
+        # @param mode [Symbol] the input mode.
+        # @param fields [Array<FieldDefinition>] field definitions to compile.
+        # @param before_hooks [Array<#call>] processors run before native validation.
+        # @param after_hooks [Array<#call>] processors run after native validation.
+        # @param validate_keys [Boolean] whether unknown keys are validation errors.
+        # @param messages [MessageConfig] validation message configuration.
+        # @raise [NativeExtensionError] if the native schema plan cannot be compiled.
+        def initialize(mode:, fields:, before_hooks: [], after_hooks: [], validate_keys: false,
+                       messages: MessageConfig.new)
+          @mode = mode.to_sym
+          @fields = fields.freeze
+          @fields_by_name = fields.to_h { |field| [field.name, field] }.freeze
+          @has_ruby_predicates = ruby_predicates?(fields)
+          @before_hooks, @after_hooks = [before_hooks, after_hooks].map { _1.dup.freeze }
+          @message_backend = messages.backend_class.new(messages)
+          begin
+            plan = {
+              engine_version: ENGINE_VERSION,
+              mode: mode.to_s,
+              validate_keys: validate_keys,
+              fields: fields.map(&:to_native_h)
+            }
+            @engine = Native::Engine.new(JSON.generate(plan, max_nesting: false))
+          rescue StandardError => e
+            raise NativeExtensionError, "could not compile native schema plan: #{e.message}"
+          end
+        end
+
+        # Validates and coerces a Hash.
+        #
+        # @param input [Hash] input to validate.
+        # @return [Result] the output and validation messages.
+        # @raise [ArgumentError] if +input+ is not a Hash.
+        def call(input)
+          raise ArgumentError, "Input must be a Hash. #{input.class} was given." unless input.is_a?(Hash)
+
+          # Before hooks receive an isolated copy and may safely mutate nested values.
+          prepared_input = before_hooks.empty? ? input.dup : ProcessorHooks.deep_dup(input)
+          prepared_input = ProcessorHooks.apply(before_hooks, prepared_input)
+          result = engine.call(prepared_input)
+          output = ProcessorHooks.apply(after_hooks, result.output)
+          messages = result.errors.map do |error|
+            path = error[:path]
+            code = error[:code]
+            text = error[:text]
+            predicate, args = native_predicate_details(path, code)
+            native_message(path, code, text, predicate, args)
+          end
+          RubyTypeProcessor.apply(fields, output, messages, @message_backend)
+          apply_ruby_predicates(fields, output, [], messages) if @has_ruby_predicates
+          Result.new(output, messages.freeze)
+        end
+
+        # Validates and coerces a Hash.
+        #
+        # Alias for {#call}.
+        #
+        # @param input [Hash] input to validate.
+        # @return [Result] the output and validation messages.
+        # @raise [ArgumentError] if +input+ is not a Hash.
+        def [](input)
+          call(input)
+        end
+
+        # Returns all declared field paths, including nested array paths.
+        #
+        # @api private
+        #
+        # @return [Array<Array<Symbol, Integer>>] declared field paths. Array members
+        #   use +:__index__+ as an index placeholder.
+        def key_paths
+          paths_for(fields)
+        end
+
+        # Returns a diagnostic representation of this compiled schema.
+        #
+        # @return [String] the schema mode, field names, and native-engine marker.
+        def inspect
+          "#<#{self.class} mode=#{mode.inspect} fields=#{fields.map(&:name).inspect} native=true>"
+        end
+
+        private
+
+        attr_reader :before_hooks, :after_hooks
+
+        # @api private
+        def native_message(path, code, text, predicate, args)
+          Message.new(
+            text: native_error_message(code, text, predicate, args, path),
+            path: path, code: code, source: :schema, predicate: predicate, args: args
+          )
+        end
+
+        # @api private
+        def native_error_message(code, native_text, predicate, args, path)
+          field = field_at_path(path)
+          @message_backend.message(
+            code: code, predicate: predicate&.to_s&.delete_suffix('?'), args: args,
+            type: field&.normalized_type, fallback: native_text
+          )
+        end
+
+        # @api private
+        def paths_for(definitions, prefix = [])
+          definitions.flat_map do |field|
+            current = [*prefix, field.name]
+            nested = paths_for(field.children, current)
+            member_nested = field.member ? paths_for(field.member.children, [*current, :__index__]) : []
+            [current, *nested, *member_nested]
+          end
+        end
+
+        # @api private
+        def ruby_predicates?(definitions)
+          definitions.any? do |field|
+            field.predicates.any? { |predicate| !NATIVE_PREDICATES.include?(predicate.name) } ||
+              ruby_predicates?(field.children) ||
+              (field.member && ruby_predicates?([field.member]))
+          end
+        end
+
+        # @api private
+        def apply_ruby_predicates(definitions, data, prefix, messages)
+          error_paths = messages.to_set(&:path)
+          apply_ruby_predicates_at(definitions, data, prefix, messages, error_paths)
+        end
+
+        # @api private
+        def apply_ruby_predicates_at(definitions, data, prefix, messages, error_paths)
+          stack = [[:definitions, definitions, data, prefix]]
+
+          until stack.empty?
+            kind, *arguments = stack.pop
+            case kind
+            when :definitions
+              current_definitions, current_data, current_prefix = arguments
+              next unless current_data.is_a?(Hash)
+
+              current_definitions.reverse_each do |field|
+                stack << [:field, field, current_data, current_prefix]
+              end
+            when :field
+              field, current_data, current_prefix = arguments
+              next unless current_data.key?(field.name)
+
+              path = [*current_prefix, field.name]
+              value = current_data[field.name]
+              apply_ruby_predicates_to(field, value, path, messages, error_paths)
+
+              if value.is_a?(Hash)
+                stack << [:definitions, field.children, value, path]
+              elsif value.is_a?(Array) && field.member
+                value.each_index.reverse_each do |index|
+                  stack << [:member, field.member, value[index], [*path, index]]
+                end
+              end
+            when :member
+              member, value, path = arguments
+              apply_ruby_predicates_to(member, value, path, messages, error_paths)
+              stack << [:definitions, member.children, value, path]
+            end
+          end
+        end
+
+        # @api private
+        def apply_ruby_predicates_to(field, value, path, messages, error_paths)
+          return if error_paths.include?(path)
+
+          field.predicates.each do |predicate|
+            next if NATIVE_PREDICATES.include?(predicate.name)
+
+            unless predicate_valid?(predicate, value)
+              messages << predicate_message(predicate, path)
+              error_paths << path
+            end
+          end
+        end
+
+        # @api private
+        def predicate_valid?(predicate, value)
+          case predicate.name
+          when :format then value.respond_to?(:match?) && predicate.argument.match?(value)
+          when :included_in then predicate.argument.include?(value)
+          when :excluded_from then !predicate.argument.include?(value)
+          when :eql then value.eql?(predicate.argument)
+          when :not_eql then !value.eql?(predicate.argument)
+          else
+            raise UnsupportedFeatureError,
+                  "predicate #{predicate.name.inspect} is not supported natively; move it to a contract rule"
+          end
+        end
+
+        # @api private
+        def predicate_message(predicate, path)
+          text = case predicate.name
+                 when :format then 'is in invalid format'
+                 when :included_in then "must be one of: #{Array(predicate.argument).join(', ')}"
+                 when :excluded_from then "must not be one of: #{Array(predicate.argument).join(', ')}"
+                 when :eql then "must be equal to #{predicate.argument}"
+                 when :not_eql then "must not be equal to #{predicate.argument}"
+                 else 'is invalid'
+                 end
+          text = @message_backend.message(
+            code: predicate.name, predicate: predicate.name, args: [predicate.argument], type: nil, fallback: text
+          )
+          Message.new(
+            text: text, path: path, code: predicate.name, source: :schema,
+            predicate: "#{predicate.name}?", args: [predicate.argument]
+          )
+        end
+
+        def native_predicate_details(path, code)
+          field = field_at_path(path)
+          predicate = field&.predicates&.find { |candidate| candidate.name == code.to_sym }
+          predicate ? [:"#{predicate.name}?", [predicate.argument]] : [nil, []]
+        end
+
+        def field_at_path(path)
+          definition = nil
+
+          path.each do |part|
+            if part.is_a?(Integer)
+              return nil unless definition&.member
+
+              definition = definition.member
+            else
+              definition = definition ? definition.child_at(part) : @fields_by_name[part.to_sym]
+              return nil unless definition
+            end
+          end
+
+          definition
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Dry
+  module Validation
+    module Rust
+      VERSION = '0.1.0.pre5'
+      ENGINE_VERSION = 1
+    end
+  end
+end

data/lib/dry/validation/rust.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative 'rust/version'
+require_relative 'rust/errors'
+require_relative 'rust/native'
+require_relative 'rust/path'
+require_relative 'rust/path_trie'
+require_relative 'rust/message'
+require_relative 'rust/message_set'
+require_relative 'rust/contract/values'
+require_relative 'rust/macros'
+require_relative 'rust/failures'
+require_relative 'rust/message_backend'
+require_relative 'rust/config'
+require_relative 'rust/schema'
+require_relative 'rust/rule'
+require_relative 'rust/evaluator'
+require_relative 'rust/contract/result'
+require_relative 'rust/contract'
+
+module Dry
+  module Validation
+    module Rust
+      class << self
+        # @api private
+        def global_macros
+          @global_macros ||= MacroRegistry.new
+        end
+
+        def register_macro(name, *, &)
+          global_macros.register(name, *, &)
+          self
+        end
+
+        def Contract(options = {}, &)
+          Contract.build(options, &)
+        end
+
+        def load_extensions(*names)
+          names.each do |name|
+            next if name.to_sym == :predicates_as_macros
+
+            raise UnsupportedFeatureError,
+                  "extension #{name.inspect} is not implemented in the experimental Rust compatibility layer"
+          end
+          self
+        end
+      end
+
+      register_macro(:acceptance) do
+        key.failure(:acceptance) unless value.equal?(true)
+      end
+    end
+  end
+end

data/lib/dry/validation.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative 'validation/rust'
+
+module Dry
+  if const_defined?(:Schema, false) &&
+     !const_get(:Schema, false).const_defined?(:RUST_COMPATIBILITY_LAYER, false)
+    raise LoadError, <<~MESSAGE
+      dry-schema and dry-validation-rust cannot both own Dry::Schema in exact compatibility mode.
+      Remove the upstream dry-schema/dry-validation gems, or use the side-by-side
+      dry/validation/rust namespace.
+    MESSAGE
+  end
+
+  unless const_defined?(:Schema, false)
+    module Schema
+      RUST_COMPATIBILITY_LAYER = true
+      VERSION = Validation::Rust::VERSION
+
+      class << self
+        def Params(*external_schemas, &)
+          Validation::Rust::Schema.Params(*external_schemas, &)
+        end
+
+        def JSON(*external_schemas, &)
+          Validation::Rust::Schema.JSON(*external_schemas, &)
+        end
+
+        def define(*external_schemas, &)
+          Validation::Rust::Schema.define(:schema, *external_schemas, &)
+        end
+      end
+    end
+  end
+
+  module Validation
+    if const_defined?(:Contract, false) && const_get(:Contract, false) != Rust::Contract
+      raise LoadError, <<~MESSAGE
+        dry-validation and dry-validation-rust cannot both own Dry::Validation::Contract.
+        Remove the upstream dry-validation gem when using exact compatibility mode, or
+        require "dry/validation/rust" and inherit from Dry::Validation::Rust::Contract.
+      MESSAGE
+    end
+
+    Contract = Rust::Contract unless const_defined?(:Contract, false)
+    Result = Rust::Contract::Result unless const_defined?(:Result, false)
+    Message = Rust::Message unless const_defined?(:Message, false)
+    MessageSet = Rust::MessageSet unless const_defined?(:MessageSet, false)
+    Evaluator = Rust::Evaluator unless const_defined?(:Evaluator, false)
+    VERSION = Rust::VERSION unless const_defined?(:VERSION, false)
+
+    class << self
+      def Contract(options = {}, &)
+        Rust.Contract(options, &)
+      end
+
+      def register_macro(name, *, &)
+        Rust.register_macro(name, *, &)
+      end
+
+      def load_extensions(*names)
+        Rust.load_extensions(*names)
+      end
+    end
+  end
+end

data/lib/dry-schema.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'dry/schema'

data/lib/dry-validation.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'dry/validation'

data/lib/dry_validation_rust.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'dry/validation/rust'