LibMake: Rust Library Scaffold Generator

Buod / Mga Pangunahing Punto

Ang LibMake ⧉ ay isang open-source na Rust CLI tool na naka-install sa pamamagitan ng cargo install libmake na lumilikha ng kumpletong library scaffold mula sa mga CLI flag o config file (TOML, YAML, JSON, o CSV), na may output na sumasaklaw sa Cargo.toml, source, tests, benchmarks, dokumentasyon, at CI sa isang invocation.

Ang nabuong proyekto ay sumusunod sa mga convention ng Rust API Guidelines: mga doc comment sa antas ng module at aytem sa src/lib.rs, #![deny(missing_docs)] sa crate root, at isang README na nakakonekta sa dokumentasyon ng crate sa pamamagitan ng #![doc = include_str!("../README.md")].

Ang config-file mode (--config libmake.toml) ay nagbibigay-daan sa mga koponan na mag-commit ng isang file na ganap na tinutukoy ang kanilang library template — may-akda, lisensya, kategorya, Rust edition, MSRV, URL ng repository — na ginagawang paulit-ulit at maihahambing sa Git ang paglikha ng scaffold.

Ang GitHub Actions workflow na nilikha ng LibMake ay sumusubok sa stable, beta, at nightly na Rust toolchain, nagpapatupad ng clippy -D warnings, sinusuri ang rustfmt, at nagpapatakbo ng cargo-audit para sa mga kilalang CVE sa puno ng dependency.

Ang mga Tera template ay nagpapalakas sa paglikha ng code: ang LibMake ay may kasamang default na hanay ng template ngunit tumatanggap ng custom na direktoryo ng template sa pamamagitan ng --template, kaya ang mga hindi pamantayang layout ng proyekto at karagdagang mga nabuong file ay sinusuportahan nang hindi kailangang i-fork ang tool.

Ang LibMake ⧉ ay isang open-source na Rust CLI at library na lumilikha ng kumpletong scaffold ng library project mula sa isang invocation. Tinutugunan nito ang agwat sa pagitan ng cargo new --lib (na lumilikha lamang ng minimal na Cargo.toml at src/lib.rs) at ng production-ready na pag-setup ng library (na nangangailangan ng manu-manong pagdaragdag ng mga doc comment, CI, mga test harness, istraktura ng benchmark, CONTRIBUTING.md, at mga file ng lisensya).

Inilalarawan ng artikulong ito kung ano ang nililikha ng LibMake, kung paano gumagana ang mga mode ng config-file at CLI, ang nabuong istraktura ng CI, at ang sistema ng template.

Pag-install at Pangunahing Paggamit #

Ang LibMake ay nailathala sa crates.io at naka-install sa pamamagitan ng Cargo:

cargo install libmake

Ang minimal na CLI invocation ay lumilikha ng isang pinangalanang library sa kasalukuyang direktoryo:

libmake \
  --author "Jane Smith" \
  --email "jane@example.com" \
  --name "my_library" \
  --description "A Rust library for doing useful things" \
  --version "0.1.0" \
  --licence "MIT OR Apache-2.0" \
  --repository "https://github.com/example/my_library" \
  --rustversion "1.70.0" \
  --edition "2021" \
  --output "my_library"

Kasama sa mga karagdagang opsyonal na flag ang --categories, --keywords, --homepage, --documentation, --readme, at --build.

Config-File Mode #

Para sa paggamit ng koponan, lahat ng CLI flag ay maaaring ipahayag sa isang TOML config file:

# libmake.toml
author      = "Jane Smith"
email       = "jane@example.com"
name        = "my_library"
description = "A Rust library for doing useful things"
version     = "0.1.0"
licence     = "MIT OR Apache-2.0"
repository  = "https://github.com/example/my_library"
rustversion = "1.70.0"
edition     = "2021"
output      = "my_library"
categories  = ["algorithms", "data-structures"]
keywords    = ["rust", "library"]

Tatawagin bilang:

libmake --config libmake.toml

Tinatanggap din ng LibMake ang mga format ng config na JSON, YAML, at CSV sa pamamagitan ng mga flag na --config-json, --config-yaml, at --config-csv ayon sa pagkakasunod. Ang pag-commit ng libmake.toml sa root ng repository ay nagbibigay sa bawat contributor ng reproducible na scaffold baseline, at ang mga pagbabago sa configuration ng template ay makikita sa mga Git diff.

Nabuong Istraktura ng Proyekto #

Ang isang LibMake invocation ay lumilikha ng sumusunod na layout:

my_library/
├── .github/
│   └── workflows/
│       └── release.yml     # full CI matrix
├── benches/
│   └── lib_benchmarks.rs   # Criterion benchmark stub
├── src/
│   └── lib.rs              # doc-commented, deny(missing_docs)
├── tests/
│   └── lib_tests.rs        # integration test stub
├── CONTRIBUTING.md
├── Cargo.toml              # complete metadata
├── LICENSE-APACHE
├── LICENSE-MIT
└── README.md

Ang nabuong src/lib.rs ay kinabibilangan ng isang crate-level na doc comment, #![deny(missing_docs)], #![doc = include_str!("../README.md")] para makuha ang README sa rustdoc, at isang stub na pampublikong uri na may kasamang doc comment. Ang mga pagpipiliang ito ay sumusunod sa kinakailangan ng Rust API Guidelines na ang lahat ng pampublikong aytem ay may dokumentasyon.

Ang nabuong benches/lib_benchmarks.rs ay gumagamit ng Criterion.rs at nangangailangan ng pagdaragdag ng criterion bilang dev-dependency, na awtomatikong inilalagay ng LibMake sa Cargo.toml.

GitHub Actions CI Workflow #

Ang nabuong .github/workflows/release.yml ay nagpapatakbo ng limang trabaho sa bawat push at pull request:

Trabaho	Toolchain	Ano ang sinusuri
`test`	stable, beta, nightly (matrix)	`cargo test --all-features`
`clippy`	stable	`cargo clippy -- -D warnings`
`fmt`	stable	`cargo fmt --check`
`audit`	stable	`cargo audit` (cargo-audit naka-install sa trabaho)
`doc`	stable	`cargo doc --no-deps` (nabigo sa mga nawawalang docs)

Ang trabahong nightly ay may continue-on-error: true kaya ang isang nightly regression ay hindi nakakahadlang sa mga merge, habang isinasailalim pa rin ang pagkabigo sa workflow run.

Templating gamit ang Tera #

Ginagamit ng LibMake ang Tera template engine — isang Jinja2-like na syntax para sa Rust — para i-render ang lahat ng nabuong file. Ang bawat template ay tumatanggap ng buong config struct bilang context:

{{ name }}            → my_library
{{ author }}          → Jane Smith
{{ edition }}         → 2021
{{ description }}     → A Rust library for doing useful things

Ang mga custom na direktoryo ng template ay sinusuportahan sa pamamagitan ng flag na --template:

libmake --config libmake.toml --template ./my_templates/

Ang custom na direktoryo ay dapat sumasalamin sa default na istraktura ng template (parehong mga filename). Ang anumang file na naroroon sa custom na direktoryo ay nag-o-override sa kaukulang built-in na template; ang mga file na wala sa custom na direktoryo ay gumagamit ng built-in na bersyon. Nagbibigay-daan ito sa mga partial na override — halimbawa, pagpapalit lamang ng CI workflow template habang pinapanatili ang mga default na template ng src/lib.rs at Cargo.toml.

Mga Madalas Itanong #

Paano naiiba ang LibMake mula sa cargo new --lib? Ang cargo new --lib ay lumilikha ng isang minimal na proyekto na may Cargo.toml at src/lib.rs lamang (na naglalaman ng isang #[cfg(test)] na bloke). Ang LibMake ay lumilikha ng buong istraktura — mga integration test, benchmark, CI, CONTRIBUTING.md, mga dual-licence na file, at isang maayos na dokumentadong src/lib.rs — na na-configure sa aktwal na metadata ng proyekto sa halip na mga placeholder.

Maaari bang gamitin ang LibMake sa isang kasalukuyang Cargo workspace? Ang LibMake ay lumilikha ng isang standalone na direktoryo ng crate. Para idagdag ang nabuong crate sa isang kasalukuyang workspace, idagdag ang output path sa members array ng workspace sa root na Cargo.toml. Hindi binabago ng LibMake ang mga kasalukuyang workspace file.

Maaari ko bang i-update ang mga scaffold template pagkatapos ng paunang paglikha? Ang LibMake ay lumilikha ng mga file nang isang beses; hindi nito sinusubaybayan o ina-update ang mga dating nabuong proyekto. Para gamitin ang mga na-update na template, ang inirekomendang paraan ay muling patakbuhin ang LibMake sa isang pansamantalang direktoryo at i-diff ang resulta laban sa kasalukuyang crate, inilalapat ang mga ninanais na pagbabago nang pili.

Anong mga Rust edition at MSRV na halaga ang sinusuportahan ng LibMake? Tinatanggap ng LibMake ang anumang string para sa --edition at --rustversion at direktang isinusulat ang mga halaga sa Cargo.toml. Hindi nito bine-validate kung ang tinukoy na edition o MSRV ay tunay na bersyon ng Rust, kaya ang mga caller ay responsable sa pagbibigay ng tamang mga halaga.

Mga Sanggunian #

Rousseau, S. LibMake — Isang code generator para bawasan ang mga paulit-ulit na gawain at bumuo ng mga mataas na kalidad na Rust library. GitHub, 2023. https://github.com/sebastienrousseau/libmake
The Rust Programming Language. Rust API Guidelines. GitHub, 2023. https://rust-lang.github.io/api-guidelines/
The Cargo Book. Package Layout. The Rust Programming Language, 2023. https://doc.rust-lang.org/cargo/guide/project-layout.html
Keats, V. et al. Tera — Isang template engine na inspirado ng Jinja2 at Django templates. GitHub, 2023. https://keats.github.io/tera/

Huling sinuri 2026-05-24.

Huling sinuri 2026-06-06.