Update-informer

Update informer for CLI applications written in Rust 🦀

It checks for a new version on Crates.io and GitHub 🚀

Benefits

• Support of Crates.io and GitHub.
• Configurable frequency of checks.
• Minimum dependencies - only ureq, semver and serde.

The idea is actually not new, as GitHub has been doing for a long time in its CLI application.
There is also a popular JavaScript library.

Usage

Add update-informer to Cargo.toml:

toml [dependencies] update-informer = "0.1.0"

To check for a new version on Crates.io, use the check_version function.
This function takes the project name and current version as well as check interval:

```rust use updateinformer::{checkversion, registry::Crates};

if let Ok(Some(version)) = checkversion(Crates, "repo", "0.1.0", Duration::fromsecs(60 * 60 * 24)) { println!("New version is available: {}", version); } ```

Also, you can take the name and version of the project from Cargo using environment variables:

```rust use updateinformer::{checkversion, registry::Crates};

checkversion(Crates, env!("CARGOPKGNAME"), env!("CARGOPKGVERSION"), Duration::fromsecs(60 * 60 * 24)); ```

Note that the first check will start only after the interval has expired:

```rust use updateinformer::{checkversion, registry::Crates};

const EVERYHOUR: Duration = Duration::fromsecs(60 * 60);

checkversion(Crates, "repo", "0.1.0", EVERYHOUR); // The check will start only after an hour ```

To check for a new version on GitHub (note that the project name must contain the owner):

```rust use updateinformer::{checkversion, registry::GitHub};

checkversion(GitHub, "owner/repo", "0.1.0", Duration::fromsecs(60 * 60 * 24)); ```

Example

A real example of using update_informer with colored crate:

```rust use colored::*; use std::time::Duration; use updateinformer::{checkversion, registry::Crates};

fn main() { let pkgname = env!("CARGOPKGNAME"); let currentversion = env!("CARGOPKGVERSION"); let interval = Duration::from_secs(60 * 60 * 24);

if let Ok(Some(version)) = check_version(Crates, pkg_name, current_version, interval) {
    let msg = format!(
        "A new release of {pkg_name} is available: v{current_version} -> {new_version}",
        pkg_name = pkg_name.italic().cyan(),
        current_version = current_version,
        new_version = version.to_string().green()
    );

    let release_url = format!(
        "https://github.com/{pkg_name}/{pkg_name}/releases/tag/{version}",
        pkg_name = pkg_name,
        version = version
    )
        .yellow();

    println!("\n{msg}\n{url}", msg = msg, url = release_url);
}

} ```

The result will look like:

Tests

In order not to check for updates in tests, you can use the stub_check_version function, which returns the desired version.

Example of usage in unit tests:

```rust use std::time::Duration; use update_informer::registry::Crates;

[cfg(not(test))]

let result = updateinformer::checkversion(Crates, "repo", "0.1.0", Duration::from_secs(60 * 60 * 24));

[cfg(test)]

let result = updateinformer::stubcheckversion(Crates, "repo", "0.1.0", Duration::fromsecs(60 * 60 * 24), "1.0.0");

if let Ok(Some(version)) = result { println!("New version is available: {}", version); } ```

To use the stub_check_version function in integration tests, you must first add the feature flag to Cargo.toml:

toml [features] stub_check_version = []

Then use this feature flag in your code and integration tests:

```rust

[cfg(not(feature = "stubcheckversion"))]

let result = updateinformer::checkversion(Crates, "repo", "0.1.0", Duration::from_secs(60 * 60 * 24));

[cfg(feature = "stubcheckversion")]

let result = updateinformer::stubcheckversion(Crates, "repo", "0.1.0", Duration::fromsecs(60 * 60 * 24), "1.0.0"); ```

Sponsors

License

MIT