A default bookmark must exist: settings refuse a missing one, the overview stands in main with a note, an unknown name is not a bookmark, tag or change; Bookmarks › New bookmark makes one on the web (closes #345) 351cf57e5608

- **A default bookmark must exist, and bookmarks are made on the web (#345).** Settings refused nothing, so a default named before it existed (doomsdayone/tetriblox's `develop`) left the repository's pages saying `"develop" is not a change`. Settings now refuse a new default that is not a bookmark (an empty repository may name any, for its first push) and list those that are; a missing default leaves the overview showing main, or the first bookmark, with a note; an unknown name is "not a bookmark, tag or change of this repository". Bookmarks › New bookmark makes one from a bookmark, tag or change, as the user's delegate or, without a trust policy, unsigned as a push would be, so a proposal can then target it.

/// The bookmark to show when the default bookmark does not exist: main,

/// else master, else the first by name; `None` without any.

fn stand_in(repo: &Repo) -> Result<Option<String>> {

    let view = repo.view()?;

    let names: Vec<&String> = view.bookmarks.keys().collect();

    Ok(["main", "master"]

        .iter()

        .find(|n| names.iter().any(|b| b == *n))

        .map(|n| n.to_string())

        .or_else(|| names.iter().min().map(|b| b.to_string())))

}

        return Err(fail(format!("{spec:?} is not a bookmark, tag or change of this repository")));

    /// The bookmark shown in the default's place when the repository has

    /// no bookmark of the default's name (a default set before its first

    /// push, or one deleted since).

    pub standing_in: Option<String>,

    let missing = || RefTarget { label: shown.into(), kind: RefKind::Bookmark, heads: vec![] };

    let (target, standing_in) = match resolve(repo, cache, shown) {

        Ok(t) => (t, None),

        // No bookmark of the default's name: show main, or else the first

        // bookmark, and say so, rather than an empty repository.

        Err(_) if shown == default_bookmark => match stand_in(repo)? {

            Some(b) => (resolve(repo, cache, &b)?, Some(b)),

            None => (missing(), None),

        },

        Err(_) => (missing(), None),

        standing_in,

        .route("/{owner}/{name}/bookmarks/create", post(refs::create_bookmark))

    /// Whether the viewer may create and delete bookmarks (write access).

#[derive(Deserialize)]

pub struct CreateBookmarkForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    name: String,

    /// A bookmark, tag or change; the default bookmark when empty.

    #[serde(default)]

    from: String,

}

/// Create a bookmark from the web at the heads of a bookmark, tag or change:

/// what pushing a new bookmark does, signed by the hub key as the user's

/// delegate, as the web's other changes to bookmarks are.

pub async fn create_bookmark(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Form(f): Form<CreateBookmarkForm>,

) -> Result<Page<BookmarksPage>, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/bookmarks"), &viewer);

    let me = require(&viewer, &shell)?;

    let (repo, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Write).await?;

    csrf(&viewer, &f.csrf_token, &shell)?;

    let bookmark = f.name.trim().to_string();

    let from = match f.from.trim() {

        "" => row.default_bookmark.clone(),

        s => s.to_string(),

    };

    if bookmark.is_empty() || bookmark.chars().any(char::is_whitespace) {

        return bookmarks_page(&app, shell, repo, row, role, None, Some("A bookmark's name has no spaces.".into())).await;

    }

    let (wanted, spec) = (bookmark.clone(), from.clone());

    let found = app

        .repos

        .read(&repo, move |r, cache| {

            if r.view()?.bookmarks.contains_key(&wanted) {

                return Ok(Err(format!("{wanted} is a bookmark already.")));

            }

            Ok(view::resolve(r, cache, &spec).map(|t| t.heads).map_err(|e| e.to_string()))

        })

        .await

        .map_err(|e| Error::from_repo(shell.clone(), e))?;

    let heads = match found {

        Ok(heads) if !heads.is_empty() => heads,

        Ok(_) => return bookmarks_page(&app, shell, repo, row, role, None, Some(format!("{from} holds no changes to start from."))).await,

        Err(msg) => return bookmarks_page(&app, shell, repo, row, role, None, Some(msg)).await,

    };

    // As the user's delegate when they have one; otherwise unsigned, which

    // a repository without a trust policy takes, as a push without one.

    let made = match super::edit::signer_for(&app, me.account.id).await {

        Ok(signer) => crate::repos::edits::move_bookmark(&app.repos, &repo, bookmark.clone(), heads.clone(), signer)

            .await

            .map(|_| ())

            .map_err(|e| e.to_string()),

        Err(why) => {

            let (target, at) = (bookmark.clone(), heads.clone());

            let unsigned = app

                .repos

                .write(&repo, move |r, _| {

                    let update = r.host_ref_update(&target, &at, None)?;

                    let report = r.receive_push_report(Default::default(), vec![update], None, vec![])?;

                    Ok(match report.results.first() {

                        Some(res) if res.ok => Ok(()),

                        Some(res) => Err(res.reason.clone()),

                        None => Err("nothing happened".to_string()),

                    })

                })

                .await

                .map_err(|e| e.to_string())

                .and_then(|r| r);

            unsigned.map_err(|refused| format!("{refused}. {why}"))

        }

    };

    if let Err(e) = made {

        return bookmarks_page(&app, shell, repo, row, role, None, Some(format!("Could not create {bookmark}: {e}"))).await;

    }

    let made = bookmark.clone();

    let new_state = app

        .repos

        .read(&repo, move |r, _| Ok(r.view()?.bookmarks.get(&made).map(|s| s.to_hex()).unwrap_or_default()))

        .await

        .unwrap_or_default();

    let result = db::repos::PushOutcome {

        reference: bookmark.clone(),

        ok: true,

        reason: format!("created on the web from {from}"),

        old_state: oxy_core::hash::ObjectRef::ZERO.to_hex(),

        new_state: new_state.clone(),

        heads: heads.len() as i64,

        changes: 0,

    };

    db::repos::record_push(&app.db, row.id, Some((me.account.id, &me.account.username)), &[result]).await.ok();

    crate::hooks::emit(

        &app,

        &row,

        "push",

        &me.account.username,

        serde_json::json!({ "updates": [{ "reference": bookmark, "old_state": oxy_core::hash::ObjectRef::ZERO.to_hex(), "new_state": new_state, "heads": heads.len(), "changes": 0, "created": true }], "via": "web" }),

    )

    .await;

    db::accounts::audit(&app.db, Some(&me.account), "bookmark.created", &format!("{owner}/{name}"), &format!("{bookmark} from {from}"))

        .await

        .ok();

    let notice = format!("Created {bookmark} from {from}. Propose changes into it, or make it the default in Settings.");

    bookmarks_page(&app, shell, repo, row, role, Some(notice), None).await

}

    let (repo, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Maintain).await?;

    // A new default must be a bookmark the repository has, or every page

    // that opens it finds nothing; an empty repository may name any, for

    // its first push to create.

    let wanted = f.default_bookmark.trim().to_string();

    if wanted != row.default_bookmark {

        let names: Vec<String> = app

            .repos

            .read(&repo, |r, _| Ok(r.view()?.bookmarks.keys().cloned().collect::<Vec<String>>()))

            .await

            .map_err(|err| Error::from_repo(shell.clone(), err))?;

        if !names.is_empty() && !names.contains(&wanted) {

            let mut some: Vec<&str> = names.iter().map(String::as_str).filter(|n| *n == "main" || *n == "master").collect();

            some.extend(names.iter().map(String::as_str).filter(|n| *n != "main" && *n != "master").take(8 - some.len()));

            let more = if names.len() > some.len() { format!(" and {} more", names.len() - some.len()) } else { String::new() };

            let msg = format!("{wanted} is not a bookmark here yet: push it first, or choose one of {}{more}.", some.join(", "));

            return back(&row, Section::General, None, Some(msg));

        }

    }

/// A bookmark is made on the web from another (doomsdayone/tetriblox could

/// not make develop), a default must be a bookmark the repository has, and

/// one that is missing (set before) leaves the overview showing main with a

/// note rather than an empty repository or a 404 saying "not a change".

#[tokio::test(flavor = "multi_thread")]

async fn bookmarks_are_made_on_the_web_and_a_default_must_exist() {

    hermetic();

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

    let mut config = Config::load(dir.path()).unwrap();

    config.registration.setup_code = "test-setup".into();

    config.auth.push_tokens = vec!["site".into()];

    config.registration.mode = "open".into();

    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();

    let port = listener.local_addr().unwrap().port();

    config.server.base_url = format!("http://127.0.0.1:{port}");

    let app = oxygenhub::build(config).await.unwrap();

    let router = oxygenhub::router(app.clone());

    tokio::spawn(async move { axum::serve(listener, router).await.unwrap() });

    let base = format!("http://127.0.0.1:{port}");

    let app = &app;

    let andy = send(

        app,

        "POST",

        "/register",

        None,

        None,

        Some("application/x-www-form-urlencoded"),

        b"username=andy&email=a%40example.com&password=correct-horse-battery&setup=test-setup".to_vec(),

    )

    .await

    .cookie

    .unwrap();

    let repo = RepoName::parse("andy/demo").unwrap();

    app.repos.create(&repo, None).unwrap();

    db::repos::create(&app.db, "andy", "demo", "", hub_api::Visibility::Public).await.unwrap();

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

    let mut client = Repo::init(work.path()).unwrap();

    client.create_identity("Andy", "[email protected]", IdentityScope::Repo).unwrap();

    client.config.set("remote.origin.url", &format!("{base}/andy/demo")).unwrap();

    client.config.set("remote.origin.token", "site").unwrap();

    client.save_config().unwrap();

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

    client.snapshot("t").unwrap();

    let c1 = client.commit("First", &[]).unwrap();

    assert!(client.push("origin", false).unwrap().iter().all(|r| r.ok));

    let host = || app.repos.open(&repo).unwrap();

    let heads_of = |b: &str| {

        let r = host();

        let st = r.view().unwrap().bookmarks.get(b).copied();

        st.map(|st| r.store().get_state(&st).unwrap().heads)

    };

    let page = send(app, "GET", "/andy/demo/bookmarks", Some(&andy), None, None, vec![]).await.text();

    assert!(page.contains("New bookmark") && page.contains("value=\"main\""), "{page}");

    let csrf = csrf_of(&page);

    // develop from the default; then not twice, nor from nothing.

    let r = form(app, "/andy/demo/bookmarks/create", &andy, &format!("_csrf={csrf}&name=develop&from=")).await;

    assert!(r.text().contains("Created develop from main."), "{}", r.text());

    assert_eq!(heads_of("develop"), Some(vec![c1]));

    let r = form(app, "/andy/demo/bookmarks/create", &andy, &format!("_csrf={csrf}&name=develop&from=main")).await;

    assert!(r.text().contains("develop is a bookmark already."), "{}", r.text());

    let r = form(app, "/andy/demo/bookmarks/create", &andy, &format!("_csrf={csrf}&name=feature&from=nowhere")).await;

    assert!(r.text().contains(""nowhere" is not a bookmark, tag or change of this repository"), "{}", r.text());

    assert_eq!(heads_of("feature"), None);

    let r = form(app, "/andy/demo/bookmarks/create", &andy, &format!("_csrf={csrf}&name=two+words&from=main")).await;

    assert!(r.text().contains("no spaces"), "{}", r.text());

    // The default: an existing bookmark, never a missing one.

    let settings = |b: &str| format!("_csrf={csrf}&description=&visibility=public&default_bookmark={b}");

    let r = form(app, "/andy/demo/settings", &andy, &settings("release")).await;

    let to = r.location.unwrap_or_default();

    assert!(to.contains("error=") && to.contains("release"), "{to}");

    let row = || async { db::repos::get(&app.db, "andy", "demo").await.unwrap().unwrap() };

    assert_eq!(row().await.default_bookmark, "main");

    form(app, "/andy/demo/settings", &andy, &settings("develop")).await;

    assert_eq!(row().await.default_bookmark, "develop");

    // One set before it existed (or deleted since): main, with a note.

    sqlx::query("UPDATE repositories SET default_bookmark = 'gone' WHERE name = 'demo'").execute(&app.db).await.unwrap();

    let page = send(app, "GET", "/andy/demo", Some(&andy), None, None, vec![]).await;

    assert_eq!(page.status, StatusCode::OK);

    let page = page.text();

    assert!(

        page.contains("This repository has no bookmark <strong>gone</strong>, its default, so this is <strong>main</strong>."),

        "{page}"

    );

    assert!(page.contains("a.txt"), "main's files: {page}");

    // Saving other settings keeps a missing default rather than refusing.

    let r =

        form(app, "/andy/demo/settings", &andy, &format!("_csrf={csrf}&description=Demo&visibility=public&default_bookmark=gone")).await;

    assert!(!r.location.unwrap_or_default().contains("error="));

    assert_eq!(row().await.description, "Demo");

}

{% if can_delete %}<details class="panel"{% if bookmarks.is_empty() %} open{% endif %}><summary>New bookmark</summary>

<form class="card" method="post" action="{{ repo.url }}/bookmarks/create"><input type="hidden" name="_csrf" value="{{ shell.csrf }}">

  <label for="bm-name">Name</label><input type="text" id="bm-name" name="name" maxlength="255" placeholder="develop" required>

  <label for="bm-from">From</label><input type="text" id="bm-from" name="from" list="bm-list" value="{% for b in bookmarks %}{% if b.default %}{{ b.name }}{% endif %}{% endfor %}" placeholder="a bookmark, tag or change">

  <datalist id="bm-list">{% for b in bookmarks %}<option value="{{ b.name }}">{% endfor %}</datalist>

  <p class="small mute">It starts at the same changes as what it is made from; nothing is copied.</p>

  <button type="submit">CREATE</button>

</form></details>{% endif %}

    {% if let Some(b) = o.standing_in %}<div class="strip warn">This repository has no bookmark <strong>{{ repo.default_bookmark }}</strong>, its default, so this is <strong>{{ b }}</strong>. Push {{ repo.default_bookmark }}, or choose an existing default in <a href="{{ repo.url }}/settings">settings</a>.</div>{% endif %}