New repository page in sections, with OxygenFlow, the wiki and a default bookmark 1062a0f8e985

## Unreleased

- **The New repository page in sections (#371):** Repository, Visibility, Starting files, Wiki, Project board, OxygenFlow and Storage, each with a heading and a line on what it does, and the choices as cards side by side that stack on a phone.

- **OxygenFlow with a new repository (#371):** on the site's runners (site administrators) or the owner's own (when the owner has one), set as it is made; left alone, the site's default applies.

- **Start the wiki (#371):** a Home page with the repository's name and description, written as you with the hub signing as your delegate.

- **Default bookmark (#371):** chosen on the New repository page, else the owner's default, else the site's, else `main`. A user sets theirs under Settings › New repositories, an organisation under its settings, and a site administrator under Administration › New repositories.

- The API's create takes `flow` (`on`, `own`), `wiki` and `default_bookmark`; `oh repo create … --flow on|own --wiki --bookmark NAME`.

  // The owner's default bookmark (#371): shown, and taken when left as it is.

  var bm = form.querySelector("[data-default-bookmark]");

  var bmFrom = form.querySelector("[data-bookmark-hint]");

  var bmTouched = false;

  if (bm) bm.addEventListener("input", function () { bmTouched = true; });

  function bookmark() {

    var o = owner.selectedOptions[0];

    if (!bm || !o) return;

    var b = o.getAttribute("data-bookmark") || "main";

    if (!bmTouched) bm.value = b;

    bm.placeholder = b;

    if (bmFrom) bmFrom.textContent = b + " is " + (o.getAttribute("data-bookmark-from") || "the default") + ". Change it in Settings.";

  }

  // On its owner's runners only when the owner has one (#371).

  var runners = (owner.getAttribute("data-runners") || "").split(" ").filter(Boolean);

  var own = form.querySelector("[data-flow-own]");

  function flow() {

    if (!own) return;

    var has = runners.indexOf(owner.value) >= 0;

    var r = own.querySelector("input");

    r.disabled = !has;

    if (!has && r.checked) form.querySelector("input[name=flow][value='']").checked = true;

    own.classList.toggle("off", !has);

    var note = own.querySelector("[data-flow-own-note]");

    if (note) note.textContent = has ? "Only " + owner.value + "'s own runners take its jobs." : owner.value + " has no runners of its own yet.";

  }

    bookmark();

    flow();

  bookmark();

  flow();

    /// OxygenFlow with it (#371): `on` (the site's runners; site

    /// administrators only) or `own` (the owner's runners, when it has

    /// one). Left out, the site's default applies.

    #[serde(default, skip_serializing_if = "Option::is_none")]

    pub flow: Option<String>,

    /// Start its wiki with a Home page giving its name and description.

    #[serde(default, skip_serializing_if = "std::ops::Not::not")]

    pub wiki: bool,

    /// Its default bookmark. Left out, the owner's default, else the

    /// site's, else `main`.

    #[serde(default, skip_serializing_if = "Option::is_none")]

    pub default_bookmark: Option<String>,

    // OxygenFlow and the wiki with it (#371).

    let bookmark = body.default_bookmark.clone().unwrap_or_default();

    if !bookmark.trim().is_empty() {

        crate::repo_setup::check_bookmark(bookmark.trim()).map_err(|m| ApiError(StatusCode::BAD_REQUEST, m))?;

    }

    let flow = crate::repo_setup::Flow::parse(body.flow.as_deref().unwrap_or("")).map_err(|m| ApiError(StatusCode::BAD_REQUEST, m))?;

    crate::repo_setup::check_flow(&app, me, &name.owner, flow).await.map_err(|m| ApiError(StatusCode::FORBIDDEN, m))?;

    if !files.is_empty() || body.wiki {

    let row = crate::repo_setup::set_default_bookmark(&app, row, &bookmark).await?;

    crate::repo_setup::set_flow(&app, &row, me, flow).await?;

    if body.wiki {

        crate::repo_setup::start_wiki(&app, &row, me, &body.description)

            .await

            .map_err(|m| ApiError(StatusCode::INTERNAL_SERVER_ERROR, m))?;

    }

    let row = db::repos::get_by_id(&app.db, row.id).await?.unwrap_or(row);

//! and proposals as they open. OxygenFlow switched on and the wiki

//! started with a Home page come with it too (#371).

/// Where a new repository's default bookmark comes from (#371): the

/// owner's own choice (a user's or an organisation's), else the site's,

/// else `main`. Kept in the settings table, so nothing else changes.

#[derive(Clone, Copy, Debug, PartialEq, Eq)]

pub enum BookmarkScope {

    Site,

    Account(i64),

    Org(i64),

}

/// The bookmark a repository has when nothing else is chosen.

pub const MAIN: &str = "main";

impl BookmarkScope {

    fn key(self) -> String {

        match self {

            BookmarkScope::Site => "default_bookmark".into(),

            BookmarkScope::Account(id) => format!("default_bookmark.account.{id}"),

            BookmarkScope::Org(id) => format!("default_bookmark.org.{id}"),

        }

    }

}

/// The default bookmark set at `scope`, if one is.

pub async fn bookmark_setting(pool: &db::Pool, scope: BookmarkScope) -> sqlx::Result<Option<String>> {

    Ok(db::accounts::setting(pool, &scope.key()).await?.filter(|v| !v.is_empty()))

}

/// Set (or, empty, clear) the default bookmark at `scope`.

pub async fn set_bookmark_setting(pool: &db::Pool, scope: BookmarkScope, value: &str) -> Result<(), String> {

    let v = value.trim();

    if !v.is_empty() {

        check_bookmark(v)?;

    }

    db::accounts::set_setting(pool, &scope.key(), v).await.map_err(|e| e.to_string())

}

/// A bookmark name a repository may default to.

pub fn check_bookmark(name: &str) -> Result<(), String> {

    if crate::repos::names::valid_segment(name) {

        Ok(())

    } else {

        Err(format!(

            "{name:?} is not a bookmark name: letters, digits, dots, dashes and underscores, up to 64, starting with a letter or digit."

        ))

    }

}

/// The default bookmark a new repository under `owner` takes, and where

/// it comes from (for the page: "develop, from doomsdayone's settings").

pub async fn default_bookmark_for(app: &Shared, owner: &str) -> (String, String) {

    let own = match db::accounts::org_by_name(&app.db, owner).await.ok().flatten() {

        Some(org) => Some(BookmarkScope::Org(org.id)),

        None => db::accounts::account_by_name(&app.db, owner).await.ok().flatten().map(|a| BookmarkScope::Account(a.id)),

    };

    if let Some(scope) = own {

        if let Ok(Some(b)) = bookmark_setting(&app.db, scope).await {

            return (b, format!("{owner}'s default"));

        }

    }

    match bookmark_setting(&app.db, BookmarkScope::Site).await {

        Ok(Some(b)) => (b, "this site's default".into()),

        _ => (MAIN.into(), "the usual default".into()),

    }

}

/// The new repository's default bookmark: the one asked for, or its

/// owner's, the site's or `main`; set on its row when it is not `main`.

pub async fn set_default_bookmark(app: &Shared, row: db::repos::RepoRow, asked: &str) -> sqlx::Result<db::repos::RepoRow> {

    let asked = asked.trim();

    let b = if asked.is_empty() { default_bookmark_for(app, &row.owner).await.0 } else { asked.to_string() };

    if b == row.default_bookmark {

        return Ok(row);

    }

    db::repos::set_default_bookmark(&app.db, row.id, &b).await?;

    Ok(db::repos::get_by_id(&app.db, row.id).await?.unwrap_or(row))

}

/// OxygenFlow for a new repository (#371): left to the site's default,

/// on the site's runners (a site administrator's choice), or on the

/// owner's own runners.

#[derive(Clone, Copy, Debug, PartialEq, Eq)]

pub enum Flow {

    Default,

    On,

    Own,

}

impl Flow {

    pub fn parse(choice: &str) -> Result<Flow, String> {

        match choice.trim() {

            "" | "default" | "off" => Ok(Flow::Default),

            "on" => Ok(Flow::On),

            "own" => Ok(Flow::Own),

            other => Err(format!("OxygenFlow is on, own or left to the default, not {other}.")),

        }

    }

    /// The repository's `flow` setting, as Settings › Pipelines writes it.

    pub fn setting(self) -> &'static str {

        match self {

            Flow::Default => "",

            Flow::On => "on",

            Flow::Own => "own",

        }

    }

}

/// Whether `owner` has runners of its own (not the site's), which

/// [`Flow::Own`] needs before its repository exists.

pub async fn owner_has_runner(app: &Shared, owner: &str) -> sqlx::Result<bool> {

    Ok(db::runners::serving_owner(&app.db, owner).await?.iter().any(|r| !r.scope().is_site()))

}

/// Checked before the repository is made, as Settings › Pipelines checks.

pub async fn check_flow(app: &Shared, account: &db::accounts::Account, owner: &str, flow: Flow) -> Result<(), String> {

    match flow {

        Flow::Default => Ok(()),

        Flow::On if account.is_admin => Ok(()),

        Flow::On => Err("Only site administrators let the site's runners take a repository's jobs.".into()),

        Flow::Own => match owner_has_runner(app, owner).await.map_err(|e| e.to_string())? {

            true => Ok(()),

            false => {

                Err(format!("{owner} has no runners of its own yet: register one, then switch OxygenFlow on in Settings › Pipelines."))

            }

        },

    }

}

/// Switch OxygenFlow on for the new repository, as chosen.

pub async fn set_flow(app: &Shared, row: &db::repos::RepoRow, by: &db::accounts::Account, flow: Flow) -> sqlx::Result<()> {

    if flow == Flow::Default {

        return Ok(());

    }

    db::repos::set_flow(&app.db, row.id, flow.setting()).await?;

    db::accounts::audit(&app.db, Some(by), "repo.flow", &format!("{}/{}", row.owner, row.name), flow.setting()).await.ok();

    Ok(())

}

/// A new wiki's Home page: the repository's name and description.

pub fn wiki_home(name: &RepoName, description: &str) -> String {

    let about = description.trim();

    let about = if about.is_empty() { String::new() } else { format!("{about}\n\n") };

    format!("# {}\n\n{about}This is the wiki's home page. Edit it, or add pages beside it.\n", name.name)

}

/// Start the repository's wiki with its Home page, written as `by` and

/// signed as their delegate, as a wiki edit on the site is.

pub async fn start_wiki(app: &Shared, row: &db::repos::RepoRow, by: &db::accounts::Account, description: &str) -> Result<(), String> {

    let name = RepoName::new(&row.owner, &row.name).ok_or("bad repository name")?;

    let signer = crate::web::edit::signer_for(app, by.id).await?;

    let edit = FileEdit { path: crate::wiki::path_of(crate::wiki::HOME), content: Some(wiki_home(&name, description).into_bytes()) };

    crate::wiki::commit(app, &name, vec![edit], "Start the wiki".into(), signer).await.map_err(|e| e.to_string())?;

    db::accounts::audit(&app.db, Some(by), "wiki.started", &name.to_string(), "Home").await.ok();

    Ok(())

}

    }

    #[test]

    fn flow_choices_and_the_wiki_home() {

        assert_eq!(Flow::parse("").unwrap(), Flow::Default);

        assert_eq!(Flow::parse("off").unwrap(), Flow::Default);

        assert_eq!(Flow::parse("on").unwrap().setting(), "on");

        assert_eq!(Flow::parse("own").unwrap().setting(), "own");

        assert!(Flow::parse("always").is_err());

        let name = RepoName::new("andy", "square").unwrap();

        assert_eq!(

            wiki_home(&name, " A platform game. "),

            "# square\n\nA platform game.\n\nThis is the wiki's home page. Edit it, or add pages beside it.\n"

        );

        assert!(wiki_home(&name, "").starts_with("# square\n\nThis is"));

    }

    #[test]

    fn bookmark_defaults_are_kept_apart() {

        assert_eq!(BookmarkScope::Site.key(), "default_bookmark");

        assert_eq!(BookmarkScope::Account(7).key(), "default_bookmark.account.7");

        assert_eq!(BookmarkScope::Org(7).key(), "default_bookmark.org.7");

        assert!(check_bookmark("develop").is_ok());

        assert!(check_bookmark("release-1.0").is_ok());

        assert!(check_bookmark("feature/x").is_err());

        assert!(check_bookmark("-x").is_err());

    NewRepositories,

    ("Data", &[AdminSection::NewRepositories, AdminSection::Storage, AdminSection::Backups]),

            AdminSection::NewRepositories => "/admin/repositories",

            AdminSection::NewRepositories => "repositories",

            AdminSection::NewRepositories => "New repositories",

    /// New repositories' default bookmark across the site (#371); empty, `main`.

    site_bookmark: String,

    let site_bookmark =

        crate::repo_setup::bookmark_setting(&app.db, crate::repo_setup::BookmarkScope::Site).await.map_err(e)?.unwrap_or_default();

        site_bookmark,

#[derive(Deserialize)]

pub struct BookmarkForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    #[serde(default)]

    default_bookmark: String,

}

/// `POST /admin/repositories` (oxygenhub#371): the default bookmark of new

/// repositories whose owner has not chosen one; empty, `main`.

pub async fn set_bookmark(State(app): State<Shared>, viewer: Viewer, Form(f): Form<BookmarkForm>) -> Result<Page<AdminPage>, Error> {

    let shell = Shell::new(&app, "/admin", &viewer);

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

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

    let scope = crate::repo_setup::BookmarkScope::Site;

    if let Err(m) = crate::repo_setup::set_bookmark_setting(&app.db, scope, &f.default_bookmark).await {

        return Err(Error::bad(shell, &m));

    }

    let b = f.default_bookmark.trim();

    accounts::audit(&app.db, Some(&me), "admin.default_bookmark", b, "").await.ok();

    let b = if b.is_empty() { crate::repo_setup::MAIN } else { b };

    admin_page(

        &app,

        shell,

        AdminSection::NewRepositories,

        Some(format!("New repositories start on {b} unless their owner chooses another.")),

    )

    .await

}

        .route("/settings/repositories", post(settings::repositories))

        .route("/admin/repositories", get(admin::section).post(admin::set_bookmark))

    /// Its new repositories' default bookmark (#371), and the site's.

    default_bookmark: String,

    site_bookmark: String,

    let default_bookmark = crate::repo_setup::bookmark_setting(&app.db, crate::repo_setup::BookmarkScope::Org(org.id))

        .await

        .ok()

        .flatten()

        .unwrap_or_default();

    let site_bookmark = crate::repo_setup::bookmark_setting(&app.db, crate::repo_setup::BookmarkScope::Site)

        .await

        .ok()

        .flatten()

        .unwrap_or_else(|| crate::repo_setup::MAIN.into());

        default_bookmark,

        site_bookmark,

    /// Its new repositories' default bookmark (#371); empty, the site's.

    #[serde(default)]

    default_bookmark: String,

    if let Err(m) =

        crate::repo_setup::set_bookmark_setting(&app.db, crate::repo_setup::BookmarkScope::Org(org.id), &f.default_bookmark).await

    {

        return org_page(&app, shell, org, None, Some(m)).await;

    }

    /// Whether the viewer may put a repository on the site's runners (#371).

    admin: bool,

    /// Owners with runners of their own, for "on its owner's runners".

    runner_owners: Vec<String>,

    /// Each owner's default bookmark and where it comes from (#371).

    bookmarks: Vec<(String, String, String)>,

    let mut runner_owners = Vec::new();

    let mut bookmarks = Vec::new();

        let (b, from) = crate::repo_setup::default_bookmark_for(app, o).await;

        bookmarks.push((o.clone(), b, from));

        if crate::repo_setup::owner_has_runner(app, o).await.unwrap_or(false) {

            runner_owners.push(o.clone());

        }

        admin: me.is_admin,

        runner_owners,

        bookmarks,

    /// OxygenFlow (#371): `on`, `own`, or the site default.

    #[serde(default)]

    flow: String,

    /// Start the wiki with a Home page (#371).

    #[serde(default)]

    wiki: Option<String>,

    /// Its default bookmark; empty, the owner's or the site's default (#371).

    #[serde(default)]

    default_bookmark: String,

        return Ok(fail(&m));

    }

    let flow = match crate::repo_setup::Flow::parse(&f.flow) {

        Ok(flow) => flow,

        Err(m) => return Ok(fail(&m)),

    };

    if let Err(m) = crate::repo_setup::check_flow(&app, &me.account, &name.owner, flow).await {

    }

    let wiki = f.wiki.is_some();

    if !f.default_bookmark.trim().is_empty() {

        if let Err(m) = crate::repo_setup::check_bookmark(f.default_bookmark.trim()) {

            return Ok(fail(&m));

        }

    if !files.is_empty() || wiki {

            return Ok(fail(&format!("The hub cannot write the starting files or the wiki for you yet. {m}")));

        let row =

            crate::repo_setup::set_default_bookmark(&app, row, &f.default_bookmark).await.map_err(|e| Error::from_db(shell.clone(), e))?;

        crate::repo_setup::set_flow(&app, &row, &me.account, flow).await.map_err(|e| Error::from_db(shell.clone(), e))?;

        if wiki {

            if let Err(e) = crate::repo_setup::start_wiki(&app, &row, &me.account, &f.description).await {

                tracing::warn!("wiki for {name}: {e}");

            }

        }

    let row =

        crate::repo_setup::set_default_bookmark(&app, row, &f.default_bookmark).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    crate::repo_setup::set_flow(&app, &row, &me.account, flow).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    }

    if wiki {

        if let Err(e) = crate::repo_setup::start_wiki(&app, &row, &me.account, &f.description).await {

            tracing::warn!("wiki for {name}: {e}");

        }

        admin: p.admin,

        runner_owners: p.runner_owners.clone(),

        bookmarks: p.bookmarks.clone(),

    /// The default bookmark of the repositories they make (#371), and the

    /// one they get when that is empty.

    default_bookmark: String,

    site_bookmark: String,

            default_bookmark: String::new(),

            site_bookmark: crate::repo_setup::MAIN.into(),

    /// What the page reads from the hub: whether it sends mail, and the

    /// default bookmarks (#371).

    async fn with_hub(mut self, app: &Shared) -> Self {

        use crate::repo_setup::{bookmark_setting, BookmarkScope};

        self.default_bookmark = bookmark_setting(&app.db, BookmarkScope::Account(self.me.id)).await.ok().flatten().unwrap_or_default();

        if let Ok(Some(b)) = bookmark_setting(&app.db, BookmarkScope::Site).await {

            self.site_bookmark = b;

        }

    Ok(Page(SettingsPage::new(shell, me.account, &headers).with_hub(&app).await))

    let page = SettingsPage::new(shell, fresh, &headers).with_hub(&app).await;

    let page = SettingsPage::new(shell, me.account.clone(), &headers).with_hub(&app).await;

            SettingsPage::new(shell, me.account, &headers)

                .with_hub(&app)

                .await

                .error("The website must be an http:// or https:// address."),

        Err(msg) => return Ok(Page(SettingsPage::new(shell, me.account, &headers).with_hub(&app).await.error(&msg))),

    Ok(Page(SettingsPage::new(shell, updated, &headers).with_hub(&app).await.notice(notice)))

}

#[derive(Deserialize)]

pub struct BookmarkForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    #[serde(default)]

    default_bookmark: String,

}

/// `POST /settings/repositories` (oxygenhub#371): the default bookmark of

/// the repositories they make; empty, the site's.

pub async fn repositories(

    State(app): State<Shared>,

    viewer: Viewer,

    headers: HeaderMap,

    Form(f): Form<BookmarkForm>,

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

    let shell = Shell::new(&app, "/settings", &viewer);

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

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

    let scope = crate::repo_setup::BookmarkScope::Account(me.account.id);

    let page = match crate::repo_setup::set_bookmark_setting(&app.db, scope, &f.default_bookmark).await {

        Ok(()) => {

            accounts::audit(&app.db, Some(&me.account), "account.default_bookmark", &me.account.username, f.default_bookmark.trim())

                .await

                .ok();

            SettingsPage::new(shell, me.account, &headers).with_hub(&app).await.notice("Saved: new repositories start with that bookmark.")

        }

        Err(m) => SettingsPage::new(shell, me.account, &headers).with_hub(&app).await.error(&m),

    };

    Ok(Page(page))

        return Ok(Page(SettingsPage::new(shell, me.account, &headers).with_hub(&app).await.error("Your current password is wrong."))

            .into_response());

        return Ok(Page(SettingsPage::new(shell, me.account, &headers).with_hub(&app).await.error(e)).into_response());

    let a = mint(andy.clone(), "scopes=repo%3Aadmin").await;

    let b = mint(bob.clone(), "scopes=repo%3Aread&scopes=repo%3Awrite").await;

    // OxygenFlow, the wiki and the default bookmark with it (#371).

    let a = a.as_str();

    let made = |name: &'static str| async move { api(app, "GET", &format!("/api/v1/repos/andy/{name}"), Some(a), None).await.0 };

    let bob_admin = mint(bob.clone(), "scopes=repo%3Aadmin").await;

    let (st, v) = api(app, "POST", "/api/v1/repos", Some(&bob_admin), Some(r#"{"owner":"bob","name":"site","flow":"on"}"#)).await;

    assert_eq!(st, StatusCode::FORBIDDEN, "only site administrators use the site's runners: {v}");

    let (st, v) = api(app, "POST", "/api/v1/repos", Some(a), Some(r#"{"owner":"andy","name":"ownflow","flow":"own"}"#)).await;

    assert_eq!(st, StatusCode::FORBIDDEN, "andy has no runners of his own: {v}");

    assert_eq!(made("ownflow").await, StatusCode::NOT_FOUND, "nothing made");

    let (st, _) = api(app, "POST", "/api/v1/repos", Some(a), Some(r#"{"owner":"andy","name":"x","flow":"always"}"#)).await;

    assert_eq!(st, StatusCode::BAD_REQUEST);

    let (st, v) = api(app, "POST", "/api/v1/repos", Some(a), Some(r#"{"owner":"andy","name":"flowing","flow":"on"}"#)).await;

    assert_eq!(st, StatusCode::CREATED, "{v}");

    let flow: String = sqlx::query_scalar("SELECT flow FROM repositories WHERE name = 'flowing'").fetch_one(&app.db).await.unwrap();

    assert_eq!(flow, "on");

    let (st, v) = api(app, "POST", "/api/v1/repos", Some(a), Some(r#"{"owner":"andy","name":"wikied","wiki":true}"#)).await;

    assert_eq!(st, StatusCode::CONFLICT, "the wiki needs the hub as the caller's delegate: {v}");

    assert_eq!(made("wikied").await, StatusCode::NOT_FOUND, "nothing made");

    // The bookmark: asked for, else the owner's, else the site's, else main.

    let bookmark = |name: &'static str| async move {

        api(app, "GET", &format!("/api/v1/repos/andy/{name}"), Some(a), None).await.1["default_bookmark"].as_str().unwrap().to_string()

    };

    assert_eq!(bookmark("flowing").await, "main");

    let (st, _) = api(app, "POST", "/api/v1/repos", Some(a), Some(r#"{"owner":"andy","name":"y","default_bookmark":"a/b"}"#)).await;

    assert_eq!(st, StatusCode::BAD_REQUEST);

    let page = call(app, "GET", "/admin/repositories", None, Some(&andy), None, None).await;

    let token = csrf_of(&page.body);

    let r = call(app, "POST", "/admin/repositories", None, Some(&andy), None, Some(&format!("_csrf={token}&default_bookmark=trunk"))).await;

    assert!(r.body.contains("start on trunk"), "{}", r.body);

    api(app, "POST", "/api/v1/repos", Some(a), Some(r#"{"owner":"andy","name":"sited"}"#)).await;

    assert_eq!(bookmark("sited").await, "trunk");

    let page = call(app, "GET", "/settings", None, Some(&andy), None, None).await;

    assert!(page.body.contains(r#"placeholder="trunk""#), "the site's default shown");

    let token = csrf_of(&page.body);

    call(app, "POST", "/settings/repositories", None, Some(&andy), None, Some(&format!("_csrf={token}&default_bookmark=develop"))).await;

    api(app, "POST", "/api/v1/repos", Some(a), Some(r#"{"owner":"andy","name":"mine"}"#)).await;

    assert_eq!(bookmark("mine").await, "develop");

    api(app, "POST", "/api/v1/repos", Some(a), Some(r#"{"owner":"andy","name":"asked","default_bookmark":"next"}"#)).await;

    assert_eq!(bookmark("asked").await, "next");

    let page = call(app, "GET", "/new", None, Some(&andy), None, None).await;

    assert!(page.body.contains(r#"data-bookmark="develop""#), "{}", page.body);

    assert!(page.body.contains("<h2>OxygenFlow</h2>") && page.body.contains("<h2>Wiki</h2>"));

    assert!(again.body.contains("cannot write the starting files or the wiki for you yet"), "no delegate: refused, nothing made");

        /// Switch OxygenFlow on: `on` (the site's runners; site administrators) or `own` (the owner's runners)

        #[arg(long)]

        flow: Option<String>,

        /// Start its wiki with a Home page

        #[arg(long)]

        wiki: bool,

        /// Its default bookmark (default: the owner's, else the site's, else main)

        #[arg(long, short = 'B')]

        bookmark: Option<String>,

        Cmd::Repo { cmd: RepoCmd::Create { slug, description, visibility, project, readme, licence, ignore, flow, wiki, bookmark } } => {

                "wiki": wiki,

            if let Some(f) = flow {

                body["flow"] = serde_json::json!(f);

            }

            if let Some(b) = bookmark {

                body["default_bookmark"] = serde_json::json!(b);

            }

{% when crate::web::admin::AdminSection::NewRepositories %}

<section class="panel" id="repositories">

  <h2>New repositories</h2>

  <form class="card" method="post" action="/admin/repositories">

    <input type="hidden" name="_csrf" value="{{ shell.csrf }}">

    <label for="sitebookmark">Default bookmark</label>

    <input type="text" id="sitebookmark" name="default_bookmark" value="{{ site_bookmark }}" placeholder="main" pattern="[A-Za-z0-9][A-Za-z0-9._-]{0,63}" autocomplete="off" spellcheck="false">

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

  </form>

  <p class="small mute">The bookmark a new repository starts with, such as <code>develop</code>. A user or an organisation may choose their own in their settings, and each repository on the New repository page. Left empty: <code>main</code>.</p>

</section>

  <label for="default_bookmark">New repositories' default bookmark</label>

  <input type="text" id="default_bookmark" name="default_bookmark" value="{{ default_bookmark }}" placeholder="{{ site_bookmark }}" pattern="[A-Za-z0-9][A-Za-z0-9._-]{0,63}" autocomplete="off" spellcheck="false">

  <p class="small mute">Such as <code>develop</code>. Left empty, they take this site's: <code>{{ site_bookmark }}</code>. Each repository can still choose its own.</p>

<form class="card full new-repo" method="post" action="/new" data-new-repo>

  <section class="nr-sec">

    <div class="nr-head"><h2>Repository</h2><p class="small mute">Where it lives and what it is called.</p></div>

    <div class="nr-body">

      <div class="row name-row">

        <div><label for="owner">Owner</label><select id="owner" name="owner" data-orgs="{% for o in orgs %}{{ o }} {% endfor %}" data-runners="{% for o in runner_owners %}{{ o }} {% endfor %}">{% for (o, b, from) in bookmarks %}<option value="{{ o }}" data-bookmark="{{ b }}" data-bookmark-from="{{ from }}">{{ o }}</option>{% endfor %}</select></div>

        <div class="slash" aria-hidden="true">/</div>

        <div class="grow"><label for="name">Name</label><input type="text" id="name" name="name" required pattern="[A-Za-z0-9][A-Za-z0-9._-]{0,63}" autocomplete="off" aria-describedby="name-check" autofocus></div>

      </div>

      <p id="name-check" class="small name-check" role="status" aria-live="polite" data-base="{{ base_url }}"></p>

      <label for="description">Description <span class="small mute">(optional; the README and the wiki start with it)</span></label><input type="text" id="description" name="description">

      <label for="default_bookmark">Default bookmark</label><input type="text" id="default_bookmark" class="nr-bookmark" name="default_bookmark" pattern="[A-Za-z0-9][A-Za-z0-9._-]{0,63}" autocomplete="off" spellcheck="false" aria-describedby="bookmark-from" data-default-bookmark>

      <p id="bookmark-from" class="small mute nr-hint" data-bookmark-hint></p>

    </div>

  </section>

  <section class="nr-sec">

    <div class="nr-head"><h2>Visibility</h2><p class="small mute">Who can see and clone it. You can change it later in Settings.</p></div>

    <div class="nr-body nr-cards three" role="radiogroup" aria-label="Visibility">

      <label class="choice-card"><input type="radio" name="visibility" value="public" checked><span><strong>Public</strong><span class="small mute">Anyone can see and clone it. You choose who may push.</span></span></label>

      <label class="choice-card"><input type="radio" name="visibility" value="internal"><span><strong>Internal</strong><span class="small mute">Anyone signed in to this hub can see it.</span></span></label>

      <label class="choice-card"><input type="radio" name="visibility" value="private"><span><strong>Private</strong><span class="small mute">Only you{% if !orgs.is_empty() %}, the organisation's members{% endif %} and the people you add.</span></span></label>

    </div>

  </section>

  <section class="nr-sec">

    <div class="nr-head"><h2>Starting files</h2><p class="small mute">Optional. Left empty, it starts empty and takes its first push. The hub commits these as you, signed with its key as your delegate.</p></div>

    <div class="nr-body">

      <label class="nr-toggle"><input type="checkbox" name="readme" value="1"><span><strong>README</strong><span class="small mute">Its name and description, as README.md.</span></span></label>

      <div class="row nr-pair">

        <div><label for="licence">Licence</label><select id="licence" name="licence"><option value="">none</option>{% for (id, what) in licences %}<option value="{{ id }}">{{ id }}: {{ what }}</option>{% endfor %}</select></div>

        <div><label for="ignore">.oxyignore</label><select id="ignore" name="ignore"><option value="">none</option>{% for l in ignores %}<option>{{ l }}</option>{% endfor %}</select></div>

      </div>

    </div>

  </section>

  <section class="nr-sec">

    <div class="nr-head"><h2>Wiki</h2><p class="small mute">Pages beside the code, cloned as its <code>.wiki</code>.</p></div>

    <div class="nr-body">

      <label class="nr-toggle"><input type="checkbox" name="wiki" value="1"><span><strong>Start the wiki</strong><span class="small mute">A Home page with its name and description, ready to edit. Left off, the first page anyone writes starts it.</span></span></label>

    </div>

  </section>

  <section class="nr-sec">

    <div class="nr-head"><h2>Project board</h2><p class="small mute">Its issues and proposals join the board as they open.</p></div>

    <div class="nr-body">

      <div class="nr-cards three" role="radiogroup" aria-label="Project board">

        <label class="choice-card"><input type="radio" name="board" value="" checked data-board-none><span><strong>No board</strong><span class="small mute">Add its issues to a board later.</span></span></label>

        <label class="choice-card"><input type="radio" name="board" value="new" data-board-new><span><strong>A new board</strong><span class="small mute">Backlog, Doing and Done; finished work moves to Done.</span></span></label>

        {% if !boards.is_empty() %}<label class="choice-card"><input type="radio" name="board" value="existing" data-board-existing><span><strong>An existing board</strong><span class="small mute">One of the owner's open boards.</span></span></label>{% endif %}

      </div>

      <div class="board-title"><label for="board_title">Board title</label><input type="text" id="board_title" name="board_title" maxlength="100" placeholder="the repository's name"></div>

      {% if !boards.is_empty() %}<div class="board-existing"><label for="board_n">Board</label><select id="board_n" name="board_n" data-board-list>{% for (o, n, t) in boards %}<option value="{{ n }}" data-owner="{{ o }}">{{ o }} #{{ n }}: {{ t }}</option>{% endfor %}</select></div>{% endif %}

  </section>

  <section class="nr-sec">

    <div class="nr-head"><h2>OxygenFlow</h2><p class="small mute">Pipelines: once it is on, every push with a <code>.flow/pipeline.kdl</code> starts a run, and its jobs show as checks.</p></div>

    <div class="nr-body nr-cards three" role="radiogroup" aria-label="OxygenFlow">

      <label class="choice-card"><input type="radio" name="flow" value="" checked><span><strong>Not yet</strong><span class="small mute">The site's default. Switch it on later in Settings › Pipelines.</span></span></label>

      <label class="choice-card{% if !admin %} off{% endif %}"><input type="radio" name="flow" value="on"{% if !admin %} disabled{% endif %}><span><strong>On, site runners</strong><span class="small mute">{% if admin %}The site's runners take its jobs.{% else %}A site administrator's choice.{% endif %}</span></span></label>

      <label class="choice-card" data-flow-own><input type="radio" name="flow" value="own"><span><strong>On, own runners</strong><span class="small mute" data-flow-own-note>Only the owner's own runners take its jobs.</span></span></label>

    </div>

  </section>

  <details class="nr-sec nr-storage">

    <summary><h2>Storage</h2><span class="small mute">This server's disk, unless you keep it in your own bucket.</span></summary>

    <div class="nr-body">

      <div class="nr-cards two">

        <label class="choice-card"><input type="radio" name="storage" value="hub" checked><span><strong>This server's disk</strong><span class="small mute">The default. Backed up with the hub.</span></span></label>

        <label class="choice-card"><input type="radio" name="storage" value="bucket"><span><strong>My own bucket</strong><span class="small mute">Amazon S3, Google Cloud Storage or Azure; this server keeps a cache. It starts empty.</span></span></label>

      </div>

    </div>

  <div class="nr-foot"><button type="submit">CREATE REPOSITORY</button></div>

  <a href="#repositories">New repositories</a>

<form class="card" id="repositories" method="post" action="/settings/repositories">

  <input type="hidden" name="_csrf" value="{{ shell.csrf }}">

  <h2>New repositories</h2>

  <label for="default_bookmark">Default bookmark</label>

  <input type="text" id="default_bookmark" name="default_bookmark" value="{{ default_bookmark }}" placeholder="{{ site_bookmark }}" pattern="[A-Za-z0-9][A-Za-z0-9._-]{0,63}" autocomplete="off" spellcheck="false">

  <p class="small mute">The bookmark your new repositories start with, such as <code>develop</code>. Left empty, they take this site's: <code>{{ site_bookmark }}</code>. An organisation sets its own under its settings.</p>

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

</form>

/* The New repository page (#360, #371): sections with a heading column on

   the left and their choices on the right, stacked on a phone. */

form.card.new-repo { max-width: 960px; padding: 0; }

.new-repo .nr-sec { display: grid; grid-template-columns: minmax(0, 220px) minmax(0, 1fr); gap: 8px 28px; padding: 20px 24px; border-top: 1px solid var(--line); }

.new-repo .nr-sec:first-of-type { border-top: 0; }

.new-repo .nr-sec > .nr-head h2, .new-repo .nr-storage summary h2 { font-size: 15px; margin: 0 0 4px; color: var(--ink); }

.new-repo .nr-sec > .nr-head p { margin: 0; }

.new-repo .nr-body { min-width: 0; }

.new-repo .nr-body > label:first-child, .new-repo .name-row label { margin-top: 0; }

.new-repo .name-row .slash { flex: none; font-size: 20px; color: var(--mute); padding-bottom: 6px; }

.new-repo .name-check { min-height: 1.4em; margin: 4px 0 4px; }

.new-repo .nr-cards { display: grid; gap: 10px; align-content: start; }

.new-repo .nr-cards.three { grid-template-columns: repeat(auto-fit, minmax(170px, 1fr)); }

.new-repo .nr-cards.two { grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); margin-bottom: 10px; }

.new-repo label.choice-card, .new-repo label.nr-toggle { display: flex; gap: 10px; align-items: flex-start; margin: 0; padding: 10px 12px; border: 1px solid var(--line); background: var(--soft); cursor: pointer; font-size: 14px; text-transform: none; letter-spacing: 0; color: var(--ink); }

.new-repo label.choice-card input, .new-repo label.nr-toggle input { margin: 3px 0 0; flex: none; }

.new-repo label.choice-card > span, .new-repo label.nr-toggle > span { display: grid; gap: 2px; min-width: 0; }

.new-repo label.choice-card:hover, .new-repo label.nr-toggle:hover { border-color: var(--acc); }

.new-repo label.choice-card:has(input:checked), .new-repo label.nr-toggle:has(input:checked) { border-color: var(--acc); box-shadow: inset 3px 0 0 var(--acc); }

.new-repo label.choice-card:has(input:focus-visible), .new-repo label.nr-toggle:has(input:focus-visible) { outline: 2px solid var(--acc); outline-offset: 1px; }

.new-repo label.choice-card.off { cursor: not-allowed; opacity: .6; }

.new-repo label.choice-card.off:hover { border-color: var(--line); }

.new-repo .nr-pair { margin-top: 4px; flex-wrap: wrap; }

.new-repo .nr-pair > div { flex: 1 1 200px; min-width: 0; }

.new-repo .nr-hint { margin: 4px 0 0; }

.new-repo input.nr-bookmark { max-width: 260px; }

.new-repo .name-row > div:first-child { flex: 0 1 220px; min-width: 0; }

.new-repo .name-row .grow { flex: 1 1 auto; }

.new-repo .name-row select, .new-repo .name-row input { width: 100%; }

.new-repo .board-title, .new-repo .board-existing { margin-top: 6px; max-width: 420px; }

.new-repo details.nr-storage > summary { grid-column: 1 / -1; display: flex; flex-wrap: wrap; align-items: baseline; gap: 4px 12px; cursor: pointer; list-style: none; }

.new-repo details.nr-storage > summary::-webkit-details-marker { display: none; }

.new-repo details.nr-storage > summary h2::before { content: "\25B8"; display: inline-block; width: 1em; color: var(--mute); }

.new-repo details.nr-storage[open] > summary h2::before { content: "\25BE"; }

.new-repo details.nr-storage > .nr-body { grid-column: 2; }

.new-repo .nr-storage:not(:has(input[name=storage][value=bucket]:checked)) .storage-bucket { display: none; }

.new-repo .nr-foot { display: flex; justify-content: flex-end; padding: 16px 24px; border-top: 1px solid var(--line); background: var(--soft); }

.new-repo .nr-foot button { margin: 0; }

@media (max-width: 720px) {

  .new-repo .nr-sec { grid-template-columns: minmax(0, 1fr); padding: 16px; }

  .new-repo details.nr-storage > .nr-body { grid-column: 1; }

  .new-repo .nr-foot { padding: 12px 16px; }

  .new-repo .nr-foot button { width: 100%; }

}