feat: List images to show, move CLI arguments

Author: Techassi

rust/boil/src/build/bakefile.rs

@@ -123,12 +123,10 @@ impl Targets {
             targets.insert_targets(image_name.to_owned(), pairs, &options, true)?;
         }
 
-        println!("{targets:#?}");
-
         Ok(targets)
     }
 
-    pub fn from_images(images: &[Image], options: TargetsOptions) -> Result<Self, TargetsError> {
+    pub fn set(images: &[Image], options: TargetsOptions) -> Result<Self, TargetsError> {
         let mut targets = Self::default();
 
         for image in images {
@@ -214,9 +212,9 @@ impl Bakefile {
     /// This will only create targets for selected entry images and their dependencies. There is no
     /// need to filter anything out afterwards. The filtering is done automatically internally.
     pub fn from_args(args: &cli::BuildArguments, config: Config) -> Result<Self, Error> {
-        let graph = Targets::from_images(&args.images, TargetsOptions::default())
-            .context(CreateGraphSnafu)?;
-        Self::from_targets(graph, args, config)
+        let targets =
+            Targets::set(&args.images, TargetsOptions::default()).context(CreateGraphSnafu)?;
+        Self::from_targets(targets, args, config)
     }
 
     /// Returns all image manifest URIs for entry images.

rust/boil/src/build/cli.rs

@@ -1,16 +1,14 @@
-use std::path::PathBuf;
+use std::{path::PathBuf, str::FromStr};
 
 use clap::{Args, ValueHint, value_parser};
 use semver::Version;
+use snafu::{ResultExt, Snafu, ensure};
 use url::Host;
 
-use crate::{
-    build::{
-        docker::BuildArgument,
-        image::Image,
-        platform::{Architecture, TargetPlatform},
-    },
-    cli::parse_image_version,
+use crate::build::{
+    docker::BuildArgument,
+    image::Image,
+    platform::{Architecture, TargetPlatform},
 };
 
 #[derive(Debug, Args)]
@@ -124,3 +122,19 @@ impl BuildArguments {
         PathBuf::from("Dockerfile")
     }
 }
+
+#[derive(Debug, Snafu)]
+pub enum ParseImageVersionError {
+    #[snafu(display("failed to parse semantic version"))]
+    ParseVersion { source: semver::Error },
+
+    #[snafu(display("semantic version must not contain build metadata"))]
+    ContainsBuildMetadata,
+}
+
+pub fn parse_image_version(input: &str) -> Result<Version, ParseImageVersionError> {
+    let version = Version::from_str(input).context(ParseVersionSnafu)?;
+    ensure!(version.build.is_empty(), ContainsBuildMetadataSnafu);
+
+    Ok(version)
+}

rust/boil/src/cli.rs

@@ -1,11 +1,8 @@
-use std::{path::PathBuf, str::FromStr};
+use std::path::PathBuf;
 
-use clap::{Args, Parser, Subcommand};
-use clap_complete::Shell;
-use semver::Version;
-use snafu::{ResultExt, Snafu, ensure};
+use clap::{Parser, Subcommand};
 
-use crate::build::cli::BuildArguments;
+use crate::{build::cli::BuildArguments, completions::CompletionsArguments, show::ShowArguments};
 
 #[derive(Debug, Parser)]
 #[command(author, version, about)]
@@ -53,37 +50,3 @@ pub enum Command {
     /// Generate shell completions.
     Completions(CompletionsArguments),
 }
-
-#[derive(Debug, Args)]
-pub struct ShowArguments {
-    #[command(subcommand)]
-    pub commands: ShowCommand,
-}
-
-#[derive(Debug, Subcommand)]
-pub enum ShowCommand {
-    Images,
-    Tree,
-}
-
-#[derive(Debug, Args)]
-pub struct CompletionsArguments {
-    /// Shell to generate completions for.
-    pub shell: Shell,
-}
-
-#[derive(Debug, Snafu)]
-pub enum ParseImageVersionError {
-    #[snafu(display("failed to parse semantic version"))]
-    ParseVersion { source: semver::Error },
-
-    #[snafu(display("semantic version must not contain build metadata"))]
-    ContainsBuildMetadata,
-}
-
-pub fn parse_image_version(input: &str) -> Result<Version, ParseImageVersionError> {
-    let version = Version::from_str(input).context(ParseVersionSnafu)?;
-    ensure!(version.build.is_empty(), ContainsBuildMetadataSnafu);
-
-    Ok(version)
-}

rust/boil/src/completions/mod.rs

@@ -1,6 +1,13 @@
-use clap::CommandFactory;
+use clap::{Args, CommandFactory};
+use clap_complete::Shell;
 
-use crate::cli::{Cli, CompletionsArguments};
+use crate::cli::Cli;
+
+#[derive(Debug, Args)]
+pub struct CompletionsArguments {
+    /// Shell to generate completions for.
+    pub shell: Shell,
+}
 
 pub fn run_command(arguments: CompletionsArguments) {
     let mut cli = Cli::command();

rust/boil/src/main.rs

@@ -3,8 +3,9 @@ use semver::Version;
 use snafu::{ResultExt, Snafu};
 
 use crate::{
-    cli::{Cli, Command, ShowCommand},
+    cli::{Cli, Command},
     config::Config,
+    show::ShowCommand,
 };
 
 // Common modules
@@ -83,7 +84,9 @@ async fn main() -> Result<(), Error> {
             build::run_command(arguments, config).context(BuildSnafu)
         }
         Command::Show(arguments) => match arguments.commands {
-            ShowCommand::Images => show::images::run_command().context(ShowSnafu),
+            ShowCommand::Images(arguments) => {
+                show::images::run_command(arguments).context(ShowSnafu)
+            }
             ShowCommand::Tree => todo!(),
         },
         Command::Completions(arguments) => {

rust/boil/src/show/images.rs

@@ -0,0 +1,13 @@
+use clap::Args;
+
+use crate::build::image::Image;
+
+#[derive(Debug, Args)]
+pub struct ShowImagesArguments {
+    /// Optionally specify one or more images to display.
+    pub image: Vec<Image>,
+
+    /// Pretty print the structured output.
+    #[arg(long)]
+    pub pretty: bool,
+}

rust/boil/src/show/images/cli.rs

@@ -0,0 +1,78 @@
+use std::collections::BTreeMap;
+
+use serde::{Serialize, ser::SerializeSeq};
+use snafu::{ResultExt, Snafu};
+
+use crate::{
+    build::bakefile::{Targets, TargetsError, TargetsOptions},
+    show::images::cli::ShowImagesArguments,
+};
+
+pub mod cli;
+
+#[derive(Debug, Snafu)]
+pub enum Error {
+    #[snafu(display("failed to serialize list as JSON"))]
+    SerializeList { source: serde_json::Error },
+
+    #[snafu(display("failed to build list of targets"))]
+    BuildTargets { source: TargetsError },
+}
+
+// NOTE (@Techassi): I don't know if I like this... but this makes the stdout output very convient
+// to consume.
+struct OneOrMany(BTreeMap<String, Vec<String>>);
+
+impl Serialize for OneOrMany {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        if self.0.len() == 1 {
+            let mut seq = serializer.serialize_seq(Some(1))?;
+            for entry in &self.0 {
+                for version in entry.1 {
+                    seq.serialize_element(&version)?;
+                }
+            }
+
+            Ok(seq.end()?)
+        } else {
+            self.0.serialize(serializer)
+        }
+    }
+}
+
+pub fn run_command(arguments: ShowImagesArguments) -> Result<(), Error> {
+    let list: BTreeMap<_, _> = if arguments.image.is_empty() {
+        Targets::all(TargetsOptions { only_entry: true })
+            .context(BuildTargetsSnafu)?
+            .into_iter()
+    } else {
+        Targets::set(&arguments.image, TargetsOptions { only_entry: true })
+            .context(BuildTargetsSnafu)?
+            .into_iter()
+    }
+    .map(|(image_name, image_versions)| {
+        let versions: Vec<_> = image_versions
+            .into_iter()
+            .map(|(image_version, (_, _))| image_version)
+            .collect();
+        (image_name, versions)
+    })
+    .collect();
+
+    print_to_stdout(list, arguments.pretty)
+}
+
+fn print_to_stdout(list: BTreeMap<String, Vec<String>>, pretty: bool) -> Result<(), Error> {
+    let stdout = std::io::stdout();
+
+    let list = OneOrMany(list);
+
+    if pretty {
+        serde_json::to_writer_pretty(stdout, &list).context(SerializeListSnafu)
+    } else {
+        serde_json::to_writer(stdout, &list).context(SerializeListSnafu)
+    }
+}

rust/boil/src/show/images/mod.rs

@@ -1 +1,17 @@
+use clap::{Args, Subcommand};
+
+use crate::show::images::cli::ShowImagesArguments;
+
 pub mod images;
+
+#[derive(Debug, Args)]
+pub struct ShowArguments {
+    #[command(subcommand)]
+    pub commands: ShowCommand,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum ShowCommand {
+    Images(ShowImagesArguments),
+    Tree,
+}