Line data    Source code

       1              : mod badge;
       2              : mod coverage_badge_command;
       3              : mod git_info;
       4              : mod publish_command;
       5              : mod release;
       6              : mod release_metadata;
       7              : mod release_version;
       8              : mod remote_access;
       9              : mod remote_paths;
      10              : mod serde_date;
      11              : mod serde_version;
      12              : #[cfg(test)]
      13              : mod test_s3;
      14              : mod vacuum_command;
      15              : 
      16              : use anyhow::Result;
      17              : use clap::{Parser, Subcommand};
      18              : use coverage_badge_command::{coverage_badge, CoverageBadgeArgs};
      19              : use publish_command::{publish, PublishArgs};
      20              : use std::env;
      21              : use vacuum_command::{vacuum, VacuumArgs};
      22              : 
      23              : /// Publish and clean up DashQL native app releases
      24              : #[derive(Parser, Debug)]
      25              : #[command(version, about, long_about = None)]
      26              : struct Cli {
      27              :     /// The subcommand to run
      28              :     #[command(subcommand)]
      29              :     command: CliCommand,
      30              : }
      31              : 
      32              : #[derive(Subcommand, Debug)]
      33              : enum CliCommand {
      34              :     Version,
      35              :     Publish(PublishArgs),
      36              :     Vacuum(VacuumArgs),
      37              :     CoverageBadge(CoverageBadgeArgs),
      38              : }
      39              : 
      40            2 : fn print_version(source_dir: &std::path::Path) -> Result<()> {
      41            2 :     let git_repo = git_info::collect_git_info(&source_dir.to_path_buf())?;
      42            1 :     println!("{}", &git_repo.version.as_semver());
      43            1 :     Ok(())
      44            2 : }
      45              : 
      46              : #[::tokio::main]
      47            0 : async fn main() -> Result<()> {
      48              :     // Setup the logger
      49            0 :     if env::var("RUST_LOG").is_err() {
      50            0 :         env::set_var("RUST_LOG", "info")
      51            0 :     }
      52            0 :     env_logger::init();
      53              : 
      54              :     // Parse arguments
      55            0 :     let args = Cli::try_parse()?;
      56              : 
      57            0 :     let source_dir = {
      58            0 :         if let Ok(dir) = std::env::var("BUILD_WORKSPACE_DIRECTORY") {
      59            0 :             let path = std::path::PathBuf::from(&dir);
      60            0 :             if path.exists() { path } else { std::env::current_dir()? }
      61              :         } else {
      62            0 :             std::env::current_dir()?
      63              :         }
      64              :     };
      65              : 
      66            0 :     match args.command {
      67            0 :         CliCommand::Version => print_version(&source_dir)?,
      68            0 :         CliCommand::Publish(args) => publish(args).await?,
      69            0 :         CliCommand::Vacuum(args) => vacuum(args).await?,
      70            0 :         CliCommand::CoverageBadge(args) => coverage_badge(args)?,
      71              :     };
      72            0 :     Ok(())
      73            0 : }
      74              : 
      75              : #[cfg(test)]
      76              : mod tests {
      77              :     use super::*;
      78              : 
      79              :     #[test]
      80            1 :     fn parses_the_subcommands() {
      81            1 :         assert!(matches!(Cli::try_parse_from(["pack", "version"]).unwrap().command, CliCommand::Version));
      82            1 :         assert!(matches!(Cli::try_parse_from(["pack", "vacuum", "--dry-run"]).unwrap().command, CliCommand::Vacuum(_)));
      83            1 :         assert!(matches!(
      84            1 :             Cli::try_parse_from(["pack", "coverage-badge", "a.dat", "b.dat", "--output", "badge.svg"]).unwrap().command,
      85              :             CliCommand::CoverageBadge(_)
      86              :         ));
      87            1 :         assert!(Cli::try_parse_from(["pack", "coverage-badge", "--output", "badge.svg"]).is_err());
      88            1 :         assert!(Cli::try_parse_from(["pack"]).is_err());
      89            1 :         assert!(Cli::try_parse_from(["pack", "unknown"]).is_err());
      90            1 :     }
      91              : 
      92              :     #[test]
      93            1 :     fn publish_needs_every_artifact() {
      94            1 :         assert!(Cli::try_parse_from(["pack", "publish", "--source-dir", "."]).is_err());
      95            1 :     }
      96              : 
      97              :     #[test]
      98            1 :     fn prints_the_version_of_a_repository() {
      99            1 :         let dir = test_s3::TempDir::new();
     100            1 :         test_s3::git_repository(dir.path(), "v1.2.3", 0);
     101            1 :         print_version(dir.path()).unwrap();
     102            1 :         let empty = test_s3::TempDir::new();
     103            1 :         assert!(print_version(empty.path()).is_err());
     104            1 :     }
     105              : }