Merge branch 'master' of github.com:stepancheg/rust-protobuf into patch-stack

Author: Snow Pettersen

.gitignore

@@ -11,7 +11,7 @@ src/test/v*/pb_*.rs
 src/test/v*/*_pb.rs
 src/test/lib
 protobuf-bin-gen-rust
-protoc-gen-rust
+protoc-gen-rs
 target/
 Cargo.lock
 .idea

CHANGELOG.md

@@ -1,8 +1,19 @@
 # Changelog
 
-## [3.6] - Unreleased
+## Unreleased
 
-## [3.5.1] - Unreleased
+## [3.7.1] - Unrelease
+
+- `protoc-gen-rust` renamed to `protoc-gen-rs`. `protoc --rust_out=` no longer works with latest Google protobuf,
+  they are working on official protobuf support for Rust.
+- Do not detect nightly in `protobuf` crate (no longer needed)
+- [Repeated fields in constants](https://github.com/stepancheg/rust-protobuf/pull/740)
+
+## [3.6.0] - 2024-09-30
+
+- [Fix text format parsing of non-ASCII](https://github.com/stepancheg/rust-protobuf/pull/730)
+
+## [3.5.1] - 2024-08-19
 
 - [Remove deprecated `box_pointers` lint](https://github.com/stepancheg/rust-protobuf/pull/733)
 

Cargo.toml

@@ -24,3 +24,6 @@ members = [
     "test-crates/protobuf-test",
     "test-crates/protobuf-test-common",
 ]
+
+[workspace.dependencies]
+protoc-bin-vendored = "=3.1.0"

protobuf-codegen/Cargo.toml

@@ -9,7 +9,7 @@ repository = "https://github.com/stepancheg/rust-protobuf/"
 description = """
 Code generator for rust-protobuf.
 
-Includes a library to invoke programmatically (e. g. from `build.rs`) and `protoc-gen-rust` binary.
+Includes a library to invoke programmatically (e. g. from `build.rs`) and `protoc-gen-rs` binary.
 """
 
 [lib]
@@ -27,8 +27,8 @@ protobuf-parse = { path = "../protobuf-parse", version = "=4.0.0-alpha.0" }
 
 [[bin]]
 
-name = "protoc-gen-rust"
-path = "src/bin/protoc-gen-rust.rs"
+name = "protoc-gen-rs"
+path = "src/bin/protoc-gen-rs.rs"
 test = false
 
 [package.metadata.docs.rs]

protobuf-codegen/README.md

@@ -7,14 +7,14 @@ This crate is useful mostly from `build.rs` scripts to generate `.rs` files duri
 # How to generate code
 
 There are three main ways to generate `.rs` files from `.proto` files:
-* using `protoc` command line tool and `protoc-gen-rust` plugin
+* using `protoc` command line tool and `protoc-gen-rs` plugin
 * using this crate `Codegen` with pure rust parser
 * using this crate `Codegen` with `protoc` parser
 
 Which one should you use depends on your needs.
 
 If you are using non-cargo build system (like Bazel), you might prefer
-using `protoc-gen-rust` plugin for `protoc`.
+using `protoc-gen-rs` plugin for `protoc`.
 
 If you build with `cargo`, you probably want to use `Codegen` from this crate.
 
@@ -54,12 +54,12 @@ protobuf_codegen::Codegen::new()
     .run_from_script();
 ```
 
-## How to use `protoc-gen-rust`
+## How to use `protoc-gen-rs`
 
 If you have to.
 
 (Note `protoc` can be invoked programmatically with
-[protoc crate](https://docs.rs/protoc/%3E=3.0.0-alpha))
+[protoc crate](https://docs.rs/protoc/))
 
 0) Install protobuf for `protoc` binary.
 
@@ -78,11 +78,11 @@ apt-get install protobuf-compiler
 Protobuf is needed only for code generation, `rust-protobuf` runtime
 does not use C++ protobuf library.
 
-1) Install `protoc-gen-rust` program (which is `protoc` plugin)
+1) Install `protoc-gen-rs` program (which is `protoc` plugin)
 
 It can be installed either from source or with `cargo install protobuf-codegen` command.
 
-2) Add `protoc-gen-rust` to $PATH
+2) Add `protoc-gen-rs` to $PATH
 
 If you installed it with cargo, it should be
 
@@ -93,7 +93,7 @@ PATH="$HOME/.cargo/bin:$PATH"
 3) Generate .rs files:
 
 ```sh
-protoc --rust_out . foo.proto
+protoc --rs_out . foo.proto
 ```
 
 This will generate .rs files in current directory.

protobuf-codegen/src/bin/protoc-gen-rs.rs

@@ -0,0 +1,3 @@
+fn main() {
+    protobuf_codegen::protoc_gen_rs::protoc_gen_rust_main();
+}

protobuf-codegen/src/bin/protoc-gen-rust.rs

@@ -34,7 +34,7 @@ enum CodegenError {
 
 /// Entry point for `.proto` to `.rs` code generation.
 ///
-/// This is similar to `protoc --rust_out...`.
+/// This is similar to `protoc --rs_out...`.
 #[derive(Debug, Default)]
 pub struct Codegen {
     /// What parser to use to parse `.proto` files.
@@ -208,8 +208,8 @@ impl Codegen {
 
     /// Invoke the code generation.
     ///
-    /// This is roughly equivalent to `protoc --rust_out=...` but
-    /// without requiring `protoc-gen-rust` command in `$PATH`.
+    /// This is roughly equivalent to `protoc --rs_out=...` but
+    /// without requiring `protoc-gen-rs` command in `$PATH`.
     ///
     /// This function uses pure Rust parser or `protoc` parser depending on
     /// how this object was configured.

protobuf-codegen/src/codegen/mod.rs

@@ -168,7 +168,7 @@ impl Customize {
     /// So the generated code (and more importantly, generated binary size) is smaller,
     /// but reflection, text format, JSON serialization won't work.
     ///
-    /// Note when using `protoc` plugin `protoc-gen-rust`, the option name is just `lite`.
+    /// Note when using `protoc` plugin `protoc-gen-rs`, the option name is just `lite`.
     pub fn lite_runtime(mut self, lite_runtime: bool) -> Self {
         self.lite_runtime = Some(lite_runtime);
         self

protobuf-codegen/src/customize/mod.rs

@@ -146,7 +146,7 @@ impl<'a> MessageGen<'a> {
             .collect()
     }
 
-    fn required_fields(&'a self) -> Vec<&'a FieldGen> {
+    fn required_fields(&'a self) -> Vec<&'a FieldGen<'a>> {
         self.fields
             .iter()
             .filter(|f| match f.kind {
@@ -156,14 +156,14 @@ impl<'a> MessageGen<'a> {
             .collect()
     }
 
-    fn message_fields(&'a self) -> Vec<&'a FieldGen> {
+    fn message_fields(&'a self) -> Vec<&'a FieldGen<'a>> {
         self.fields
             .iter()
             .filter(|f| f.proto_type == field_descriptor_proto::Type::TYPE_MESSAGE)
             .collect()
     }
 
-    fn fields_except_oneof(&'a self) -> Vec<&'a FieldGen> {
+    fn fields_except_oneof(&'a self) -> Vec<&'a FieldGen<'a>> {
         self.fields
             .iter()
             .filter(|f| match f.kind {
@@ -173,14 +173,14 @@ impl<'a> MessageGen<'a> {
             .collect()
     }
 
-    fn fields_except_group(&'a self) -> Vec<&'a FieldGen> {
+    fn fields_except_group(&'a self) -> Vec<&'a FieldGen<'a>> {
         self.fields
             .iter()
             .filter(|f| f.proto_type != field_descriptor_proto::Type::TYPE_GROUP)
             .collect()
     }
 
-    fn fields_except_oneof_and_group(&'a self) -> Vec<&'a FieldGen> {
+    fn fields_except_oneof_and_group(&'a self) -> Vec<&'a FieldGen<'a>> {
         self.fields
             .iter()
             .filter(|f| match f.kind {