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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178

//! Code generator for copra RPC framework
//!
//! This crate provides one function [`run`], which can generate service provider
//! templates and client side stubs from `.proto` files. The best place to use
//! this function is the `build.rs` file. For more information about `build.rs`,
//! please refer to the [build scripts] section of the official cargo book.
//!
//! [`run`]: fn.run.html
//! [build scripts]: https://doc.rust-lang.org/cargo/reference/build-scripts.html
//!
//! # Examples
//!
//! Say, we have a `awesome.proto` file in the project root directory (i.e. next
//! to `Cargo.toml`), and we want to generate rust code in `src/generated`.
//! We can add this to `build.rs`:
//!
//! ```no_run
//! extern crate protoc_rust_copra;
//!
//! fn main() {
//!     protoc_rust_copra::run(protoc_rust_copra::Args {
//!         out_dir: "src/generated",
//!         input: &["awesome.proto"],
//!         includes: &[],
//!         rust_protobuf: true
//!     }).expect("Failed to compile proto files");
//! }
//! ```
//!
//! # Acknowledgment
//!
//! The crate is a mirror of [protoc-rust-grpc].
//!
//! [protoc-rust-grpc]: https://crates.io/crates/protoc-rust-grpc

#![warn(missing_docs, missing_debug_implementations)]

extern crate inflector;
#[macro_use]
extern crate log;
extern crate protobuf;
extern crate protoc;
extern crate protoc_rust;
extern crate tempdir;

mod codegen;

use std::io;
use std::io::Read;
use std::io::Write;
use std::fs;

#[derive(Debug, Default)]
/// Argument passed to `run`
pub struct Args<'a> {
    /// where to put generated files
    pub out_dir: &'a str,
    /// dependency to other .proto files
    pub includes: &'a [&'a str],
    /// List of .proto files to compile
    pub input: &'a [&'a str],
    /// Generate rust-protobuf files along with copra
    ///
    /// Set this value to `false` to only generate service boilerplates and RPC
    /// stubs.
    pub rust_protobuf: bool,
}

/// Generate rust code
pub fn run(args: Args) -> io::Result<()> {
    let protoc = protoc::Protoc::from_env_path();
    let version = protoc.version().expect("protoc version");
    if !version.is_3() {
        panic!("protobuf must have version 3");
    }

    if args.rust_protobuf {
        protoc_rust::run(protoc_rust::Args {
            out_dir: args.out_dir,
            includes: args.includes,
            input: args.input,
        })?;
    }

    let temp_dir = tempdir::TempDir::new("protoc-rust")?;
    let temp_file = temp_dir.path().join("descriptor.pbbin");
    let temp_file = temp_file.to_str().expect("utf-8 file name");

    protoc.write_descriptor_set(protoc::DescriptorSetOutArgs {
        out: temp_file,
        includes: args.includes,
        input: args.input,
        include_imports: true,
    })?;

    let mut fds = Vec::new();
    let mut file = fs::File::open(temp_file)?;
    file.read_to_end(&mut fds)?;

    drop(file);
    drop(temp_dir);

    let fds: protobuf::descriptor::FileDescriptorSet =
        protobuf::parse_from_bytes(&fds).map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;

    let mut includes = args.includes;
    if includes.is_empty() {
        static DOT_SLICE: &'static [&'static str] = &["."];
        includes = DOT_SLICE;
    }

    let mut files_to_generate = Vec::new();
    'outer: for file in args.input {
        for include in includes {
            if let Some(truncated) = remove_path_prefix(file, include) {
                files_to_generate.push(truncated.to_owned());
                continue 'outer;
            }
        }

        return Err(io::Error::new(
            io::ErrorKind::Other,
            format!(
                "file {:?} is not found in includes {:?}",
                file, args.includes
            ),
        ));
    }

    let gen_result = codegen::gen(fds.get_file(), &files_to_generate)?;

    for r in gen_result {
        let r: protobuf::compiler_plugin::GenResult = r;
        let file = format!("{}/{}", args.out_dir, r.name);
        let mut file = fs::File::create(&file)?;
        file.write_all(&r.content)?;
        file.flush()?;
    }

    Ok(())
}

fn remove_dot_slash(path: &str) -> &str {
    if path == "." {
        ""
    } else if path.starts_with("./") || path.starts_with(".\\") {
        &path[2..]
    } else {
        path
    }
}

fn remove_path_prefix<'a>(mut path: &'a str, mut prefix: &str) -> Option<&'a str> {
    path = remove_dot_slash(path);
    prefix = remove_dot_slash(prefix);

    if prefix == "" {
        return Some(path);
    }

    if prefix.ends_with("/") || prefix.ends_with("\\") {
        prefix = &prefix[..prefix.len() - 1];
    }

    if !path.starts_with(prefix) {
        return None;
    }

    if path.len() <= prefix.len() {
        return None;
    }

    if path.as_bytes()[prefix.len()] == b'/' || path.as_bytes()[prefix.len()] == b'\\' {
        return Some(&path[prefix.len() + 1..]);
    } else {
        return None;
    }
}