Merge pull request #1085 from itowlson/templates-track-source

Record where templates were installed from

Author: itowlson

crates/templates/src/manager.rs

@@ -125,7 +125,7 @@ impl TemplateManager {
 
         for template_dir in template_dirs {
             let install_result = self
-                .install_one(&template_dir, options, reporter)
+                .install_one(&template_dir, options, source, reporter)
                 .await
                 .with_context(|| {
                     format!("Failed to install template from {}", template_dir.display())
@@ -146,6 +146,7 @@ impl TemplateManager {
         &self,
         source_dir: &Path,
         options: &InstallOptions,
+        source: &TemplateSource,
         reporter: &impl ProgressReporter,
     ) -> anyhow::Result<InstallationResult> {
         let layout = TemplateLayout::new(source_dir);
@@ -179,11 +180,11 @@ impl TemplateManager {
                     ))
                 }
                 ExistsBehaviour::Update => {
-                    copy_template_over_existing(id, source_dir, &dest_dir).await?
+                    copy_template_over_existing(id, source_dir, &dest_dir, source).await?
                 }
             }
         } else {
-            copy_template_into(id, source_dir, &dest_dir).await?
+            copy_template_into(id, source_dir, &dest_dir, source).await?
         };
 
         Ok(InstallationResult::Installed(template))
@@ -237,6 +238,7 @@ async fn copy_template_over_existing(
     id: &str,
     source_dir: &Path,
     dest_dir: &Path,
+    source: &TemplateSource,
 ) -> anyhow::Result<Template> {
     // The nearby directory to which we initially copy the source
     let stage_dir = dest_dir.with_extension(".stage");
@@ -270,7 +272,9 @@ async fn copy_template_over_existing(
 
     // Copy template source into stage directory, and do best effort
     // cleanup if it goes wrong.
-    let copy_to_stage_err = copy_template_into(id, source_dir, &stage_dir).await.err();
+    let copy_to_stage_err = copy_template_into(id, source_dir, &stage_dir, source)
+        .await
+        .err();
     if let Some(e) = copy_to_stage_err {
         let _ = tokio::fs::remove_dir_all(&stage_dir).await;
         return Err(e);
@@ -320,6 +324,7 @@ async fn copy_template_into(
     id: &str,
     source_dir: &Path,
     dest_dir: &Path,
+    source: &TemplateSource,
 ) -> anyhow::Result<Template> {
     tokio::fs::create_dir_all(&dest_dir)
         .await
@@ -340,9 +345,22 @@ async fn copy_template_into(
         )
     })?;
 
+    write_install_record(dest_dir, source);
+
     load_template_from(id, dest_dir)
 }
 
+fn write_install_record(dest_dir: &Path, source: &TemplateSource) {
+    let layout = TemplateLayout::new(dest_dir);
+    let install_record_path = layout.install_record_file();
+
+    // A failure here shouldn't fail the install
+    let install_record = source.to_install_record();
+    if let Ok(record_text) = toml::to_string_pretty(&install_record) {
+        _ = std::fs::write(install_record_path, record_text);
+    }
+}
+
 fn load_template_from(id: &str, dest_dir: &Path) -> anyhow::Result<Template> {
     let layout = TemplateLayout::new(dest_dir);
     Template::load_from(&layout).with_context(|| {

crates/templates/src/reader.rs

@@ -2,7 +2,7 @@ use std::collections::HashMap;
 
 use anyhow::Context;
 use indexmap::IndexMap;
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 
 #[derive(Debug, Deserialize)]
 #[serde(tag = "manifest_version")]
@@ -54,3 +54,15 @@ pub(crate) struct RawCustomFilter {
 pub(crate) fn parse_manifest_toml(text: impl AsRef<str>) -> anyhow::Result<RawTemplateManifest> {
     toml::from_str(text.as_ref()).context("Failed to parse template manifest TOML")
 }
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "snake_case", untagged)]
+pub(crate) enum RawInstalledFrom {
+    Git { git: String },
+    File { dir: String },
+}
+
+pub(crate) fn parse_installed_from(text: impl AsRef<str>) -> Option<RawInstalledFrom> {
+    // If we can't load it then it's not worth an error
+    toml::from_str(text.as_ref()).ok()
+}

crates/templates/src/source.rs

@@ -56,6 +56,24 @@ impl TemplateSource {
             spin_version: spin_version.to_owned(),
         }))
     }
+
+    pub(crate) fn to_install_record(&self) -> Option<crate::reader::RawInstalledFrom> {
+        match self {
+            Self::Git(g) => Some(crate::reader::RawInstalledFrom::Git {
+                git: g.url.to_string(),
+            }),
+            Self::File(p) => {
+                // Saving a relative path would be meaningless (but should never happen)
+                if p.is_absolute() {
+                    Some(crate::reader::RawInstalledFrom::File {
+                        dir: format!("{}", p.display()),
+                    })
+                } else {
+                    None
+                }
+            }
+        }
+    }
 }
 
 pub(crate) struct LocalTemplateSource {

crates/templates/src/store.rs

@@ -77,6 +77,8 @@ const SNIPPETS_DIR_NAME: &str = "snippets";
 
 const MANIFEST_FILE_NAME: &str = "spin-template.toml";
 
+const INSTALLATION_RECORD_FILE_NAME: &str = ".install.toml";
+
 impl TemplateLayout {
     pub fn new(template_dir: impl AsRef<Path>) -> Self {
         Self {
@@ -107,4 +109,8 @@ impl TemplateLayout {
     pub fn snippets_dir(&self) -> PathBuf {
         self.metadata_dir().join(SNIPPETS_DIR_NAME)
     }
+
+    pub fn install_record_file(&self) -> PathBuf {
+        self.template_dir.join(INSTALLATION_RECORD_FILE_NAME)
+    }
 }

crates/templates/src/template.rs

@@ -17,6 +17,7 @@ use crate::{
 pub struct Template {
     id: String,
     description: Option<String>,
+    installed_from: InstalledFrom,
     trigger: TemplateTriggerCompatibility,
     variants: HashMap<TemplateVariantKind, TemplateVariant>,
     parameters: Vec<TemplateParameter>,
@@ -25,6 +26,13 @@ pub struct Template {
     content_dir: Option<PathBuf>, // TODO: maybe always need a spin.toml file in there?
 }
 
+#[derive(Debug)]
+enum InstalledFrom {
+    Git(String),
+    Directory(String),
+    Unknown,
+}
+
 #[derive(Debug, Eq, PartialEq, Hash)]
 enum TemplateVariantKind {
     NewApplication,
@@ -115,10 +123,13 @@ impl Template {
             None
         };
 
+        let installed_from = read_install_record(layout);
+
         let template = match raw {
             RawTemplateManifest::V1(raw) => Self {
                 id: raw.id.clone(),
                 description: raw.description.clone(),
+                installed_from,
                 trigger: Self::parse_trigger_type(raw.trigger_type, layout),
                 variants: Self::parse_template_variants(raw.new_application, raw.add_component),
                 parameters: Self::parse_parameters(&raw.parameters)?,
@@ -152,6 +163,16 @@ impl Template {
         }
     }
 
+    /// A human-readable description of where the template was installed
+    /// from.
+    pub fn installed_from_or_empty(&self) -> &str {
+        match &self.installed_from {
+            InstalledFrom::Git(repo) => repo,
+            InstalledFrom::Directory(path) => path,
+            InstalledFrom::Unknown => "",
+        }
+    }
+
     fn variant(&self, variant_info: &TemplateVariantInfo) -> Option<&TemplateVariant> {
         let kind = variant_info.kind();
         self.variants.get(&kind)
@@ -390,3 +411,14 @@ fn parse_string_constraints(raw: &RawParameter) -> anyhow::Result<StringConstrai
 
     Ok(StringConstraints { regex })
 }
+
+fn read_install_record(layout: &TemplateLayout) -> InstalledFrom {
+    use crate::reader::{parse_installed_from, RawInstalledFrom};
+
+    let installed_from_text = std::fs::read_to_string(layout.install_record_file()).ok();
+    match installed_from_text.and_then(parse_installed_from) {
+        Some(RawInstalledFrom::Git { git }) => InstalledFrom::Git(git),
+        Some(RawInstalledFrom::File { dir }) => InstalledFrom::Directory(dir),
+        None => InstalledFrom::Unknown,
+    }
+}

src/commands/templates.rs

@@ -3,6 +3,7 @@ use std::path::PathBuf;
 use anyhow::{Context, Result};
 use clap::{Parser, Subcommand, ValueEnum};
 use comfy_table::Table;
+use path_absolutize::Absolutize;
 
 use serde::Serialize;
 use spin_templates::{
@@ -87,7 +88,10 @@ impl Install {
             (Some(git), None) => {
                 TemplateSource::try_from_git(git, &self.branch, env!("VERGEN_BUILD_SEMVER"))?
             }
-            (None, Some(dir)) => TemplateSource::File(dir.clone()),
+            (None, Some(dir)) => {
+                let abs_dir = dir.absolutize().map(|d| d.to_path_buf());
+                TemplateSource::File(abs_dir.unwrap_or_else(|_| dir.clone()))
+            }
             _ => anyhow::bail!("Exactly one of `git` and `dir` sources must be specified"),
         };
 
@@ -163,6 +167,10 @@ pub struct List {
     /// The format in which to list the templates.
     #[clap(value_enum, long = "format", default_value = "table", hide = true)]
     pub format: ListFormat,
+
+    /// Whether to show additional template details in the list.
+    #[clap(long = "verbose", takes_value = false)]
+    pub verbose: bool,
 }
 
 #[derive(ValueEnum, Clone, Debug)]
@@ -198,11 +206,21 @@ impl List {
             println!();
         } else {
             let mut table = Table::new();
-            table.set_header(vec!["Name", "Description"]);
+
+            let mut header = vec!["Name", "Description"];
+            if self.verbose {
+                header.push("Installed from");
+            }
+
+            table.set_header(header);
             table.load_preset(comfy_table::presets::ASCII_BORDERS_ONLY_CONDENSED);
 
             for template in templates {
-                table.add_row(vec![template.id(), template.description_or_empty()]);
+                let mut row = vec![template.id(), template.description_or_empty()];
+                if self.verbose {
+                    row.push(template.installed_from_or_empty());
+                }
+                table.add_row(row);
             }
 
             println!("{}", table);