protovalidate 0.1.0.beta1 → 0.1.0.beta3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a731f1825e8edbdc267b0529ab4ed15d0af616bcb2c3baf4140498358e63d383
-  data.tar.gz: c4b4e8306f28c6635a5215e9391348bab07cef66733028c0e6b0f7c245d89027
+  metadata.gz: d67bc65a7ddf2e634a3ae981ae3a514da0bd11e19e07f6ad29be593670117646
+  data.tar.gz: 1037f9d79262c4426840e64a4688619d5a1f3dcb8c19d6f6059b9fd842947207
 SHA512:
-  metadata.gz: a0c3fd528a82ab022359ab0303d7944ffbfce344fc0b6ed87f6eb98d5d1097e2651df3777cbe0e3a8f41290f4d72013f761dbd689fada029b8125a28dceed25d
-  data.tar.gz: 7d47196a549257ef660e702182eedb7ff82391573d0184667f17b5765644287d2048e833a21433bc4726b73f4d4714449068e4b843eec5be40adc84df5576402
+  metadata.gz: cde29cd8ed0e2c74f77cbf2b18c8c6c8ee1d3caaa98f07cd505c642717db122b302aa4901cb2be72a6ef952880fe1d581416d250b4ed048e9502938956e16a80
+  data.tar.gz: d2b45c9e369b02e0d0649960e8524564de93e6edb3efa9a2b7a78bcf1e5a524e55342a32c75b4e9830abdbe26ee5dda4ec6f1b39694d42665ffdbfd2d2312b1f

data/.gitattributes

@@ -0,0 +1,12 @@
+ext/protovalidate/sys/third_party/** linguist-vendored
+
+# script/extract-native-sources
+ext/protovalidate/sys/gen/** linguist-generated
+ext/protovalidate/sys/filelists/*.txt linguist-generated
+
+# rake proto:generate
+lib/buf/validate/validate_pb.rb linguist-generated
+spec/gen/** linguist-generated
+
+# Compiled descriptor set of spec/proto
+spec/fixtures/spec_messages.fdset linguist-generated

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.1.0.beta3 (2026-09-22)
+
+- `Protovalidate.register` and `Validator#register` compile the rules of message types ahead of their first validation, so the compilation, which blocks concurrent validations, can run at boot instead of inside a request. `register_all` does the same for every loaded message class.
+- Validating an already seen message type no longer takes a lock or allocates its type name on the Ruby side.
+
+## 0.1.0.beta2 (2026-09-21)
+
+- Precompiled gems for `x86_64-linux-musl`, `aarch64-linux-musl`, `arm-linux-gnu` and `x64-mingw-ucrt`.
+- Precompiled Linux glibc gems now require glibc 2.34 or newer (was 2.28); older hosts fall back to the source gem.
+
 ## 0.1.0.beta1 (2026-09-20)
 
 - Initial release: `Protovalidate.validate` / `collect_violations` backed by protovalidate-cc 1.2.0 (protovalidate 1.2.2).

data/README.md

@@ -14,8 +14,11 @@ Precompiled gems are published for:
 
 | Platform | Requirements |
 |---|---|
-| `x86_64-linux-gnu`, `aarch64-linux-gnu` | glibc 2.28 or newer |
+| `x86_64-linux-gnu`, `aarch64-linux-gnu` | glibc 2.34 or newer |
+| `arm-linux-gnu` (ARMv7, hard float) | glibc 2.31 or newer |
+| `x86_64-linux-musl`, `aarch64-linux-musl` | musl libc, e.g. Alpine Linux |
 | `arm64-darwin` | macOS 11 or newer |
+| `x64-mingw-ucrt` | RubyInstaller (UCRT) Ruby |
 
 Each covers Ruby 3.3, 3.4 and 4.0. On other platforms or Ruby versions the source gem is built at install time, which needs a Rust toolchain (1.85+), a C++17 compiler and a few minutes: it compiles protovalidate-cc, cel-cpp, abseil, protobuf, re2 and the ANTLR runtime.
 
@@ -74,6 +77,23 @@ All inherit from `Protovalidate::Error` except `ArgumentError`.
 
 A `Validator` compiles the rules of each message type once and caches them, so reuse one instance. Validating from several threads at once is supported and releases the GVL while protovalidate-cc runs. Ractors are not supported.
 
+The rules of a message type are compiled the first time a message of that type is validated, and protovalidate-cc holds an exclusive lock while it compiles, so every concurrent validation on the same validator waits until the compilation finishes. To keep that off the request path, register the message types your application validates at boot, for example from a Rails initializer or before the server forks workers:
+
+```ruby
+Protovalidate.register(Example::User, Example::Order)
+```
+
+`Protovalidate.register_all` registers every message class loaded so far instead of a hand-maintained list, so call it once all generated code has been loaded. In a Rails application, `config.after_initialize` callbacks run in the `finisher_hook` initializer, after the `eager_load!` initializer, so with `config.eager_load` enabled every generated class under an autoload path is already loaded by then. Generated code outside the autoload paths, such as under `lib/`, must be required before the callback runs.
+
+```ruby
+# config/initializers/protovalidate.rb
+Rails.application.config.after_initialize do
+  Protovalidate.register_all if Rails.application.config.eager_load
+end
+```
+
+Types that were not registered still compile on first use, so registration is an optimization rather than a requirement. Both methods raise `Protovalidate::CompilationError` for a rule that does not compile, so a bad rule fails at boot rather than on the first request that reaches it. `register_all` skips message types the engine cannot see, which happens when google-protobuf ships a newer copy of a file compiled into the extension, such as `google/protobuf/descriptor.proto`; those types cannot be validated either way. Once a type is registered, validating it takes no lock on the Ruby side, and the shared validator returned by `Protovalidate.validator` is created once and then read without locking.
+
 ## Development
 
 ```bash
@@ -86,7 +106,7 @@ bundle exec rake steep yard:check rubocop
 
 The native code lives in `ext/protovalidate`: `src/lib.rs` binds `Protovalidate::Native::Engine` with [magnus](https://github.com/matsadler/magnus), and `sys/` compiles protovalidate-cc and its dependencies from git submodules using file lists derived from protovalidate-cc's Bazel build. To move to a new protovalidate-cc release, edit `ext/protovalidate/sys/versions.json`, run `script/extract-native-sources` (needs Bazel), update `PROTOVALIDATE_VERSION` in `lib/protovalidate/version.rb` if the specification version moved, and run `bundle exec rake proto:generate`.
 
-Precompiled gems are assembled by `.github/workflows/native.yml`: Linux builds run inside manylinux_2_28 containers, macOS builds on macos-15, and `rake 'gem:native[PLATFORM]'` packages one gem per platform.
+Precompiled gems are assembled by `.github/workflows/native.yml`: glibc Linux builds run inside manylinux_2_34 containers, macOS builds on macos-15 and Windows builds on windows-2025. musl and 32-bit ARM builds are cross-compiled with `rake cross compile` inside [rb-sys-dock](https://github.com/oxidize-rb/rb-sys) images, with newer cross compilers swapped in. `rake 'gem:native[PLATFORM]'` packages one gem per platform.
 
 ## License
 

data/Rakefile

@@ -14,6 +14,11 @@ Rake::ExtensionTask.new("protovalidate_native") do |ext|
   ext.ext_dir = "ext/protovalidate"
   ext.lib_dir = "lib/protovalidate"
   ext.source_pattern = "{Cargo.toml,Cargo.lock,build.rs,src/**/*.rs,sys/Cargo.toml,sys/build.rs,sys/src/**/*.rs,sys/shim/*,sys/filelists/*.txt}"
+  # Platforms without a native CI runner are cross-compiled inside rb-sys-dock
+  # images (see .github/workflows/native.yml). Given several RUBY_CC_VERSIONs,
+  # `rake cross compile` stages each under tmp/<platform>/stage/lib/protovalidate/<X.Y>/.
+  ext.cross_compile = true
+  ext.cross_platform = %w[x86_64-linux-musl aarch64-linux-musl arm-linux-gnueabihf]
 end
 
 RSpec::Core::RakeTask.new(:spec)

data/ext/protovalidate/src/lib.rs

@@ -6,8 +6,8 @@
 use magnus::Module as _;
 use magnus::Object as _;
 
-/// The engine, shared between Ruby threads. `validate` takes the read lock and
-/// `add_file` the write lock, matching the shim's thread-safety contract.
+/// The engine, shared between Ruby threads. `validate` and `message_type?`
+/// take the read lock; `add_file` and `compile` take the write lock.
 #[magnus::wrap(class = "Protovalidate::Native::Engine", free_immediately)]
 struct Engine {
     inner: std::sync::RwLock<protovalidate_cc_sys::Engine>,
@@ -39,6 +39,37 @@ impl Engine {
             .map_err(|error| crate::to_ruby_error(ruby, error))
     }
 
+    /// Whether the engine knows the named message type.
+    fn message_type(rb_self: &Self, type_name: String) -> bool {
+        let engine = rb_self
+            .inner
+            .read()
+            .unwrap_or_else(std::sync::PoisonError::into_inner);
+        engine.has_message_type(&type_name)
+    }
+
+    /// Compiles the rules of the named type ahead of its first validation.
+    ///
+    /// Compilation inserts into the factory's `flat_hash_map` of rules, and a
+    /// rehash there moves every entry. A concurrent `Validate` holds a pointer
+    /// into that map after releasing the factory's reader lock, so compiling
+    /// under the shared read lock could leave it reading freed memory. The
+    /// write lock keeps validations out until the insert is done.
+    fn compile(
+        ruby: &magnus::Ruby,
+        rb_self: &Self,
+        type_name: String,
+    ) -> Result<(), magnus::Error> {
+        let result = crate::gvl::without_gvl(|| {
+            let engine = rb_self
+                .inner
+                .write()
+                .unwrap_or_else(std::sync::PoisonError::into_inner);
+            engine.compile(&type_name)
+        });
+        result.map_err(|error| crate::to_ruby_error(ruby, error))
+    }
+
     /// Validates a serialized message of the named type, returning serialized
     /// violations or `nil` when it is valid.
     fn validate(
@@ -156,6 +187,8 @@ fn init(ruby: &magnus::Ruby) -> Result<(), magnus::Error> {
     let class = module.define_class("Engine", ruby.class_object())?;
     class.define_singleton_method("new", magnus::function!(Engine::new, 0))?;
     class.define_method("add_file", magnus::method!(Engine::add_file, 1))?;
+    class.define_method("message_type?", magnus::method!(Engine::message_type, 1))?;
+    class.define_method("compile", magnus::method!(Engine::compile, 1))?;
     class.define_method("validate", magnus::method!(Engine::validate, 3))?;
     Ok(())
 }

data/ext/protovalidate/sys/build.rs

@@ -101,6 +101,62 @@ fn read_filelist(path: &Path) -> Vec<String> {
         .collect()
 }
 
+/// Whether the target is Windows with the GNU toolchain (RubyInstaller's).
+fn target_is_mingw() -> bool {
+    env::var("CARGO_CFG_TARGET_OS").as_deref() == Ok("windows")
+        && env::var("CARGO_CFG_TARGET_ENV").as_deref() == Ok("gnu")
+}
+
+/// Whether libstdc++ is linked into the extension rather than loaded at
+/// runtime. musl distributions do not install libstdc++ by default, and on
+/// Windows the MinGW runtime DLLs are not on the PATH Ruby loads from.
+fn link_libstdcxx_statically() -> bool {
+    env::var("CARGO_CFG_TARGET_ENV").as_deref() == Ok("musl") || target_is_mingw()
+}
+
+/// cel-cpp's typeinfo.cc takes `_WIN32` to mean MSVC and demangles with
+/// `type_info::raw_name`, which only MSVC has. MinGW gets a copy that tests
+/// `_MSC_VER` instead and so takes the Itanium ABI path GCC implements.
+fn patch_for_mingw(path: PathBuf) -> PathBuf {
+    if !target_is_mingw() || !path.ends_with("third_party/cel-cpp/common/typeinfo.cc") {
+        return path;
+    }
+    let source =
+        std::fs::read_to_string(&path).unwrap_or_else(|e| panic!("{}: {e}", path.display()));
+    assert_eq!(
+        source.matches("#ifdef _WIN32").count(),
+        2,
+        "{}: the _WIN32 guards moved; revisit patch_for_mingw",
+        path.display(),
+    );
+    let patched =
+        PathBuf::from(env::var("OUT_DIR").expect("OUT_DIR")).join("cel_typeinfo_mingw.cc");
+    std::fs::write(&patched, source.replace("#ifdef _WIN32", "#ifdef _MSC_VER"))
+        .unwrap_or_else(|e| panic!("{}: {e}", patched.display()));
+    patched
+}
+
+/// Lets rustc find an archive that ships with the C++ compiler; rustc
+/// resolves `static=` libraries itself rather than asking the compiler.
+fn add_archive_search_path(compiler: &cc::Tool, archive: &str) {
+    let output = compiler
+        .to_command()
+        .arg(format!("-print-file-name={archive}"))
+        .output()
+        .expect("run the C++ compiler");
+    let path = PathBuf::from(String::from_utf8(output.stdout).expect("utf-8").trim());
+    // An archive the compiler does not know comes back as the bare name.
+    assert!(path.is_absolute(), "the C++ compiler has no {archive}");
+    let dir = path.parent().expect("archive directory");
+    println!("cargo::rustc-link-search=native={}", dir.display());
+}
+
+/// Links an archive that ships with the C++ compiler into the extension.
+fn link_static_archive(compiler: &cc::Tool, name: &str) {
+    add_archive_search_path(compiler, &format!("lib{name}.a"));
+    println!("cargo::rustc-link-lib=static={name}");
+}
+
 /// One static library built from the C++ sources.
 struct CxxLib {
     name: String,
@@ -129,13 +185,16 @@ impl CxxLib {
             build.flag_if_supported("-fvisibility=hidden");
             build.flag_if_supported("-fvisibility-inlines-hidden");
         }
+        if link_libstdcxx_statically() {
+            build.cpp_link_stdlib_static(true);
+        }
         for dir in includes {
             build.include(dir);
         }
 
         let root = manifest_dir();
         for file in read_filelist(&root.join(format!("filelists/{name}.txt"))) {
-            build.file(root.join(file));
+            build.file(patch_for_mingw(root.join(file)));
         }
         Self {
             name: name.to_owned(),
@@ -212,6 +271,27 @@ fn main() {
     antlr4_lib.compile();
     absl_lib.compile();
 
+    let compiler = absl_lib.build.get_compiler();
+    if link_libstdcxx_statically() {
+        add_archive_search_path(&compiler, "libstdc++.a");
+        // MinGW's libstdc++ implements threads on winpthreads, whose DLL is
+        // no more on Ruby's PATH than libstdc++'s.
+        if target_is_mingw() {
+            link_static_archive(&compiler, "winpthread");
+        }
+    }
+    // 32-bit ARM has no 64-bit atomic instructions, so GCC calls out to
+    // libatomic, which distributions do not always install.
+    if env::var("CARGO_CFG_TARGET_ARCH").as_deref() == Ok("arm") {
+        link_static_archive(&compiler, "atomic");
+    }
+
+    // abseil's sysinfo.cc reads the CPU frequency from the registry; bazel
+    // links advapi32 through abseil's linkopts.
+    if env::var("CARGO_CFG_TARGET_OS").as_deref() == Ok("windows") {
+        println!("cargo::rustc-link-lib=advapi32");
+    }
+
     if env::var("CARGO_CFG_TARGET_OS").as_deref() == Ok("macos") {
         println!("cargo::rustc-link-lib=framework=CoreFoundation");
     }

data/ext/protovalidate/sys/shim/pv_shim.cc

@@ -154,6 +154,43 @@ struct pv_engine {
       ABSL_GUARDED_BY(compiled_mutex);
 };
 
+namespace {
+
+const google::protobuf::Descriptor* FindMessageType(pv_engine* engine,
+                                                    absl::string_view name,
+                                                    char** error) {
+  const google::protobuf::Descriptor* descriptor =
+      engine->pool.FindMessageTypeByName(name);
+  if (descriptor == nullptr) {
+    SetError(error, absl::StrCat("unknown message type: ", name));
+  }
+  return descriptor;
+}
+
+// Compiles the rules reachable from `descriptor` unless a previous call
+// already did. Compilation holds protovalidate-cc's own writer lock, so
+// concurrent validations wait for it; only the first call per type pays.
+int EnsureCompiled(pv_engine* engine,
+                   const google::protobuf::Descriptor* descriptor,
+                   char** error) {
+  {
+    absl::ReaderMutexLock lock(&engine->compiled_mutex);
+    if (engine->compiled.contains(descriptor)) return PV_OK;
+  }
+  absl::flat_hash_set<const google::protobuf::Descriptor*> seen;
+  absl::Status compiled =
+      CompileRules(*engine->validator_factory, descriptor, seen);
+  if (!compiled.ok()) {
+    SetError(error, std::string(compiled.message()));
+    return PV_ERR_COMPILATION;
+  }
+  absl::WriterMutexLock lock(&engine->compiled_mutex);
+  engine->compiled.insert(descriptor);
+  return PV_OK;
+}
+
+}  // namespace
+
 extern "C" {
 
 pv_engine* pv_engine_new(char** error) {
@@ -192,33 +229,30 @@ int pv_engine_add_file(pv_engine* engine, const uint8_t* file_descriptor_proto,
   return PV_OK;
 }
 
+int pv_engine_has_message_type(pv_engine* engine, const char* type_name,
+                               size_t type_name_len) {
+  return engine->pool.FindMessageTypeByName(
+             absl::string_view(type_name, type_name_len)) != nullptr;
+}
+
+int pv_engine_compile(pv_engine* engine, const char* type_name,
+                      size_t type_name_len, char** error) {
+  const google::protobuf::Descriptor* descriptor =
+      FindMessageType(engine, absl::string_view(type_name, type_name_len), error);
+  if (descriptor == nullptr) return PV_ERR_ARGUMENT;
+  return EnsureCompiled(engine, descriptor, error);
+}
+
 int pv_engine_validate(pv_engine* engine, const char* type_name,
                        size_t type_name_len, const uint8_t* payload,
                        size_t payload_len, int fail_fast, uint8_t** out,
                        size_t* out_len, char** error) {
   absl::string_view name(type_name, type_name_len);
   const google::protobuf::Descriptor* descriptor =
-      engine->pool.FindMessageTypeByName(name);
-  if (descriptor == nullptr) {
-    SetError(error, absl::StrCat("unknown message type: ", name));
-    return PV_ERR_ARGUMENT;
-  }
-
-  bool known;
-  {
-    absl::ReaderMutexLock lock(&engine->compiled_mutex);
-    known = engine->compiled.contains(descriptor);
-  }
-  if (!known) {
-    absl::flat_hash_set<const google::protobuf::Descriptor*> seen;
-    absl::Status compiled =
-        CompileRules(*engine->validator_factory, descriptor, seen);
-    if (!compiled.ok()) {
-      SetError(error, std::string(compiled.message()));
-      return PV_ERR_COMPILATION;
-    }
-    absl::WriterMutexLock lock(&engine->compiled_mutex);
-    engine->compiled.insert(descriptor);
+      FindMessageType(engine, name, error);
+  if (descriptor == nullptr) return PV_ERR_ARGUMENT;
+  if (int code = EnsureCompiled(engine, descriptor, error); code != PV_OK) {
+    return code;
   }
 
   google::protobuf::Arena arena;

data/ext/protovalidate/sys/shim/pv_shim.h

@@ -60,6 +60,24 @@ void pv_engine_free(pv_engine* engine);
 int pv_engine_add_file(pv_engine* engine, const uint8_t* file_descriptor_proto,
                        size_t len, char** error);
 
+// Returns 1 when the pool knows the fully-qualified message type named by
+// `type_name` and `type_name_len`, 0 otherwise. A type can be missing after
+// its file was added when the file is one compiled into this extension and
+// the caller's copy is newer.
+int pv_engine_has_message_type(pv_engine* engine, const char* type_name,
+                               size_t type_name_len);
+
+// Compiles the rules of the fully-qualified message type named by `type_name`
+// and `type_name_len`, and of every message type reachable from its fields,
+// so that a later pv_engine_validate finds them ready. pv_engine_validate
+// compiles on demand as well; this only moves the work earlier. The name need
+// not be NUL-terminated.
+//
+// Returns PV_OK, PV_ERR_ARGUMENT for an unknown type, or PV_ERR_COMPILATION
+// with a malloc'd message in *error.
+int pv_engine_compile(pv_engine* engine, const char* type_name,
+                      size_t type_name_len, char** error);
+
 // Validates `payload`, a serialized message of the fully-qualified type named
 // by `type_name` and `type_name_len`. The name need not be NUL-terminated:
 // the pool lookup takes a string view, so callers pass their own string

data/ext/protovalidate/sys/src/lib.rs

@@ -28,6 +28,17 @@ unsafe extern "C" {
         len: usize,
         error: *mut *mut c_char,
     ) -> c_int;
+    fn pv_engine_has_message_type(
+        engine: *mut PvEngine,
+        type_name: *const c_char,
+        type_name_len: usize,
+    ) -> c_int;
+    fn pv_engine_compile(
+        engine: *mut PvEngine,
+        type_name: *const c_char,
+        type_name_len: usize,
+        error: *mut *mut c_char,
+    ) -> c_int;
     fn pv_engine_validate(
         engine: *mut PvEngine,
         type_name: *const c_char,
@@ -105,6 +116,33 @@ impl Engine {
         }
     }
 
+    /// Whether the engine's pool knows the message type `type_name`.
+    pub fn has_message_type(&self, type_name: &str) -> bool {
+        unsafe {
+            pv_engine_has_message_type(self.0, type_name.as_ptr().cast::<c_char>(), type_name.len())
+                != 0
+        }
+    }
+
+    /// Compiles the rules of `type_name` and of every message type reachable
+    /// from it, ahead of the first `validate`.
+    pub fn compile(&self, type_name: &str) -> Result<(), PvError> {
+        let mut error: *mut c_char = ptr::null_mut();
+        let code = unsafe {
+            pv_engine_compile(
+                self.0,
+                type_name.as_ptr().cast::<c_char>(),
+                type_name.len(),
+                &raw mut error,
+            )
+        };
+        if code == PV_OK {
+            Ok(())
+        } else {
+            Err(unsafe { status_error(code, error) })
+        }
+    }
+
     /// Validates a serialized message against the rules of `type_name`,
     /// returning the serialized `buf.validate.Violations`, or `None` when the
     /// message is valid.

data/lib/protovalidate/validator.rb

@@ -9,17 +9,57 @@ module Protovalidate
   # type once and caches them, so reuse one instance rather than creating one
   # per validation. Instances may be shared between threads; Ractors are not
   # supported.
+  #
+  # The rules of a message type are compiled the first time it is validated,
+  # and concurrent validations wait while that happens. {#register} moves the
+  # compilation to a time of your choosing, such as application boot.
   class Validator
+    # Every generated message class is a direct subclass of this private
+    # google-protobuf class, so its subclasses are the loaded message classes.
+    MESSAGE_BASE = Google::Protobuf.const_get(:AbstractMessage)
+    private_constant :MESSAGE_BASE
+
     # @param descriptor_pool [Google::Protobuf::DescriptorPool] pool the
     #   validated messages' schema files and their imports are looked up in
     def initialize(descriptor_pool: Google::Protobuf::DescriptorPool.generated_pool)
       @descriptor_pool = descriptor_pool
       @engine = Native::Engine.new
       @registered_files = Set.new
-      @registered_types = Set.new
+      types = {} #: Hash[message_class, String]
+      @types = types.compare_by_identity.freeze
       @registration = Mutex.new
     end
 
+    # Compiles the rules of message classes ahead of their first validation.
+    #
+    # Classes not registered here are still compiled on first use, so this is
+    # an optimization, not a requirement.
+    #
+    # @param message_classes [Array<Class>] message classes generated by google-protobuf
+    # @return [void]
+    # @raise [CompilationError] when the rules of a message type cannot be compiled
+    # @raise [ArgumentError] when an import of a message's file is missing from the pool
+    # @raise [TypeError] when a class is not a Protobuf message class
+    def register(*message_classes)
+      message_classes.each { |klass| type_name_of(klass) }
+      nil
+    end
+
+    # Registers every message class loaded so far whose type is defined in
+    # this validator's descriptor pool. Call it once all generated code has
+    # been loaded, such as after eager loading.
+    #
+    # Types the engine cannot see are skipped: google-protobuf may ship a
+    # newer copy of a file compiled into the extension, such as
+    # descriptor.proto, and the types it added cannot be validated anyway.
+    #
+    # @return [void]
+    # @raise (see #register)
+    def register_all
+      loaded_message_classes.each { |klass| register_class(klass, skip_unknown: true) }
+      nil
+    end
+
     # Validates a message, raising when it is invalid.
     #
     # @param message [Google::Protobuf::MessageExts]
@@ -46,9 +86,8 @@ module Protovalidate
     # @raise [EvaluationError] when a rule fails during evaluation
     # @raise [TypeError] when `message` is not a Protobuf message
     def collect_violations(message, fail_fast: false)
-      descriptor = descriptor_of(message)
-      register(descriptor)
-      serialized = @engine.validate(descriptor.name, message.class.encode(message), fail_fast)
+      type_name = type_name_of(message.class)
+      serialized = @engine.validate(type_name, message.class.encode(message), fail_fast)
       return [] if serialized.nil?
 
       Buf::Validate::Violations.decode(serialized).violations.map do |proto|
@@ -56,24 +95,46 @@ module Protovalidate
       end
     end
 
-    private def descriptor_of(message)
-      klass = message.class
-      unless klass.respond_to?(:descriptor) && klass.descriptor.is_a?(Google::Protobuf::Descriptor)
-        raise TypeError, "expected a Google::Protobuf message, got #{klass}"
-      end
-
-      klass.descriptor
+    # The full name of a message class's type, registering and compiling it on
+    # first sight. Registered classes resolve with one lookup and no lock.
+    private def type_name_of(klass)
+      @types[klass] || register_class(klass)
     end
 
-    private def register(descriptor)
-      return if @registered_types.include?(descriptor.name)
-
+    # @types is replaced with a frozen copy rather than mutated, so a reader
+    # outside the lock never observes a Hash being written to.
+    private def register_class(klass, skip_unknown: false)
+      descriptor = descriptor_of(klass)
       @registration.synchronize do
-        next if @registered_types.include?(descriptor.name)
+        @types[klass] || begin
+          register_file(descriptor.file_descriptor)
+          name = descriptor.name.freeze
+          next if skip_unknown && !@engine.message_type?(name)
+
+          @engine.compile(name)
+          types = @types.dup
+          types[klass] = name
+          @types = types.freeze
+          name
+        end
+      end
+    end
+
+    # Classes generated from other pools are skipped, since their files are
+    # not resolvable against this one.
+    private def loaded_message_classes
+      MESSAGE_BASE.subclasses.select do |klass|
+        descriptor = klass.descriptor
+        @descriptor_pool.lookup(descriptor.name).equal?(descriptor)
+      end
+    end
 
-        register_file(descriptor.file_descriptor)
-        @registered_types << descriptor.name
+    private def descriptor_of(klass)
+      unless klass.is_a?(Google::Protobuf::MessageExts::ClassMethods)
+        raise TypeError, "expected a Google::Protobuf message class, got #{klass.inspect}"
       end
+
+      klass.descriptor
     end
 
     # The engine resolves imports eagerly, so they are added before the importer.

data/lib/protovalidate/version.rb

@@ -2,7 +2,7 @@
 
 module Protovalidate
   # Version of this gem.
-  VERSION = "0.1.0.beta1"
+  VERSION = "0.1.0.beta3"
 
   # Version of the protovalidate specification (buf.validate protos and
   # conformance suite) this gem bundles and is validated against.

data/lib/protovalidate.rb

@@ -32,6 +32,25 @@ module Protovalidate
     validator.validate(message, fail_fast:)
   end
 
+  # Compiles the rules of message classes ahead of their first validation with
+  # the shared validator, for example at application boot.
+  #
+  # @param (see Validator#register)
+  # @return [void]
+  # @raise (see Validator#register)
+  def self.register(*message_classes)
+    validator.register(*message_classes)
+  end
+
+  # Registers every loaded message class of the generated pool with the shared
+  # validator. Call it once all generated code has been loaded.
+  #
+  # @return [void]
+  # @raise (see Validator#register)
+  def self.register_all
+    validator.register_all
+  end
+
   # Collects the violations of a message with the shared validator.
   #
   # @param (see Validator#collect_violations)

data/sig/protovalidate/native.rbs

@@ -6,6 +6,13 @@ module Protovalidate
       # Adds a serialized google.protobuf.FileDescriptorProto to the pool.
       def add_file: (String file) -> void
 
+      # Whether the engine's pool knows the named message type.
+      def message_type?: (String type_name) -> bool
+
+      # Compiles the rules of the named type and of every type reachable from
+      # it, ahead of the first validate.
+      def compile: (String type_name) -> void
+
       # Validates a serialized message of the named type; returns serialized
       # buf.validate.Violations, or nil when the message is valid.
       def validate: (String type_name, String payload, bool fail_fast) -> String?

data/sig/protovalidate.rbs

@@ -11,11 +11,18 @@ module Protovalidate
   # A Protobuf message instance produced by google-protobuf.
   type message = Google::Protobuf::MessageExts
 
+  # A Protobuf message class generated by google-protobuf.
+  type message_class = Google::Protobuf::MessageExts::ClassMethods
+
   # The validator shared by the module-level functions.
   def self.validator: () -> Validator
 
   def self.validate: (message message, ?fail_fast: bool) -> void
 
+  def self.register: (*message_class message_classes) -> void
+
+  def self.register_all: () -> void
+
   def self.collect_violations: (message message, ?fail_fast: bool) -> Array[Violation]
 
   class Error < StandardError
@@ -36,21 +43,33 @@ module Protovalidate
   end
 
   class Validator
+    # google-protobuf's private base class of generated messages, reached with const_get.
+    MESSAGE_BASE: untyped
+
     @descriptor_pool: Google::Protobuf::DescriptorPool
     @engine: Native::Engine
     @registered_files: Set[String]
-    @registered_types: Set[String]
+    # Message class to its full type name, replaced as a whole on registration.
+    @types: Hash[message_class, String]
     @registration: Mutex
 
     def initialize: (?descriptor_pool: Google::Protobuf::DescriptorPool) -> void
 
+    def register: (*message_class message_classes) -> void
+
+    def register_all: () -> void
+
     def validate: (message message, ?fail_fast: bool) -> void
 
     def collect_violations: (message message, ?fail_fast: bool) -> Array[Violation]
 
-    private def descriptor_of: (message message) -> Google::Protobuf::Descriptor
+    private def loaded_message_classes: () -> Array[message_class]
+
+    private def type_name_of: (message_class klass) -> String
+
+    private def register_class: (message_class klass, ?skip_unknown: bool) -> String?
 
-    private def register: (Google::Protobuf::Descriptor descriptor) -> void
+    private def descriptor_of: (message_class klass) -> Google::Protobuf::Descriptor
 
     private def register_file: (Google::Protobuf::FileDescriptor file) -> void
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: protovalidate
 version: !ruby/object:Gem::Version
-  version: 0.1.0.beta1
+  version: 0.1.0.beta3
 platform: ruby
 authors:
 - Sorah Fukumori
@@ -39,7 +39,7 @@ dependencies:
         version: 0.9.130
 description: Ruby implementation of protovalidate. Validates Protobuf messages against
   the buf.validate rules in their schema, evaluated with CEL by protovalidate-cc through
-  a native extension. Precompiled gems are published for Linux and macOS.
+  a native extension. Precompiled gems are published for Linux, macOS and Windows.
 email:
 - sorah@ivry.jp
 executables: []
@@ -47,6 +47,7 @@ extensions:
 - ext/protovalidate/extconf.rb
 extra_rdoc_files: []
 files:
+- ".gitattributes"
 - ".yardopts"
 - CHANGELOG.md
 - LICENSE.txt