proc_use is a Rust crate to help semi-dynamically import crates and modules.
All logic is ran at compile time, mostly contained in build.rs.
In what scenario is this crate useful? Say you have the following directory structure:
project
├─Cargo.toml
├─build.rs
└─src
├─main.rs
├─core
│ └─core.rs
└─util
├─foo.rs
├─bar.rs
└─baz.rs
You find yourself often adding new files to util and including them in core.rs.
The way to do this under vanilla Rust is like this:
```rust
// main.rs
mod foo;
mod bar;
mod baz;
rust
// core.rs
use foo::;
use bar::;
use baz::*;
Of course there are slightly cleaner ways to do this to avoid `#[path]` but that's more
work. And you need to edit multiple files every time you add a new util.
Annoying! This is where `proc_use` comes in. The above can be replaced with:
rust
// core.rs
include!(concat!(env!("OUTDIR"), "/procuse.rs"));
rust
// build.rs
use proc_use::UseBuilder;
use std::env;
use std::path::PathBuf;
fn main() {
let outpath = PathBuf::from(env::var("OUTDIR").unwrap());
UseBuilder::new()
.useglob("src/util/*.rs", "*".into())
.writetofileall(outpath.join("procuse.rs"));
}
``
That's more code up front, but now the mod and use process is automatic.
Add as many Rust files toutilas you desire; theuse_glob` method will
pick up and import all of them.
To see an example using this directory structure, see
globbing.