Coverage / crates/hub/src/web/releases.rs 73.9%

    pub fn built_by(&self, asset: &i64) -> Option<&db::flow::Provenance> {

        self.built.get(asset)

    }

async fn views(app: &Shared, repo: &RepoName, row: &db::repos::RepoRow) -> Result<Vec<ReleaseView>, sqlx::Error> {

    let list = rdb::list(&app.db, row.id).await?;

    let latest = rdb::latest(&app.db, row.id).await?.map(|r| r.id);

    let tags: HashMap<String, (Vec<String>, Option<String>)> = app

        .repos

        .read(repo, |r, _| Ok(view::tags(r)?.into_iter().map(|t| (t.name, (t.heads, t.signer))).collect()))

        .await

        .unwrap_or_default();

    let mut out = Vec::new();

    for r in list {

        let assets = rdb::assets(&app.db, r.id).await?;

        let mut built = HashMap::new();

        for a in &assets {

            if let Some(p) = db::flow::provenance(&app.db, row.id, &a.hash).await? {

                built.insert(a.id, p);

            }

        let (heads, signer) = tags.get(&r.tag).cloned().unwrap_or_default();

        let notes_html = super::issues::markdown(app, row, &r.tag, &r.notes).await;

        out.push(ReleaseView { latest: Some(r.id) == latest, r, notes_html, assets, heads, signer, built });

    Ok(out)

}

pub async fn list(

    State(app): State<Shared>,

    viewer: Viewer,

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

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

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

    let (repo, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;

    let releases = views(&app, &repo, &row).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let tags: Vec<String> =

        app.repos.read(&repo, |r, _| Ok(view::tags(r)?.into_iter().map(|t| t.name).collect())).await.unwrap_or_default();

    let unreleased = tags.into_iter().filter(|t| !releases.iter().any(|r| &r.r.tag == t)).collect();

    Ok(Page(ReleasesPage { shell, repo: RepoShell::new(&app, &row, "releases").with_role(role), releases, unreleased, one: false }))

}

pub async fn show(

    State(app): State<Shared>,

    viewer: Viewer,

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

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

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

    let (repo, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;

    let releases: Vec<ReleaseView> =

        views(&app, &repo, &row).await.map_err(|e| Error::from_db(shell.clone(), e))?.into_iter().filter(|r| r.r.tag == tag).collect();

    if releases.is_empty() {

    }

    Ok(Page(ReleasesPage { shell, repo: RepoShell::new(&app, &row, "releases").with_role(role), releases, unreleased: vec![], one: true }))

}

async fn generated_notes(app: &Shared, repo: &RepoName, repo_id: i64, tag: &str) -> String {

    let previous = rdb::list(&app.db, repo_id).await.unwrap_or_default().into_iter().find(|r| r.tag != tag).map(|r| r.tag);

    let tag = tag.to_string();

    app.repos

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

            let Some(heads) = r.tag_heads(&tag)? else { return Ok(String::new()) };

            let now = cache.load(r, &heads)?;

            let before: Vec<ChangeHash> = match &previous {

                Some(p) => r.tag_heads(p)?.unwrap_or_default(),

                None => vec![],

            let then = cache.load(r, &before)?;

            let mut added: Vec<_> = now

                .state

                .changes()

                .filter(|(h, _)| !then.state.contains(h))

                .map(|(h, m)| (m.hlc, *h, m.message.clone(), m.author))

                .collect();

            added.sort_by_key(|a| std::cmp::Reverse(a.0));

            let mut out = match &previous {

                Some(p) => format!("Changes since {p}:\n\n"),

                None => "Changes:\n\n".to_string(),

            for (_, h, message, author) in added {

                let who = view::author(r, &author, &message).name;

                out.push_str(&format!("- {} ({}, {})\n", message.lines().next().unwrap_or(""), &h.to_hex()[..12], who));

            }

            Ok(out)

        })

        .await

        .unwrap_or_default()

}

pub async fn new_form(

    State(app): State<Shared>,

    viewer: Viewer,

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

    Query(q): Query<NewQuery>,

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

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

    require(&viewer, &shell)?;

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

    let tags: Vec<String> = app

        .repos

        .read(&repo, |r, _| Ok(view::tags(r)?.into_iter().map(|t| t.name).collect()))

        .await

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

    let tag = q.tag.filter(|t| tags.contains(t)).or_else(|| tags.first().cloned()).unwrap_or_default();

    let notes = if tag.is_empty() { String::new() } else { generated_notes(&app, &repo, row.id, &tag).await };

    Ok(Page(NewReleasePage { shell, repo: RepoShell::new(&app, &row, "releases").with_role(role), tags, tag, notes, error: None }))

}

pub async fn create_release(

    app: &Shared,

    repo: &RepoName,

    row: &db::repos::RepoRow,

    me: &accounts::Account,

    tag: &str,

    title: &str,

    notes: Option<String>,

    prerelease: bool,

) -> Result<rdb::Release, String> {

    let exists = app

        .repos

        .read(repo, {

            let t = tag.to_string();

            move |r, _| Ok(r.tag_heads(&t)?.is_some())

        .await

        .map_err(|e| e.to_string())?;

    if !exists {

        return Err(format!("there is no tag {tag}; create it with oxy tag create and push it"));

    }

    if rdb::get(&app.db, row.id, tag).await.map_err(|e| e.to_string())?.is_some() {

    }

    let notes = match notes {

        Some(n) => n,

        None => generated_notes(app, repo, row.id, tag).await,

    let title = if title.trim().is_empty() { tag.to_string() } else { title.trim().to_string() };

    let r = rdb::create(&app.db, row.id, tag, &title, notes.trim(), prerelease, Some((me.id, &me.username)))

        .await

        .map_err(|e| e.to_string())?;

    accounts::audit(&app.db, Some(me), "release.published", &format!("{}@{tag}", row.slug()), "").await.ok();

    crate::hooks::emit(

        app,

        row,

        "release.published",

        &me.username,

        serde_json::json!({ "tag": tag, "title": title, "prerelease": prerelease }),

    )

    .await;

    crate::notify::deliver(

        app,

        crate::notify::Event {

            kind: "release",

            title: format!("{} released {title}", row.slug()),

            url: format!("/{}/releases/tag/{tag}", row.slug()),

            actor: me,

            repo_id: row.id,

            thread: None,

            mention_text: "",

            direct: vec![],

        },

    )

    .await;

    Ok(r)

}

pub async fn create(

    State(app): State<Shared>,

    viewer: Viewer,

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

    Form(f): Form<NewForm>,

) -> Result<Response, Error> {

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

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

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

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

    match create_release(&app, &repo, &row, &me.account, &f.tag, &f.title, Some(f.notes.clone()), f.prerelease.is_some()).await {

        Ok(r) => Ok(Redirect::to(&format!("/{owner}/{name}/releases/tag/{}", r.tag)).into_response()),

}

pub(crate) fn blob_path(app: &Shared, hash: &str) -> std::path::PathBuf {

    app.config.data.join("assets").join(&hash[..2]).join(hash)

}

pub async fn store_asset(app: &Shared, release_id: i64, name: &str, content_type: &str, bytes: &[u8]) -> Result<rdb::Asset, String> {

    let name = name.rsplit(['/', '\\']).next().unwrap_or(name).trim();

    if name.is_empty() || name.starts_with('.') || name.len() > 200 {

    }

    if bytes.len() as u64 > app.config.limits.asset_limit.0 {

    }

    let hash = hex::encode(blake3::hash(bytes).as_bytes());

    let path = blob_path(app, &hash);

    if !path.exists() {

        tokio::fs::create_dir_all(path.parent().unwrap()).await.map_err(|e| e.to_string())?;

        let tmp = path.with_extension("partial");

        tokio::fs::write(&tmp, bytes).await.map_err(|e| e.to_string())?;

        tokio::fs::rename(&tmp, &path).await.map_err(|e| e.to_string())?;

    let ct = if content_type.is_empty() { "application/octet-stream" } else { content_type };

    rdb::add_asset(&app.db, release_id, name, bytes.len() as i64, &hash, ct).await.map_err(|e| e.to_string())

}

pub async fn download(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name, id, file)): Path<(String, String, i64, String)>,

) -> Result<Response, Error> {

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

    let (_, row, _) = lookup(&app, &shell, &viewer, &owner, &name).await?;

    let e = |e| Error::from_db(shell.clone(), e);

    let asset: Option<rdb::Asset> =

        sqlx::query_as("SELECT a.* FROM release_assets a JOIN releases r ON r.id = a.release_id WHERE a.id = $1 AND r.repo_id = $2")

            .bind(id)

            .bind(row.id)

            .fetch_optional(&app.db)

            .await

            .map_err(e)?;

    let Some(a) = asset.filter(|a| a.name == file) else { return Err(Error::not_found(shell)) };

    let bytes = tokio::fs::read(blob_path(&app, &a.hash)).await.map_err(|_| Error::not_found(shell.clone()))?;

    rdb::count_download(&app.db, a.id).await.ok();

    Ok((

        [

            (header::CONTENT_TYPE, a.content_type.clone()),

            (header::CONTENT_DISPOSITION, format!("attachment; filename=\"{}\"", a.name.replace('"', ""))),