pbc 0.1.20

gen crate from protobuf
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

use std::{fs, fs::remove_dir_all, io, io::Write, path::Path};

use aok::{Result, OK};
use pb_jelly_gen::GenProtos;
use tempfile::tempdir;
use walkdir::WalkDir;

fn insert_before_first_brace(input: &str, insert: &str) -> String {
  if let Some(pos) = input.find(';') {
    let pos = pos + 1;
    let mut result = String::new();
    result.push_str(&input[..pos]); // 插入 '{' 所在行之前的内容
    result.push_str(insert); // 插入 'xxx'
    result.push_str(&input[pos..]); // 插入 '{' 所在行及之后的内容

    result
  } else {
    // 如果没有 '{'，返回原字符串
    input.to_string()
  }
}

fn rmdir<P: AsRef<std::path::Path>>(path: P) -> io::Result<()> {
  match remove_dir_all(&path) {
    Ok(()) => Ok(()),
    Err(e) if e.kind() == io::ErrorKind::NotFound => Ok(()), // 忽略目录不存在的错误
    Err(e) => Err(e),                                        // 其他错误返回
  }
}

const PROTO: &str = "proto";

pub fn run(workdir: impl AsRef<Path>) -> Result<()> {
  let workdir = workdir.as_ref();

  let dir_rust = workdir.join("rust");
  rmdir(&dir_rust)?;

  let dir_proto = workdir.join("proto");
  if !dir_proto.exists() {
    return OK;
  }
  let dir_tmp = tempdir()?;
  let dir_tmp = dir_tmp.path();

  let mut proto_cargo_toml = ifs::w(workdir.join("pb/Cargo.toml"))?;
  let mut proto_cargo_lib = ifs::w(workdir.join("pb/src/lib.rs"))?;

  let _ = proto_cargo_toml.write(
    br#"[package]
name = "pb"
version = "0.1.0"
edition = "2024"

[workspace]
members = []

[dependencies]
"#,
  )?;

  for fp in WalkDir::new(&dir_proto)
    .into_iter()
    .filter_map(Result::ok)
    .filter(|file| file.path().extension().unwrap_or_default() == PROTO)
  {
    let fp = fp.path();
    let proto = fs::read_to_string(fp)?;
    if let Ok(rel_fp) = fp.strip_prefix(&dir_proto) {
      let rel_fp = rel_fp.to_str().unwrap();
      let crate_name = rel_fp[..rel_fp.len() - 1 - PROTO.len()].as_bytes();

      if crate_name == b"_" {
        let _ = proto_cargo_lib.write(b"pub use proto__::proto__::*;\n");
      } else {
        for i in [
          b"pub mod ",
          crate_name,
          b" {\n  pub use proto_",
          crate_name,
          b"::proto_",
          crate_name,
          b"::*",
          b";\n}\n",
        ] {
          let _ = proto_cargo_lib.write(i)?;
        }
      }

      for i in [
        b"proto_",
        crate_name,
        b" = { path = \"../rust/proto_",
        crate_name,
        b"\" }",
        b"\n",
      ] {
        let _ = proto_cargo_toml.write(i)?;
      }

      let mut li = vec![];
      let mut use_ext = false;
      for i in proto.split('\n') {
        let i = i.trim();
        li.push(i);
        if i.starts_with("enum ") {
          use_ext = true;
          li.push("option (rust.closed_enum) = true;");
        }
      }
      let mut proto = li.join("\n");
      if use_ext {
        proto = insert_before_first_brace(&proto, "import \"rust/extensions.proto\";\n");
      }
      // println!("{}", proto);
      ifs::w(dir_tmp.join(rel_fp))?.write_all(proto.as_bytes())?;
    }
  }

  unsafe { std::env::set_var("CARGO_MANIFEST_DIR", workdir) };

  if let Err(e) = GenProtos::builder()
    .out_path(&dir_rust)
    .src_path(dir_tmp)
    .cleanup_out_path(true)
    .gen_protos()
  {
    eprintln!("{}", e);
    std::process::exit(1);
  }

  rmdir(dir_tmp)?;

  OK
}