feat: add tag format and default repo to config

Author: dmeijboom

src/cmd/build.rs

@@ -8,10 +8,10 @@ use tokio::{fs, task::JoinSet};
 use crate::{
     builder::{BuildError, MetaBuild},
     config::Config,
+    git,
     image::Image,
     progress,
     registry::{self, PushError, Registry},
-    tag::{self, TagError},
 };
 
 pub mod output {
@@ -41,9 +41,9 @@ pub enum WriteError {
 
 #[derive(Debug, Diagnostic, thiserror::Error)]
 pub enum Error {
-    #[error("failed to tag")]
+    #[error(transparent)]
     #[diagnostic(transparent)]
-    Tag(#[from] TagError),
+    Git(#[from] git::GitError),
     #[error("failed to build")]
     #[diagnostic(transparent)]
     Build(#[from] BuildError),
@@ -80,15 +80,15 @@ pub async fn run(
     repo: Option<String>,
     output_file: Option<&Path>,
 ) -> Result<(), Error> {
-    let tag = tag::resolve().await?;
     let root = progress::tree();
     let handle = progress::setup_line_renderer(&root);
     let insecure_registries = mem::take(&mut config.insecure_registries);
 
+    let (tag, default_repo) = (config.tag_format.clone(), config.default_repo.take());
     let builder = MetaBuild::new(config);
     let output = builder.build(root.add_child("build"), &platform).await?;
 
-    match repo {
+    match repo.or(default_repo) {
         Some(repo) => {
             let mut progress = root.add_child("push");
             progress.init(Some(output.artifacts.len()), None);

src/config.rs

@@ -8,14 +8,21 @@ use miette::Diagnostic;
 use serde::Deserialize;
 use serde_yml::{Mapping, Value};
 
+use crate::git;
+
+const DEFAULT_TAG_FORMAT: &str = "${gitTag:$gitShortCommit}${gitDirty:}";
+
 #[derive(Debug, Deserialize, Clone)]
 #[serde(rename_all = "camelCase")]
 pub struct Config {
-    #[serde(default)]
-    pub insecure_registries: Vec<String>,
     pub build: HashMap<String, Build>,
     #[serde(default)]
     pub deploy: HashMap<String, Release>,
+    #[serde(default)]
+    pub insecure_registries: Vec<String>,
+    pub default_repo: Option<String>,
+    #[serde(default)]
+    pub tag_format: String,
 }
 
 #[derive(Clone, Debug, Deserialize)]
@@ -91,6 +98,8 @@ pub enum ConfigError {
     Subst(#[from] subst::Error),
     #[error("failed to deserialize")]
     Yaml(#[from] serde_yml::Error),
+    #[error("failed to parse git status")]
+    Git(#[from] git::GitError),
     #[error("profile '{0}' does not exist")]
     Profile(String),
 }
@@ -116,25 +125,45 @@ fn template(vars: &HashMap<String, String>, config: Value) -> Result<Value, subs
     }
 }
 
+fn extract_git_vars(state: git::State) -> HashMap<String, String> {
+    let mut vars = HashMap::new();
+
+    vars.insert("gitShortCommit".to_string(), state.commit[0..6].to_string());
+    vars.insert("gitCommit".to_string(), state.commit);
+    if let Some(tag) = state.tag {
+        vars.insert("gitTag".to_string(), tag);
+    }
+    if state.dirty {
+        vars.insert("gitDirty".to_string(), "-dirty".to_string());
+    }
+
+    vars
+}
+
 pub async fn load_from_path(
     profile: Option<&str>,
     path: impl AsRef<Path>,
 ) -> Result<Config, ConfigError> {
+    let mut vars = extract_git_vars(git::state().await?);
     let data = tokio::fs::read(path).await?;
     let mut config = serde_yml::from_slice::<Value>(&data)?;
 
     if let Some(profile) = profile {
-        match config
-            .get_mut("profiles")
-            .and_then(|profiles| profiles.get_mut(profile))
-        {
-            Some(profile) => {
-                let profile = serde_yml::from_value::<Profile>(mem::take(profile))?;
-                config = template(&profile.vars, config)?;
-            }
-            None => return Err(ConfigError::Profile(profile.to_string())),
-        };
+        let profile = serde_yml::from_value::<Profile>(mem::take(
+            config
+                .get_mut("profiles")
+                .and_then(|profiles| profiles.get_mut(profile))
+                .ok_or_else(|| ConfigError::Profile(profile.to_string()))?,
+        ))?;
+
+        vars.extend(profile.vars);
+    }
+
+    let mut config = serde_yml::from_value::<Config>(template(&vars, config)?)?;
+
+    if config.tag_format.is_empty() {
+        config.tag_format = subst::substitute(DEFAULT_TAG_FORMAT, &vars)?;
     }
 
-    Ok(serde_yml::from_value(config)?)
+    Ok(config)
 }

src/tag.rs src/git.rssrc/tag.rs renamed to src/git.rs

@@ -1,32 +1,16 @@
 use std::convert::Infallible;
 
-use gix::{Head, Repository, refs::Category};
+use gix::{Repository, refs::Category};
 use miette::Diagnostic;
 
 #[derive(Debug, Diagnostic, thiserror::Error)]
-pub enum TagError {
+pub enum GitError {
     #[error("failed to open git repository")]
     Open(#[from] gix::open::Error),
     #[error("failed to resolve HEAD reference")]
     FindRef(#[from] gix::reference::find::existing::Error),
     #[error("failed to retrieve dirty status")]
     Dirty(#[from] gix::status::is_dirty::Error),
-    #[error("unable to find tag")]
-    NotFound,
-}
-
-fn parse_name(head: &mut Head<'_>) -> Result<String, TagError> {
-    if let Some(ref_name) = head.referent_name() {
-        if let Some((Category::Tag, name)) = ref_name.category_and_short_name() {
-            return Ok(name.to_string());
-        }
-    }
-
-    if let Ok(commit) = head.peel_to_commit_in_place() {
-        return Ok(commit.id.to_hex_with_len(6).to_string());
-    }
-
-    Err(TagError::NotFound)
 }
 
 // Copied from gix but takes untracked files into account
@@ -62,14 +46,30 @@ fn is_dirty(repo: &Repository) -> Result<bool, gix::status::is_dirty::Error> {
         .is_some())
 }
 
-pub async fn resolve() -> Result<String, TagError> {
+#[derive(Default)]
+pub struct State {
+    pub dirty: bool,
+    pub tag: Option<String>,
+    pub commit: String,
+}
+
+pub async fn state() -> Result<State, GitError> {
     let repo = gix::open(".")?;
     let mut head = repo.head()?;
-    let name = parse_name(&mut head)?;
+    let mut state = State {
+        dirty: is_dirty(&repo)?,
+        ..State::default()
+    };
 
-    if is_dirty(&repo)? {
-        return Ok(format!("{name}-dirty"));
+    if let Some(ref_name) = head.referent_name() {
+        if let Some((Category::Tag, name)) = ref_name.category_and_short_name() {
+            state.tag = Some(name.to_string());
+        }
+    }
+
+    if let Ok(commit) = head.peel_to_commit_in_place() {
+        state.commit = commit.id.to_hex().to_string();
     }
 
-    Ok(name)
+    Ok(state)
 }

src/main.rs

@@ -11,10 +11,10 @@ mod cmd;
 mod config;
 mod deploy;
 mod exec;
+mod git;
 mod image;
 mod progress;
 mod registry;
-mod tag;
 
 #[derive(Parser)]
 struct Opts {
@@ -64,7 +64,7 @@ enum Cmd {
     Run {
         /// OCI registry to use
         #[arg(short, long)]
-        repo: String,
+        repo: Option<String>,
 
         /// Platform selector (e.g. linux/amd64)
         #[arg(long)]
@@ -117,6 +117,8 @@ enum AppError {
     SetCurrentDir(std::io::Error),
     #[error("failed to create temp file")]
     TempFile(#[from] async_tempfile::Error),
+    #[error("no repository specified, either set in config or pass via --repo")]
+    RepoRequired,
 }
 
 impl From<cmd::build::Error> for AppError {
@@ -144,6 +146,7 @@ async fn run(opts: Opts) -> Result<(), AppError> {
             platform,
         } => {
             let config = config::load_from_path(profile.as_deref(), config_path).await?;
+
             cmd::build::run(
                 config,
                 platform.unwrap_or(detected_platform),
@@ -167,10 +170,14 @@ async fn run(opts: Opts) -> Result<(), AppError> {
             let dest = TempFile::new().await?;
             let config = config::load_from_path(profile.as_deref(), config_path).await?;
 
+            if repo.is_none() && config.default_repo.is_none() {
+                return Err(AppError::RepoRequired);
+            }
+
             cmd::build::run(
                 config.clone(),
                 platform.unwrap_or(detected_platform),
-                Some(repo),
+                repo,
                 Some(dest.file_path()),
             )
             .await?;