tez 0.0.3

A lightweight, ergonomic, and fast high-level HTTP client for Rust
Documentation
//! The human-friendly Tez command-line HTTP client.

#[path = "cli/args.rs"]
mod args;
#[path = "cli/auth.rs"]
mod command_auth;
#[path = "cli/error.rs"]
mod error;
#[path = "cli/item.rs"]
mod item;
#[path = "cli/output.rs"]
mod output;
#[path = "cli/request.rs"]
mod request;
#[path = "cli/session.rs"]
mod session;

use std::{
    io::{IsTerminal as _, Write as _},
    process::ExitCode,
};

use clap::{Parser as _, error::ErrorKind};

use crate::{args::Args, error::Result, output::Output};

fn main() -> ExitCode {
    let args = match Args::try_parse() {
        Ok(args) => args,
        Err(error) => {
            let success = matches!(
                error.kind(),
                ErrorKind::DisplayHelp
                    | ErrorKind::DisplayVersion
                    | ErrorKind::DisplayHelpOnMissingArgumentOrSubcommand
            );
            let _ = error.print();
            return if success {
                ExitCode::SUCCESS
            } else {
                ExitCode::FAILURE
            };
        }
    };

    smol::block_on(run(args))
}

async fn run(args: Args) -> ExitCode {
    match execute(args).await {
        Ok(code) => ExitCode::from(code),
        Err(error) if error.is_broken_pipe() => ExitCode::SUCCESS,
        Err(error) => {
            print_error(&error.to_string());
            ExitCode::from(error.exit_code())
        }
    }
}

async fn execute(args: Args) -> Result<u8> {
    let stdin_is_terminal = std::io::stdin().is_terminal();
    let output = Output::new(&args, std::io::stdout().is_terminal());
    let target = args.target()?;
    let mut session = session::Session::open(&args, &target.url).await?;
    let outcome = request::execute(&args, stdin_is_terminal, &mut session).await?;
    session.save().await?;
    match outcome {
        request::Outcome::Request(request) => {
            output::write_request(request).await?;
            Ok(0)
        }
        request::Outcome::Response {
            response,
            resume_from,
        } => {
            let status = response.status();
            let outcome = output::write(response, &output, resume_from).await?;
            let exit = if outcome == output::WriteOutcome::AlreadyComplete {
                0
            } else {
                output::status_exit(status, args.check_status || args.download)
            };
            Ok(exit)
        }
    }
}

fn print_error(message: &str) {
    let _ = writeln!(std::io::stderr().lock(), "tez: {message}");
}

#[cfg(test)]
mod tests {
    #[test]
    fn cli_errors_are_redacted_by_construction() {
        let error = crate::error::Error::usage("request item is malformed");

        assert_eq!(error.to_string(), "request item is malformed");
        assert!(!format!("{error:?}").contains("secret"));
    }
}