bookmark: show a bookmark's heads; bookmark() in revsets bf3a67819b59

            // A bookmark's heads by name: what a bare bookmark symbol means,

            // without falling through to tags and change prefixes.

            "bookmark" => {

                self.arity(name, args, 1)?;

                let b = self.text_arg(name, args, 0)?;

                let view = self.repo.view()?;

                let st = match view.bookmarks.get(b) {

                    Some(st) => *st,

                    None => match remote_bookmark(&view, b) {

                        Some((_, _, st)) => st,

                        None => return Err(err(format!("bookmark({b}): no such bookmark"))),

                    },

                };

                let heads = self.repo.store().get_state(&st)?.heads;

                self.ensure(&heads)?;

                Ok(heads.into_iter().collect())

            }

#[test]

fn the_bookmark_revset_function_names_only_bookmarks() {

    // oxygen#73: bookmark(NAME) is a bookmark's heads, never a tag or prefix.

    hermetic();

    let dir = tempfile::tempdir().unwrap();

    let repo = Repo::init(dir.path()).unwrap();

    write(dir.path(), "a.txt", b"a\n");

    let a = repo.commit("A", &[]).unwrap();

    write(dir.path(), "b.txt", b"b\n");

    let b = repo.commit("B", &[]).unwrap();

    let mut heads = repo.revset("bookmark(main)").unwrap().hashes;

    heads.sort();

    let mut want = repo.bookmark_heads().unwrap();

    want.sort();

    assert_eq!(heads, want);

    assert!(heads.contains(&b));

    assert_eq!(repo.revset("main").unwrap().hashes.len(), heads.len());

    // A change prefix is a symbol, not a bookmark.

    let prefix = repo.store().get_change_meta(&a).unwrap().change_id.short(8);

    assert!(repo.revset(&prefix).is_ok());

    let e = repo

        .revset(&format!("bookmark({prefix})"))

        .unwrap_err()

        .to_string();

    assert!(e.contains("no such bookmark"), "{e}");

}

oxy bookmark show feature          # each head, newest first (list -v: every bookmark's)

In a revset it means the bookmark's heads (`oxy log -r feature`);

`bookmark(feature)` means only the bookmark, never a tag or change prefix.

| `bookmark(main)`, `bookmark(origin/main)` | the heads of that bookmark only; an error if there is none (a bare name falls through to tags and change prefixes) |

        /// Show the changes a revset selects: `main` (a bookmark name means its

        /// heads; `bookmark(main)` only ever the bookmark), `main..feature &

        /// author(andy)`, `touches("src/**") & date(-7d..)` (see

        /// docs/revset_query_language.md)

        /// Each head of every bookmark, as `bookmark show` prints them

        #[arg(long, short)]

        verbose: bool,

    /// A bookmark's heads: each change nothing else on it depends on,

    /// newest first. A bookmark name is also a revset for its heads

    /// (`oxy log -r NAME`, or `bookmark(NAME)` to mean only the bookmark)

    Show {

        /// The bookmark, or REMOTE/NAME (default: the current one)

        name: Option<String>,

        /// Machine-readable output: one JSON document on stdout

        #[arg(long)]

        json: bool,

    },

            BookmarkCmd::List { all, verbose, json } => {

                workspace::bookmark_list(all, verbose, json)

            }

            BookmarkCmd::Show { name, json } => workspace::bookmark_show(name.as_deref(), json),

/// Heads with their metadata, newest first.

fn heads_newest_first(

    repo: &Repo,

    heads: &[oxy_core::hash::ChangeHash],

) -> Vec<(oxy_core::hash::ChangeHash, oxy_core::state::ChangeMeta)> {

    let mut out: Vec<_> = heads

        .iter()

        .filter_map(|h| repo.store().get_change_meta(h).ok().map(|m| (*h, m)))

        .collect();

    out.sort_by_key(|(_, m)| std::cmp::Reverse(m.hlc));

    out

}

/// One head as a line: id, hash, author, when, subject.

fn print_head(

    repo: &Repo,

    indent: &str,

    h: &oxy_core::hash::ChangeHash,

    m: &oxy_core::state::ChangeMeta,

) {

    println!(

        "{indent}{} {} {}{}{}{}{}",

        ui::id(m.change_id.short(8)),

        ui::dim(format!("#{}", &h.to_hex()[..8])),

        author_name(repo, m),

        ui::sep(),

        ui::dim(ui::ago(m.hlc.wall_ms)),

        ui::sep(),

        ui::subject(subject_of(&m.message))

    );

}

pub fn bookmark_show(name: Option<&str>, as_json: bool) -> Result<i32> {

    let name = name.unwrap_or(&repo.config.bookmark).to_string();

    let view = repo.view()?;

    let st = match view.bookmarks.get(&name) {

        Some(st) => *st,

        None => match oxy_core::repo::remote_bookmark(&view, &name) {

            Some((_, _, st)) => st,

            None => anyhow::bail!("no bookmark {name}: oxy bookmark list --all lists them"),

        },

    };

    let heads = repo.store().get_state(&st)?.heads;

    let shown = heads_newest_first(&repo, &heads);

    if as_json {

        println!(

            "{}",

            json::obj([

                ("name", json::s(&name)),

                ("current", json::b(name == repo.config.bookmark)),

                (

                    "heads",

                    json::arr(shown.iter().map(|(h, m)| {

                        json::obj([

                            ("hash", json::s(&h.to_hex())),

                            ("id", json::s(&m.change_id.to_string())),

                            ("author", json::s(&author_name(&repo, m))),

                            ("time_ms", json::n(m.hlc.wall_ms)),

                            ("subject", json::s(subject_of(&m.message))),

                        ])

                    }))

                ),

            ])

        );

        return Ok(0);

    }

    println!(

        "{} {}{}{}",

        ui::ok(ui::glyph("●", "*")),

        ui::bookmark(&name),

        ui::sep(),

        ui::dim(plural(heads.len(), "head"))

    );

    for (h, m) in &shown {

        print_head(&repo, "  ", h, m);

    }

    if heads.len() > 1 {

        println!(

            "  {}",

            ui::dim("None depends on another: the bookmark is all of them and their dependencies.")

        );

    }

    Ok(0)

}

pub fn bookmark_list(all: bool, verbose: bool, as_json: bool) -> Result<i32> {

    let repo = open()?;

        let shown = heads_newest_first(&repo, &b.heads);

        // The newest head's subject, so a busy bookmark shows its latest work.

        let head = match shown.first() {

            Some(_) if verbose => String::new(),

            Some((_, m)) if b.heads.len() > 1 => format!(

                "{} {}",

                ui::dim("newest"),

                ui::subject(subject_of(&m.message))

            ),

            Some((_, m)) => ui::subject(subject_of(&m.message)),

            None => ui::dim("(empty)"),

        };

        let head = if head.is_empty() {

            head

        } else {

            format!("  {head}")

        };

            "{mark} {}{}{}{tail}{head}",

        if verbose {

            for (h, m) in &shown {

                print_head(&repo, "    ", h, m);

            }

        }