forks.rs 86.7%

72 of 83 lines run, 11 of 34 functions · run #494 on main · run missed

//! Forks (hub spec §4): making one, listing them, and proposing from one
//! back to the repository it came from.

use super::settings::{csrf, require};
use super::{filters, lookup, Error, Page, RepoShell, Shell};
use crate::auth::{roles, Viewer};
use crate::db::{self, accounts};
use crate::repos::RepoName;
use crate::Shared;
use askama::Template;
use axum::extract::{Form, Path, State};
use axum::response::{IntoResponse, Redirect, Response};
use serde::Deserialize;

#[derive(Template)]
#[template(path = "fork_new.html")]
pub struct ForkPage {
    shell: Shell,
    repo: RepoShell,
    owners: Vec<String>,
    name: String,
    error: Option<String>,
}

pub async fn form(State(app): State<Shared>, viewer: Viewer, Path((owner, name)): Path<(String, String)>) -> Result<Page<ForkPage>, Error> {
    let shell = Shell::new(&app, &format!("/{owner}/{name}/fork"), &viewer);
    let me = require(&viewer, &shell)?;
    let (_, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;
    let owners = super::repo_settings::owners_for(&app, &me.account).await;
    Ok(Page(ForkPage { repo: RepoShell::new(&app, &row, "code").with_role(role), shell, owners, name, error: None }))
}

#[derive(Deserialize)]
pub struct ForkForm {
    #[serde(rename = "_csrf")]
    csrf_token: String,
    owner: String,
    name: String,
}

/// Anyone who can read a repository may fork it under an owner they may
/// create repositories for; the fork keeps the source's visibility.
pub async fn create(
    State(app): State<Shared>,
    viewer: Viewer,
    Path((owner, name)): Path<(String, String)>,
    Form(f): Form<ForkForm>,
) -> Result<Response, Error> {
    let shell = Shell::new(&app, &format!("/{owner}/{name}/fork"), &viewer);
    let me = require(&viewer, &shell)?;
    csrf(&viewer, &f.csrf_token, &shell)?;
    let (source, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;
    let owners = super::repo_settings::owners_for(&app, &me.account).await;
    let page = |msg: &str| {
        Page(ForkPage {
            shell: shell.clone(),
            repo: RepoShell::new(&app, &row, "code").with_role(role),
            owners: owners.clone(),
            name: f.name.clone(),
            error: Some(msg.into()),
        })
        .into_response()
    };
    let Some(dest) = RepoName::new(f.owner.trim(), f.name.trim()) else {
        return Ok(page("A repository name is letters, digits, dots, dashes and underscores."));
    };
    if dest == source {
        return Ok(page("Pick another owner or name: a repository cannot be its own fork."));
    }
    if !roles::may_create_under(&app.db, &me.account, &dest.owner).await.map_err(|e| Error::from_db(shell.clone(), e))? {
        return Ok(page("You cannot create repositories under that owner."));
    }
    if db::repos::get(&app.db, &dest.owner, &dest.name).await.map_err(|e| Error::from_db(shell.clone(), e))?.is_some()
        || app.repos.exists(&dest)
    {
        return Ok(page("That repository exists."));
    }
    app.repos.fork(&source, &dest).await.map_err(|e| Error::from_repo(shell.clone(), e))?;
    let created = db::repos::create(&app.db, &dest.owner, &dest.name, &row.description, row.visibility())
        .await
        .map_err(|e| Error::from_db(shell.clone(), e))?;
    db::repos::set_forked_from(&app.db, created.id, row.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;
    accounts::audit(&app.db, Some(&me.account), "repo.forked", &dest.to_string(), &source.to_string()).await.ok();
    Ok(Redirect::to(&dest.url()).into_response())
}

#[derive(Template)]
#[template(path = "forks.html")]
pub struct ForksPage {
    shell: Shell,
    repo: RepoShell,
    forks: Vec<db::repos::RepoRow>,
}

pub async fn list(
    State(app): State<Shared>,
    viewer: Viewer,
    Path((owner, name)): Path<(String, String)>,
) -> Result<Page<ForksPage>, Error> {
    let shell = Shell::new(&app, &format!("/{owner}/{name}/forks"), &viewer);
    let (_, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;
    let all = db::repos::forks_of(&app.db, row.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;
    let forks = super::home::visible(&app, &shell, &viewer, all).await?;
    Ok(Page(ForksPage { repo: RepoShell::new(&app, &row, "code").with_role(role), shell, forks }))
}

/// What the overview says about forks: where this one came from (when the
/// viewer may see it) and how many forks it has.
pub struct ForkInfo {
    pub upstream: Option<db::repos::RepoRow>,
    pub forks: usize,
}

pub async fn info(app: &Shared, shell: &Shell, viewer: &Viewer, row: &db::repos::RepoRow) -> ForkInfo {
    let upstream = match row.forked_from {
        Some(id) => match db::repos::get_by_id(&app.db, id).await {
            Ok(Some(up)) => super::home::visible(app, shell, viewer, vec![up]).await.ok().and_then(|mut v| v.pop()),
            _ => None,
        },
        None => None,
    };
    let forks = match db::repos::forks_of(&app.db, row.id).await {
        Ok(all) => super::home::visible(app, shell, viewer, all).await.map(|v| v.len()).unwrap_or(0),
        Err(_) => 0,
    };
    ForkInfo { upstream, forks }
}

1		//! Forks (hub spec §4): making one, listing them, and proposing from one
2		//! back to the repository it came from.
3
4		use super::settings::{csrf, require};
5		use super::{filters, lookup, Error, Page, RepoShell, Shell};
6		use crate::auth::{roles, Viewer};
7		use crate::db::{self, accounts};
8		use crate::repos::RepoName;
9		use crate::Shared;
10		use askama::Template;
11		use axum::extract::{Form, Path, State};
12		use axum::response::{IntoResponse, Redirect, Response};
13		use serde::Deserialize;
14
15		#[derive(Template)]
16		#[template(path = "fork_new.html")]
17		pub struct ForkPage {
18		shell: Shell,
19		repo: RepoShell,
20		owners: Vec<String>,
21		name: String,
22		error: Option<String>,
23		}
24
25	1×	pub async fn form(State(app): State<Shared>, viewer: Viewer, Path((owner, name)): Path<(String, String)>) -> Result<Page<ForkPage>, Error> {
26	1×	let shell = Shell::new(&app, &format!("/{owner}/{name}/fork"), &viewer);
27	1×	let me = require(&viewer, &shell)?;
28	1×	let (_, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;
29	1×	let owners = super::repo_settings::owners_for(&app, &me.account).await;
30	1×	Ok(Page(ForkPage { repo: RepoShell::new(&app, &row, "code").with_role(role), shell, owners, name, error: None }))
31	1×	}
32
33		#[derive(Deserialize)]
34		pub struct ForkForm {
35		#[serde(rename = "_csrf")]
36		csrf_token: String,
37		owner: String,
38		name: String,
39		}
40
41		/// Anyone who can read a repository may fork it under an owner they may
42		/// create repositories for; the fork keeps the source's visibility.
43	2×	pub async fn create(
44	2×	State(app): State<Shared>,
45	2×	viewer: Viewer,
46	2×	Path((owner, name)): Path<(String, String)>,
47	2×	Form(f): Form<ForkForm>,
48	2×	) -> Result<Response, Error> {
49	2×	let shell = Shell::new(&app, &format!("/{owner}/{name}/fork"), &viewer);
50	2×	let me = require(&viewer, &shell)?;
51	2×	csrf(&viewer, &f.csrf_token, &shell)?;
52	2×	let (source, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;
53	2×	let owners = super::repo_settings::owners_for(&app, &me.account).await;
54	2×	let page = \|msg: &str\| {
55	1×	Page(ForkPage {
56	1×	shell: shell.clone(),
57	1×	repo: RepoShell::new(&app, &row, "code").with_role(role),
58	1×	owners: owners.clone(),
59	1×	name: f.name.clone(),
60	1×	error: Some(msg.into()),
61	1×	})
62	1×	.into_response()
63	1×	};
64	2×	let Some(dest) = RepoName::new(f.owner.trim(), f.name.trim()) else {
65	0×	return Ok(page("A repository name is letters, digits, dots, dashes and underscores."));
66		};
67	2×	if dest == source {
68	0×	return Ok(page("Pick another owner or name: a repository cannot be its own fork."));
69	2×	}
70	2×	if !roles::may_create_under(&app.db, &me.account, &dest.owner).await.map_err(\|e\| Error::from_db(shell.clone(), e))? {
71	1×	return Ok(page("You cannot create repositories under that owner."));
72	1×	}
73	1×	if db::repos::get(&app.db, &dest.owner, &dest.name).await.map_err(\|e\| Error::from_db(shell.clone(), e))?.is_some()
74	1×	\|\| app.repos.exists(&dest)
75		{
76	0×	return Ok(page("That repository exists."));
77	1×	}
78	1×	app.repos.fork(&source, &dest).await.map_err(\|e\| Error::from_repo(shell.clone(), e))?;
79	1×	let created = db::repos::create(&app.db, &dest.owner, &dest.name, &row.description, row.visibility())
80	1×	.await
81	1×	.map_err(\|e\| Error::from_db(shell.clone(), e))?;
82	1×	db::repos::set_forked_from(&app.db, created.id, row.id).await.map_err(\|e\| Error::from_db(shell.clone(), e))?;
83	1×	accounts::audit(&app.db, Some(&me.account), "repo.forked", &dest.to_string(), &source.to_string()).await.ok();
84	1×	Ok(Redirect::to(&dest.url()).into_response())
85	2×	}
86
87		#[derive(Template)]
88		#[template(path = "forks.html")]
89		pub struct ForksPage {
90		shell: Shell,
91		repo: RepoShell,
92		forks: Vec<db::repos::RepoRow>,
93		}
94
95	1×	pub async fn list(
96	1×	State(app): State<Shared>,
97	1×	viewer: Viewer,
98	1×	Path((owner, name)): Path<(String, String)>,
99	1×	) -> Result<Page<ForksPage>, Error> {
100	1×	let shell = Shell::new(&app, &format!("/{owner}/{name}/forks"), &viewer);
101	1×	let (_, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;
102	1×	let all = db::repos::forks_of(&app.db, row.id).await.map_err(\|e\| Error::from_db(shell.clone(), e))?;
103	1×	let forks = super::home::visible(&app, &shell, &viewer, all).await?;
104	1×	Ok(Page(ForksPage { repo: RepoShell::new(&app, &row, "code").with_role(role), shell, forks }))
105	1×	}
106
107		/// What the overview says about forks: where this one came from (when the
108		/// viewer may see it) and how many forks it has.
109		pub struct ForkInfo {
110		pub upstream: Option<db::repos::RepoRow>,
111		pub forks: usize,
112		}
113
114	51×	pub async fn info(app: &Shared, shell: &Shell, viewer: &Viewer, row: &db::repos::RepoRow) -> ForkInfo {
115	51×	let upstream = match row.forked_from {
116	1×	Some(id) => match db::repos::get_by_id(&app.db, id).await {
117	1×	Ok(Some(up)) => super::home::visible(app, shell, viewer, vec![up]).await.ok().and_then(\|mut v\| v.pop()),
118	0×	_ => None,
119		},
120	50×	None => None,
121		};
122	51×	let forks = match db::repos::forks_of(&app.db, row.id).await {
123	51×	Ok(all) => super::home::visible(app, shell, viewer, all).await.map(\|v\| v.len()).unwrap_or(0),
124	0×	Err(_) => 0,
125		};
126	51×	ForkInfo { upstream, forks }
127	51×	}

`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet

Coverage / crates/hub/src/web/forks.rs 86.7%

Keyboard