cargo-pkg-info-struct-builder

OS	Status
Ubuntu-latest
macOS-latest
Windows-latest

A build-time crate that generates a struct (CargoPkgInfo) to provide easy, structured access to your Rust project’s compile-time Cargo environment variables.

Available Metadata Methods

Once generated, the CargoPkgInfo struct provides access to the following metadata:

Overview

At compile time, Cargo sets various environment variables describing your project (version, authors, license, etc.). cargo-pkg-info-struct-builder gathers those variables from your project (not this library) and creates a file, at the path of your choosing, containing a CargoPkgInfo struct.

This struct provides simple, typed methods to retrieve metadata like:

• Version (major, minor, patch, pre-release)
• Authors, description, homepage, and repository
• License information (including file contents)
• Build target and a compile-time build timestamp

Because this happens during the project’s build process, you get project-wide metadata embedded in the final binary—no additional steps required.

Quick Start

Add it as a build dependency:

cargo add cargo-pkg-info-struct-builder --build

Then, in your build.rs:

use cargo_pkg_info_struct_builder::inject_build_metadata;
use std::path::Path;

fn main() {
    // Generate metadata into a Rust file.
    // You can change the path of your choosing, and directories are
    // auto-generated if they do not already exist.
    let dest_path = Path::new("src").join("cargo_pkg_info.rs");
    inject_build_metadata(dest_path.to_path_buf());
}

Now, in your main application:

// Assuming the `dest_path` is used from the above example.
mod cargo_pkg_info;
use cargo_pkg_info::CargoPkgInfo;

fn main() {
    println!(
        "{} v{} (Built on {})",
        CargoPkgInfo::pkg_name(),
        CargoPkgInfo::pkg_version(),
        CargoPkgInfo::build_time_utc().unwrap_or(0),
    );
}

This embeds project metadata into your binary at compile time—runtime environment variables are not used.

Why Compile-Time Injection?

Unlike crates that retrieve package metadata at runtime, this crate:

• Embeds metadata at compile time to avoid file I/O in production.
• Captures the metadata of your project, not the dependency itself.
• Works with any Rust project (including WASM) without requiring Cargo to be installed at runtime.

How It Works

When build.rs runs:

1. It reads package metadata from Cargo environment variables.
2. It generates a Rust source file (cargo_pkg_info.rs) containing a struct with methods that access this metadata.
3. The file is compiled into your project, allowing runtime access to compiled environment info.

This is ideal for logging, debugging, and version tracking in Rust applications.

Notes

The generated file can be committed to version control, but it will remain unchanged unless the template itself is modified. Metadata updates do not change the file itself.

License

Licensed under MIT. See LICENSE for details.