refactor: store embd config per-submodule instead of one root file (#59)

Each embedded folder now gets its own `.embd` file holding exactly
one entry, mirroring how beman-submodule stores a .beman_submodule
file inside each submodule. Drops the name-keyed shared Config in
favor of EmbdEntry::load/save, and drops the now-redundant
metadata.folder field since the file's location is the folder.

status/update now take folder paths instead of names; add checks
for an existing folder/.embd instead of a name collision. Embeds
are discovered by walking the tree for .embd files when no folder
args are given.

Author: ptsouchlos

README.md

@@ -29,7 +29,7 @@ cargo install --path .
 embd add -l <repo link>.git -f <local folder>
 ```
 
-This will clone the repository to the given folder and create an `embd.toml` file in the `.embd` folder. This file tracks both the pinned remote/commit for each embed and the hashes of the files it manages, and should be commited to VCS. You can also filter the contents of the repository using `-i` and `-e` flags. These use glob filters to include or exclude certain folders or files. For example, to exclude all Markdown and include all text files, you could the following:
+This will clone the repository to the given folder and create a `.embd` file inside it. This file tracks both the pinned remote/commit for the embed and the hashes of the files it manages, and should be commited to VCS. You can also filter the contents of the repository using `-i` and `-e` flags. These use glob filters to include or exclude certain folders or files. For example, to exclude all Markdown and include all text files, you could the following:
 
 ```bash
 embd add -l <repo> -f <folder> -i "**.txt" -e "**.md"
@@ -43,7 +43,7 @@ To update all embedded projects, run:
 embd update
 ```
 
-To update a specific project, use the name of the repo. This corresponds to the key of the projects entry in the `.embd/embd.toml` file:
+To update a specific project, use its folder path:
 
 ```bash
 embd update infra
@@ -55,7 +55,7 @@ To update a project to a new commit, tag or branch, use the `-r` or `--rev` flag
 embd update infra --rev abcd1234
 ```
 
-This will update the files on disk and update the commit hash and file manifest tracked for that project in `embd.toml`. Updates can also be forced using `--force` and untracked files can be removed using `--overwrite`. See `embd update -h` for more details.
+This will update the files on disk and update the commit hash and file manifest tracked for that project in its `.embd` file. Updates can also be forced using `--force` and untracked files can be removed using `--overwrite`. See `embd update -h` for more details.
 
 ### Check Status of Embeds
 

docs/design.md

@@ -16,32 +16,25 @@ The general idea is to pull the dependent repository as source into the parent r
 
 ### Commands
 
-| Command  |                 Description                 |                                                                                                                                                 Options                                                                                                                                                 |
-| :------: | :-----------------------------------------: | :-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
-|  `add`   |   Add a new embedded repo to the project.   | `folder`: Specify what subdirectory to put embed in. \n `allow-untracked`: Allow untracked files in the embed directory. \n `link`: The link to the project to include \n `rev`: Specify the commit,tag or branch to pull \n `include`: Glob patterns to include \n `exclude`: Glob patterns to exclude |
-| `update` | Update all embeds to match the config file. |                                          `rev`: Specify the commit, tag or branch to advance to \n `force`: Overwrite any local modification \n `overwrite`: Delete all untracked files (requries `force`) \n `quiet`: Print summaries, not each file updates.                                          |
-| `status` |       Show the status of all embeds.        |                                                                                                                           `quiet`: Should summaries per embed, not per file.                                                                                                                            |
+| Command  |                   Description                   |                                                                                                                                                 Options                                                                                                                                                 |
+| :------: | :---------------------------------------------: | :-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
+|  `add`   |     Add a new embedded repo to the project.     | `folder`: Specify what subdirectory to put embed in. \n `allow-untracked`: Allow untracked files in the embed directory. \n `link`: The link to the project to include \n `rev`: Specify the commit,tag or branch to pull \n `include`: Glob patterns to include \n `exclude`: Glob patterns to exclude |
+| `update` | Update all embeds to match their pinned config. |                                          `rev`: Specify the commit, tag or branch to advance to \n `force`: Overwrite any local modification \n `overwrite`: Delete all untracked files (requries `force`) \n `quiet`: Print summaries, not each file updates.                                          |
+| `status` |         Show the status of all embeds.          |                                                                                                                           `quiet`: Should summaries per embed, not per file.                                                                                                                            |
 
 ### Configuration File
 
-`embd` keeps a single consolidated file, `.embd/embd.toml`, describing all the embedded sources. Each entry has a `metadata` table which includes data like the remote repository URL, commit, folder, and include/exclude filters. The config entry also includes a `files` table of sha256 hashes per tracked file. This is used to detect local drift without having to re-pull or clone files from the remote.
+`embd` stores one configuration file per embed, named `.embd`, inside the embedded folder itself. This mirrors how [beman-submodule](https://github.com/bemanproject/beman-submodule) stores a `.beman_submodule` file inside each submodule it manages. There's no project-wide config file; `embd` discovers embeds by walking the project tree for `.embd` files.
+
+Each file has a `metadata` table with the remote repository URL, commit, and include/exclude filters, plus a `files` table of sha256 hashes per tracked file, used to detect local drift without re-pulling or cloning files from the remote. The embed's folder isn't stored in the file — it's implied by the file's own location.
 
 ```toml
-[repo1.metadata]
+# example/.embd
+[metadata]
 remote = "https://example.git"
 commit_hash = "123abcd1234"
-folder = "example"
 allow_untracked = false
 
-[repo1.files]
+[files]
 "a.txt" = "sha256:..."
-
-[repo2.metadata]
-remote = "https://example2.git"
-commit_hash = "123abcd1234"
-folder = "example2"
-allow_untracked = false
-
-[repo2.files]
-"b.txt" = "sha256:..."
 ```

.embd/embd.toml infra/.embd.embd/embd.toml renamed to infra/.embd

@@ -1,14 +1,13 @@
-[infra.metadata]
+[metadata]
 remote = "git@github.com:ptsouchlos/infra.git"
 commit_hash = "79932afc417d21900038dcd8f8154c3661c15f76"
-folder = "infra"
 allow_untracked = false
 include = [
     "just/**",
     "rust/**",
 ]
 
-[infra.files]
+[files]
 "just/shells.just" = "sha256:ca031066da941b192b18859a4c8ebda1ecfe91ff14f57fe31489c6e83cb3bfa7"
 "rust/just/clippy.just" = "sha256:5ce758826bbd8f4f3ffd626792edb06ab1fe41c591f7cd099c59336c46a1081f"
 "rust/just/format.just" = "sha256:cb2e821139f1e314f5b87e4282bb75524d9d90cdd0dee1eaa524b8fa4b84f762"

src/color.rs

@@ -50,7 +50,7 @@ pub(crate) fn bad(s: &str) -> String {
     s.red().to_string()
 }
 
-/// Bold: entry headers (`name (folder)`).
+/// Bold: entry headers (the embed's folder path).
 pub(crate) fn header(s: &str) -> String {
     s.bold().to_string()
 }

src/commands/add.rs

@@ -4,7 +4,7 @@ use anyhow::{Context, Result, bail};
 use tempfile::tempdir;
 
 use crate::color;
-use crate::config::{self, EmbdEntry, FileLocks, Metadata};
+use crate::config::{EmbdEntry, FileLocks, Metadata};
 use crate::filter::Filter;
 use crate::{filesystem, git, paths};
 
@@ -52,24 +52,22 @@ fn parse_patterns(arg: &Option<String>) -> Vec<String> {
 
 pub(crate) fn execute(args: AddArgs) -> Result<()> {
     let root = paths::find_git_root()?;
-    let config_path = paths::config_path(&root);
     let cwd = std::env::current_dir().context("failed to read current directory")?;
 
     // Validate the link and filter patterns before doing any I/O.
-    let (link, repo_name) = git::parse_repo_link(&args.link)?;
-    let (folder_abs, folder_rel) = paths::resolve_inside_root(&args.folder, &root, &cwd)?;
+    // `_repo_name` is unused: embeds are identified by folder path, not by a
+    // derived repo name, but `parse_repo_link` still validates it.
+    let (link, _repo_name) = git::parse_repo_link(&args.link)?;
+    let (folder_abs, _folder_rel) = paths::resolve_inside_root(&args.folder, &root, &cwd)?;
     let include = parse_patterns(&args.include);
     let exclude = parse_patterns(&args.exclude);
     let filter = Filter::from_patterns(&include, &exclude)?;
 
-    // Load the config, or use a default one
-    let mut config = config::load_or_default(&config_path)?;
-
-    // Check if the config already contains an entry for the given repo.
-    if config.contains(&repo_name) {
+    let config_path = paths::embed_file_path(&folder_abs);
+    if config_path.exists() {
         bail!(
-            "an embed named '{}' already exists in {}",
-            repo_name,
+            "'{}' is already an embed ({} exists)",
+            args.folder.display(),
             config_path.display()
         );
     }
@@ -104,28 +102,26 @@ pub(crate) fn execute(args: AddArgs) -> Result<()> {
         // Hash the destination folder as-copied (not just what the filter
         // allowed) so a pre-existing --allow-untracked folder's contents are
         // reflected too, matching what `copy_dir` actually left on disk.
+        // `.embd` itself is excluded by `filesystem::is_skipped_entry`, so
+        // it never ends up hashing itself.
         let files = FileLocks::build_from_path(&folder_abs)?;
-        config.insert(
-            repo_name.clone(),
-            EmbdEntry {
-                metadata: Metadata {
-                    remote: link,
-                    commit_hash,
-                    folder: folder_rel,
-                    allow_untracked: args.allow_untracked,
-                    include,
-                    exclude,
-                },
-                files,
+        let entry = EmbdEntry {
+            metadata: Metadata {
+                remote: link,
+                commit_hash,
+                allow_untracked: args.allow_untracked,
+                include,
+                exclude,
             },
-        )?;
-        config.save(&config_path)?;
+            files,
+        };
+        entry.save(&config_path)?;
         Ok(())
     })();
 
     if let Err(e) = result {
         // If there was an error, try to rollback to the previous state. Nothing
-        // is written to config.toml unless the whole closure above succeeds, so
+        // is written to disk unless the whole closure above succeeds, so
         // there's no separate on-disk manifest entry to clean up here.
         rollback(&folder_abs, folder_existed, args.allow_untracked);
         // Propagate the error up to the caller

src/commands/common.rs

@@ -1,22 +1,56 @@
-use anyhow::{Context, Result};
+use std::path::{Path, PathBuf};
 
-use crate::config::{Config, EmbdEntry};
+use anyhow::{Context, Result, bail};
 
-/// Resolve a list of user-supplied names to `(name, entry)` pairs. An empty
-/// `names` slice means "all entries, in deterministic order."
-pub(crate) fn select_entries<'a>(
-    config: &'a Config,
-    names: &'a [String],
-) -> Result<Vec<(&'a str, &'a EmbdEntry)>> {
-    if names.is_empty() {
-        return Ok(config.iter().collect());
-    }
-    let mut out = Vec::with_capacity(names.len());
-    for name in names {
-        let entry = config
-            .get(name)
-            .with_context(|| format!("no embed named '{name}' in config"))?;
-        out.push((name.as_str(), entry));
+use crate::color;
+use crate::config::EmbdEntry;
+use crate::paths;
+
+/// Resolve a list of user-supplied folder paths to `(folder, entry)` pairs,
+/// each folder relative to `root`. An empty `folders` slice means "every
+/// embed discovered under `root`, in deterministic (sorted) order."
+pub(crate) fn select_entries(
+    root: &Path,
+    folders: &[String],
+    cwd: &Path,
+) -> Result<Vec<(PathBuf, EmbdEntry)>> {
+    if folders.is_empty() {
+        let discovered = paths::discover_embed_folders(root)?;
+        if discovered.is_empty() && root.join(".embd").is_dir() {
+            bail!(
+                "found a legacy '.embd/' project-level config directory; embd now stores one \
+                 .embd file per embedded folder instead of one file per project. See \
+                 docs/design.md for the new layout, and convert existing entries by hand \
+                 (there is no automated migration)."
+            );
+        }
+
+        let mut out = Vec::new();
+        for folder in discovered {
+            let config_path = paths::embed_file_path(&root.join(&folder));
+            match EmbdEntry::load(&config_path)
+                .context("failed to load embed config found during discovery")
+            {
+                Ok(entry) => out.push((folder, entry)),
+                Err(e) => {
+                    anstream::eprintln!(
+                        "{} skipping '{}': {e:#}",
+                        color::warning_label(),
+                        folder.display()
+                    );
+                }
+            }
+        }
+        Ok(out)
+    } else {
+        let mut out = Vec::with_capacity(folders.len());
+        for folder_arg in folders {
+            let (_, folder_rel) = paths::resolve_inside_root(Path::new(folder_arg), root, cwd)?;
+            let config_path = paths::embed_file_path(&root.join(&folder_rel));
+            let entry = EmbdEntry::load(&config_path)
+                .with_context(|| format!("no embed found at '{folder_arg}'"))?;
+            out.push((folder_rel, entry));
+        }
+        Ok(out)
     }
-    Ok(out)
 }

src/commands/status.rs

@@ -1,4 +1,4 @@
-use anyhow::Result;
+use anyhow::{Context, Result};
 
 use crate::color;
 use crate::commands::common::select_entries;
@@ -7,22 +7,21 @@ use crate::paths;
 
 #[derive(clap::Args, Debug)]
 pub(crate) struct StatusArgs {
-    /// Optional names to check. When empty, all embeds in the config are checked.
-    names: Vec<String>,
+    /// Optional folder paths to check. When empty, every embed in the project is checked.
+    folders: Vec<String>,
     /// Suppress per-file rows; print only one-line summaries per entry.
     #[clap(short, long)]
     quiet: bool,
 }
 
 pub(crate) fn execute(args: StatusArgs) -> Result<()> {
     let root = paths::find_git_root()?;
-    let config_path = paths::config_path(&root);
-    let config = config::load_or_default(&config_path)?;
-    let selected = select_entries(&config, &args.names)?;
+    let cwd = std::env::current_dir().context("failed to read current directory")?;
+    let selected = select_entries(&root, &args.folders, &cwd)?;
 
     let mut any_drift = false;
-    for (name, entry) in selected {
-        let report = config::inspect_entry(&root, name, entry);
+    for (folder, entry) in &selected {
+        let report = config::inspect_entry(&root, folder, entry);
         any_drift |= report.has_drift();
         print_report(&report, args.quiet);
     }
@@ -36,7 +35,7 @@ pub(crate) fn execute(args: StatusArgs) -> Result<()> {
 pub(crate) fn print_report(report: &EntryReport, quiet: bool) {
     use anstream::println;
 
-    let header = color::header(&format!("{} ({})", report.name, report.folder.display()));
+    let header = color::header(&report.folder.display().to_string());
 
     match report.state {
         EntryState::FolderMissing => {