Labels from oh: on proposals and issues, and the repository's labels 2291f8cc9c96

- **Labels from `oh` (#80).** `oh proposal label N --add NAME --remove NAME` and `oh issue label N …` put labels on or take them off (triage), and `oh label list|create|delete` manage the repository's labels. Through the API, `PATCH /proposals/{n}` takes `labels` (the whole set, by name, every name checked before anything changes), and a proposal's JSON lists its labels.

    #[serde(default)]

    pub labels: Vec<Label>,

    /// The whole set of labels, by name (triage); oxygenhub#80.

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

    pub labels: Option<Vec<String>>,

        ("ReleaseEdit", schemars::schema_for!(ReleaseEdit)),

        ("ProposalEdit", schemars::schema_for!(ProposalEdit)),

    let text = body.title.is_some() || body.body.is_some();

    if text && Some(me.id) != p.author_id && role < Role::Maintain {

    }

    if body.labels.is_some() && role < Role::Triage {

        return Err(forbidden("setting labels needs triage access"));

    }

    // Every name is checked before anything changes.

    let labels = resolve_triage(&app, row.id, body.labels.as_deref(), None, None).await?.labels;

    if text {

        let title = match body.title.as_deref().map(str::trim) {

            Some("") => return Err(ApiError(StatusCode::BAD_REQUEST, "a proposal needs a title".into())),

            Some(t) => t,

            None => p.title.as_str(),

        };

        let text = body.body.as_deref().map(str::trim).unwrap_or(&p.body);

        db::proposals::edit(&app.db, p.id, title, text, &p.target).await?;

        db::proposals::add_event(&app.db, p.id, &me.username, "edited", "").await.ok();

    if let Some(want) = labels {

        let have = db::issues::proposal_labels(&app.db, p.id).await?;

        for l in &have {

            if !want.iter().any(|w| w.id == l.id) {

                db::issues::set_proposal_label(&app.db, p.id, l.id, false).await?;

            }

        }

        for w in &want {

            if !have.iter().any(|l| l.id == w.id) {

                db::issues::set_proposal_label(&app.db, p.id, w.id, true).await?;

            }

        }

        let names: Vec<&str> = want.iter().map(|l| l.name.as_str()).collect();

        db::proposals::add_event(&app.db, p.id, &me.username, "set labels", &names.join(", ")).await.ok();

    }

        labels: db::issues::proposal_labels(&app.db, p.id)

            .await

            .unwrap_or_default()

            .into_iter()

            .map(|l| hub_api::Label { name: l.name, colour: l.colour, description: l.description })

            .collect(),

    // oxygenhub#80: labels on a proposal, the whole set by name, checked

    // before anything changes, shown in its JSON.

    for l in ["ui", "flow"] {

        let body = format!(r#"{{"name":"{l}"}}"#);

        assert_eq!(api(app, "POST", "/api/v1/repos/andy/demo/labels", Some(&andy_admin), Some(&body)).await.0, StatusCode::CREATED);

    }

    assert_eq!(edit(&bob_rw, 2, r#"{"labels":["ui"]}"#).await.0, StatusCode::FORBIDDEN, "labels need triage, not authorship");

    let (st, v) = edit(&andy_pw, 2, r#"{"labels":["ui","flow"]}"#).await;

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

    let names = |v: &serde_json::Value| -> Vec<String> {

        v["labels"].as_array().unwrap().iter().map(|l| l["name"].as_str().unwrap().to_string()).collect()

    };

    assert_eq!(names(&v), ["flow", "ui"]);

    assert_eq!(v["title"], "Feat, renamed", "labels alone leave the text");

    let (st, _) = edit(&andy_pw, 2, r#"{"labels":["ui","nope"]}"#).await;

    assert_eq!(st, StatusCode::BAD_REQUEST, "an unknown label is refused");

    let (_, v) = api(app, "GET", "/api/v1/repos/andy/demo/proposals/2", None, None).await;

    assert_eq!(names(&v), ["flow", "ui"], "and nothing changed");

    let (_, v) = edit(&andy_pw, 2, r#"{"labels":["flow"]}"#).await;

    assert_eq!(names(&v), ["flow"]);

    assert_eq!(edit(&andy_ro, 2, r#"{"labels":[]}"#).await.0, StatusCode::FORBIDDEN);

    /// The repository's labels

    Label {

        #[command(subcommand)]

        cmd: LabelCmd,

    },

    /// Put labels on an issue or take them off (triage)

    Label(LabelChange),

    /// Put labels on a proposal or take them off (triage)

    Label(LabelChange),

}

#[derive(Subcommand)]

enum LabelCmd {

    /// The repository's labels

    List,

    /// Create a label, or change the one of that name (triage)

    Create {

        name: String,

        /// `#rrggbb` (default: one the hub picks)

        #[arg(long)]

        colour: Option<String>,

        #[arg(long, short, default_value = "")]

        description: String,

    },

    /// Delete a label, taking it off every issue and proposal (triage)

    Delete { name: String },

}

/// Labels to put on or take off an issue or proposal.

#[derive(clap::Args)]

struct LabelChange {

    number: i64,

    /// A label to add (repeatable)

    #[arg(long, short)]

    add: Vec<String>,

    /// A label to take off (repeatable)

    #[arg(long, short)]

    remove: Vec<String>,

}

impl LabelChange {

    /// The set after the change, from the one there now.

    fn apply(&self, now: &[hub_api::Label]) -> Result<Vec<String>> {

        if self.add.is_empty() && self.remove.is_empty() {

            bail!("say what to change: --add NAME or --remove NAME");

        }

        let mut names: Vec<String> = now.iter().map(|l| l.name.clone()).filter(|n| !self.remove.contains(n)).collect();

        for a in &self.add {

            if !names.contains(a) {

                names.push(a.clone());

            }

        }

        Ok(names)

    }

}

fn label_names(labels: &[String]) -> String {

    if labels.is_empty() {

        ui::dim("no labels")

    } else {

        labels.iter().map(|l| format!("[{l}]")).collect::<Vec<_>>().join(" ")

    }

        Cmd::Label { cmd } => label(&c, &t, cmd, json),

        }

        IssueCmd::Label(change) => {

            let path = format!("{base}/issues/{}", change.number);

            let now: Issue = c.get(&path)?;

            let labels = change.apply(&now.labels)?;

            let edit = hub_api::IssueEdit { title: None, body: None, labels: Some(labels.clone()), assignees: None, milestone: None };

            let i: Issue = c.send("PATCH", &path, &edit)?;

            if json {

                println!("{}", serde_json::to_string(&i)?);

            } else {

                println!("{} #{} {}", ui::ok("✔"), i.number, label_names(&labels));

            }

            let edit = hub_api::ProposalEdit { title, body, labels: None };

            }

        }

        ProposalCmd::Label(change) => {

            let path = format!("{base}/proposals/{}", change.number);

            let now: Proposal = c.get(&path)?;

            let labels = change.apply(&now.labels)?;

            let edit = hub_api::ProposalEdit { labels: Some(labels.clone()), ..Default::default() };

            let p: Proposal = c.send("PATCH", &path, &edit)?;

            if json {

                println!("{}", serde_json::to_string(&p)?);

            } else {

                println!("{} #{} {}", ui::ok("✔"), p.number, label_names(&labels));

            }

        }

    }

    Ok(0)

}

fn label(c: &Client, t: &Target, cmd: LabelCmd, json: bool) -> Result<i32> {

    let base = t.repo_path()?;

    match cmd {

        LabelCmd::List => {

            let path = format!("{base}/labels");

            if json {

                println!("{}", c.get_text(&path)?);

                return Ok(0);

            }

            let labels: Vec<hub_api::Label> = c.get(&path)?;

            if labels.is_empty() {

                println!("{}", ui::dim("No labels."));

            for l in labels {

                println!("{} {}  {}", ui::dim(&l.colour), l.name, ui::dim(&l.description));

            }

        }

        LabelCmd::Create { name, colour, description } => {

            let l: hub_api::Label = c.send("POST", &format!("{base}/labels"), &hub_api::NewLabel { name, colour, description })?;

            if json {

                println!("{}", serde_json::to_string(&l)?);

            } else {

                println!("{} label {} {}", ui::ok("✔"), l.name, ui::dim(&l.colour));

            }

        }

        LabelCmd::Delete { name } => {

            c.send_text("DELETE", &format!("{base}/labels/{}", enc(&name)), &serde_json::json!({}))?;

            println!("{} deleted label {name}", ui::ok("✔"));

JSON under `/api/v1`, bearer tokens, `application/json`, RFC 7807 problem responses (an unknown route too), cursor pagination (`?after=`), ETags on cacheable resources, and rate limits per token. Resources mirror the pages: `/repos/{owner}/{name}`, `/bookmarks`, `/changes/{hash}`, `/tree/{ref}/{path}`, `/file/{ref}/{path}`, `/blame`, `/history`, `/compare`, `/conflicts`, `/proposals` (`?state=open|draft|landed|closed|all`, open ones and drafts by default; a source bookmark may hold `/`, and `owner/name:bookmark` naming the repository itself is its own bookmark), `/proposals/{n}/comments|reviews|checks|files`, `PATCH /proposals/{n}` (the title and description, for its author or a maintainer, and `labels`, the whole set by name, for triage; what is not given stays), `POST /proposals/{n}/land` (repo:write: what the Land button does, `409` with the blockers when it cannot; a landed proposal keeps the changes it landed and reports `landed` with who, how (`web`, or `api (token NAME)`) and when, which its event, the audit log and the push record also say, adding when nobody approved), `/proposals/{n}/content/{base|head}/{path}` (a changed file's bytes in the target's state or the projected state, for editor diff views), `/issues` (creating an issue can set its labels, assignees and milestone; `PATCH /issues/{n}` edits the title and body for the author or triage, and replaces labels, assignees or the milestone for triage, recording each on the timeline; unknown names are refused before anything changes), `/labels` (`POST` creates or changes one, `DELETE /labels/{name}` removes it; triage), `/milestones`, `/releases` (`PATCH /releases/{tag}` changes the title, notes or prerelease flag, repo:write), `/tags`, `/trust`, `/pushes`, `/hooks`, `/checks`, `/user`, `/notifications` (the caller's inbox and unread count; `/notifications/{id}/read` and `/notifications/read` mark read; scope `user:read`), `/users/{name}`, `/orgs/{name}`, `/checks/{state}` (the checks on a state, named by its hash, by its heads joined with `+`, by the one head of a single-head state, or by a bookmark), `/checks/required` (`GET`, and `PUT` of the whole list by a repository admin: the checks a proposal needs, passed, to land), `/projects/{owner}` (list, create) and `/projects/{owner}/{n}` (the board as the caller may see it, `PATCH` for title, description, privacy and closing, `/cards` to add a reference or note to a column named by id or name, `/cards/{id}` to move or remove one; `repo:write` and the page's rights to change), `/flow/runs` (`GET`: runs newest first, `?before=N&limit=`; `POST {"bookmark"}` or `{"change"}`, repo:write: run a bookmark's current state, the default bookmark when none is named, or one change's state), `/flow/runs/{n}` (a run with its jobs), `/flow/runs/{n}/jobs/{job}/log` (`?after=seq&limit=`) and `/flow/runs/{n}/rerun` (repo:write: a finished run again), both answering `201 {"number", "url"}` or `409` with why nothing started, `/search`. A change's author carries the account its key is linked to, or `null` and a `note` saying the key is not linked and where its owner links it (the change page shows a "key not linked" tag, with a link to Settings → Keys for signed-in viewers). Shapes reuse `oxy --json` shapes wherever one exists (change, status, blame, diff) so tools written against the CLI work against the hub. `crates/hub-api` holds the types with `serde` derives and is what the runner and the VS Code extension will link.