Stars, topics, and a sortable, filterable Explore 1553bfc9ae53

-- Stars and topics (hub spec §6: explore).

CREATE TABLE stars (

    account_id INTEGER NOT NULL REFERENCES accounts(id) ON DELETE CASCADE,

    repo_id    INTEGER NOT NULL REFERENCES repositories(id) ON DELETE CASCADE,

    at_ms      INTEGER NOT NULL,

    PRIMARY KEY (account_id, repo_id)

);

CREATE INDEX stars_by_repo ON stars (repo_id);

-- Space-separated, lower case.

ALTER TABLE repositories ADD COLUMN topics TEXT NOT NULL DEFAULT '';

    /// Space-separated topics (migration 0010).

    #[sqlx(default)]

    pub topics: String,

    pub fn topic_list(&self) -> Vec<&str> {

        self.topics.split_whitespace().collect()

    }

/// Topics from user input: comma or space separated, lower-cased,

/// letters, digits and dashes, at most 35 characters each and 20 in all.

/// Returns the stored form or what is wrong.

pub fn parse_topics(input: &str) -> Result<String, String> {

    let mut out: Vec<String> = Vec::new();

    for t in input.split([',', ' ', '\n', '\t']).map(|t| t.trim().to_ascii_lowercase()).filter(|t| !t.is_empty()) {

        if t.len() > 35 || !t.chars().all(|c| c.is_ascii_alphanumeric() || c == '-') || t.starts_with('-') {

            return Err(format!("\"{t}\" is not a topic: use letters, digits and dashes, up to 35 characters"));

        }

        if !out.contains(&t) {

            out.push(t);

        }

    }

    if out.len() > 20 {

        return Err("At most 20 topics.".into());

    }

    Ok(out.join(" "))

}

pub async fn set_topics(pool: &Pool, id: i64, topics: &str) -> sqlx::Result<()> {

    sqlx::query("UPDATE repositories SET topics = ? WHERE id = ?").bind(topics).bind(id).execute(pool).await?;

    Ok(())

}

/// Star or unstar; returns whether it is now starred.

pub async fn toggle_star(pool: &Pool, account_id: i64, repo_id: i64) -> sqlx::Result<bool> {

    let gone = sqlx::query("DELETE FROM stars WHERE account_id = ? AND repo_id = ?").bind(account_id).bind(repo_id).execute(pool).await?;

    if gone.rows_affected() > 0 {

        return Ok(false);

    }

    sqlx::query("INSERT INTO stars (account_id, repo_id, at_ms) VALUES (?, ?, ?)")

        .bind(account_id)

        .bind(repo_id)

        .bind(now_ms())

        .execute(pool)

        .await?;

    Ok(true)

}

pub async fn starred(pool: &Pool, account_id: i64, repo_id: i64) -> sqlx::Result<bool> {

    let n: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM stars WHERE account_id = ? AND repo_id = ?")

        .bind(account_id)

        .bind(repo_id)

        .fetch_one(pool)

        .await?;

    Ok(n > 0)

}

/// Stars and watchers of one repository.

pub async fn counts(pool: &Pool, repo_id: i64) -> sqlx::Result<(i64, i64)> {

    let stars: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM stars WHERE repo_id = ?").bind(repo_id).fetch_one(pool).await?;

    let watchers: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM watches WHERE repo_id = ?").bind(repo_id).fetch_one(pool).await?;

    Ok((stars, watchers))

}

/// Star counts of every starred repository.

pub async fn star_counts(pool: &Pool) -> sqlx::Result<std::collections::HashMap<i64, i64>> {

    let rows: Vec<(i64, i64)> = sqlx::query_as("SELECT repo_id, COUNT(*) FROM stars GROUP BY repo_id").fetch_all(pool).await?;

    Ok(rows.into_iter().collect())

}

#[cfg(test)]

mod topic_tests {

    use super::parse_topics;

    #[test]

    fn topics_are_normalised_and_checked() {

        assert_eq!(parse_topics("Rust, vcs  retro-computing,rust").unwrap(), "rust vcs retro-computing");

        assert_eq!(parse_topics("").unwrap(), "");

        assert!(parse_topics("c++").is_err());

        assert!(parse_topics("-lead").is_err());

        assert!(parse_topics(&"x".repeat(36)).is_err());

        assert!(parse_topics(&(0..21).map(|i| format!("t{i}")).collect::<Vec<_>>().join(" ")).is_err());

    }

}

use axum::extract::{Path, Query, State};

use serde::Deserialize;

    /// Explore's controls: the filter text, the sort, the topic.

    q: String,

    sort: String,

    topic: String,

    stars: std::collections::HashMap<i64, i64>,

}

impl HomePage {

    fn star_count(&self, id: &i64) -> i64 {

        self.stars.get(id).copied().unwrap_or(0)

    }

}

/// `/explore?q=&sort=activity|stars|name&topic=`.

#[derive(Deserialize, Default)]

pub struct ExploreQuery {

    #[serde(default)]

    q: String,

    #[serde(default)]

    sort: String,

    #[serde(default)]

    topic: String,

        return Ok(explore(State(app), viewer, Query(ExploreQuery::default())).await?.into_response());

/// `/explore`: every repository the viewer may see, filtered by text and

/// topic, sorted by recent activity (the default), stars or name.

pub async fn explore(State(app): State<Shared>, viewer: Viewer, Query(q): Query<ExploreQuery>) -> Result<Page<HomePage>, Error> {

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

    let mut repos = visible(&app, &shell, &viewer, db::repos::list(&app.db).await.map_err(db_err)?).await?;

    let stars = db::repos::star_counts(&app.db).await.map_err(db_err)?;

    let needle = q.q.trim().to_lowercase();

    if !needle.is_empty() {

        repos.retain(|r| {

            r.slug().to_lowercase().contains(&needle)

                || r.description.to_lowercase().contains(&needle)

                || r.topic_list().iter().any(|t| t.contains(&needle))

        });

    }

    let topic = q.topic.trim().to_lowercase();

    if !topic.is_empty() {

        repos.retain(|r| r.topic_list().contains(&topic.as_str()));

    }

    let sort = match q.sort.as_str() {

        "stars" | "name" => q.sort.clone(),

        _ => "activity".to_string(),

    };

    match sort.as_str() {

        "stars" => repos.sort_by_key(|r| (std::cmp::Reverse(stars.get(&r.id).copied().unwrap_or(0)), std::cmp::Reverse(r.updated_ms))),

        "name" => repos.sort_by_key(|r| (r.name.to_lowercase(), r.owner.to_lowercase())),

        _ => repos.sort_by_key(|r| std::cmp::Reverse(r.updated_ms)),

    }

    Ok(Page(HomePage { description: app.config.site.description.clone(), shell, repos, owner: None, q: q.q, sort, topic, stars }))

    let stars = db::repos::star_counts(&app.db).await.unwrap_or_default();

    Ok(Page(HomePage {

        description: String::new(),

        shell,

        repos,

        owner: Some(owner),

        q: String::new(),

        sort: "activity".into(),

        topic: String::new(),

        stars,

    })

    .into_response())

/// Star or unstar a repository.

pub async fn star(

    State(app): State<Shared>,

    viewer: Viewer,

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

    Form(f): Form<super::session::CsrfForm>,

) -> Result<Response, Error> {

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

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

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

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

    db::repos::toggle_star(&app.db, me.account.id, row.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    Ok(Redirect::to(&format!("/{owner}/{name}")).into_response())

}

        .route("/{owner}/{name}/star", post(issues::star))

    starred: bool,

    stars: i64,

    watchers: i64,

    topics: Vec<String>,

    let starred = match viewer.account() {

        Some(a) => crate::db::repos::starred(&app.db, a.id, row.id).await.unwrap_or(false),

        None => false,

    };

    let (stars, watchers) = crate::db::repos::counts(&app.db, row.id).await.unwrap_or((0, 0));

    let topics = row.topic_list().into_iter().map(String::from).collect();

    Ok(Page(OverviewPage { shell, repo: rs, o, readme_html, watching, latest_release, quickstart, fork, starred, stars, watchers, topics }))

    #[serde(default)]

    topics: String,

    let topics = match db::repos::parse_topics(&f.topics) {

        Ok(t) => t,

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

    };

    db::repos::set_topics(&app.db, row.id, &topics).await.map_err(e)?;

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

async fn stars_topics_and_explore() {

    let h = hub().await;

    let app = &h.app;

    let andy = register(app, "andy").await;

    let bob = register(app, "bob").await;

    for (name, desc) in [("alpha", "An emulator"), ("beta", "A compiler"), ("gamma", "Retro games")] {

        app.repos.create(&RepoName::parse(&format!("andy/{name}")).unwrap(), None).unwrap();

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

    }

    // Topics through settings; bad ones are refused.

    let csrf = csrf_of(&get(app, "/andy/gamma/settings", Some(&andy)).await.body);

    let r = post(

        app,

        "/andy/gamma/settings",

        Some(&andy),

        &format!("_csrf={csrf}&description=Retro+games&default_bookmark=main&visibility=public&topics=c%2B%2B"),

    )

    .await;

    assert!(r.body.contains("is not a topic"), "{}", r.body);

    let r = post(

        app,

        "/andy/gamma/settings",

        Some(&andy),

        &format!("_csrf={csrf}&description=Retro+games&default_bookmark=main&visibility=public&topics=Retro%2C+6502"),

    )

    .await;

    assert!(r.body.contains("Saved"), "{}", r.body);

    assert_eq!(db::repos::get(&app.db, "andy", "gamma").await.unwrap().unwrap().topics, "retro 6502");

    let page = get(app, "/andy/gamma", None).await;

    assert!(page.body.contains(r#"href="/explore?topic=retro""#), "{}", page.body);

    // Stars: bob stars beta and gamma, andy stars gamma; toggling unstars.

    for (who, repo) in [(&bob, "beta"), (&bob, "gamma"), (&andy, "gamma"), (&andy, "alpha")] {

        let csrf = csrf_of(&get(app, &format!("/andy/{repo}"), Some(who)).await.body);

        assert_eq!(post(app, &format!("/andy/{repo}/star"), Some(who), &format!("_csrf={csrf}")).await.status, StatusCode::SEE_OTHER);

    }

    let csrf = csrf_of(&get(app, "/andy/alpha", Some(&andy)).await.body);

    post(app, "/andy/alpha/star", Some(&andy), &format!("_csrf={csrf}")).await;

    assert!(get(app, "/andy/gamma", Some(&bob)).await.body.contains("★ UNSTAR"));

    assert!(get(app, "/andy/gamma", None).await.body.contains("★ 2"));

    assert!(get(app, "/andy/alpha", None).await.body.contains("★ 0"), "unstarred again");

    // Explore: sort by stars, by name, filter by text and by topic.

    let order = |b: &str| {

        ["alpha", "beta", "gamma"]

            .into_iter()

            .map(|n| (b.find(&format!("/andy/{n}\"")).unwrap_or(usize::MAX), n))

            .collect::<std::collections::BTreeMap<_, _>>()

            .into_values()

            .collect::<Vec<_>>()

    };

    assert_eq!(order(&get(app, "/explore?sort=stars", None).await.body)[..2], ["gamma", "beta"]);

    assert_eq!(order(&get(app, "/explore?sort=name", None).await.body), ["alpha", "beta", "gamma"]);

    let filtered = get(app, "/explore?q=compiler", None).await.body;

    assert!(filtered.contains("/andy/beta\"") && !filtered.contains("/andy/alpha\""), "{filtered}");

    let by_topic = get(app, "/explore?topic=6502", None).await.body;

    assert!(by_topic.contains("/andy/gamma\"") && !by_topic.contains("/andy/beta\""), "{by_topic}");

}

| `/explore` | Every repository the viewer may see; `q` filters by name, description or topic, `topic` by one topic, `sort` is `activity` (default), `stars` or `name`; each row shows its topics and stars. Topics are set under repository settings (letters, digits and dashes, at most 20); anyone signed in can star a repository, and the overview shows star and watcher counts |

{% if owner.is_none() %}

<form class="bar explore-bar" method="get" action="/explore">

  <input type="search" name="q" value="{{ q }}" placeholder="Filter by name, description or topic" aria-label="Filter repositories">

  <select name="sort" aria-label="Sort">

    <option value="activity"{% if sort == "activity" %} selected{% endif %}>recently active</option>

    <option value="stars"{% if sort == "stars" %} selected{% endif %}>most stars</option>

    <option value="name"{% if sort == "name" %} selected{% endif %}>name</option>

  </select>

  {% if !topic.is_empty() %}<input type="hidden" name="topic" value="{{ topic }}"><span class="topic">{{ topic }} <a href="/explore?sort={{ sort }}&amp;q={{ q }}" aria-label="Clear the topic">×</a></span>{% endif %}

  <button type="submit" class="small">FILTER</button>

</form>

{% endif %}

      {% if !r.topics.is_empty() %}<p class="topics">{% for t in r.topic_list() %}<a class="topic" href="/explore?topic={{ t }}">{{ t }}</a>{% endfor %}</p>{% endif %}

    <div class="right small">{% if star_count(r.id) > 0 %}<span class="mute" title="stars">★ {{ star_count(r.id) }}</span> · {% endif %}updated <time title="{{ r.updated_ms|when_i }}">{{ r.updated_ms|ago_i }}</time></div>

    {% if !topics.is_empty() %}<p class="topics">{% for t in topics %}<a class="topic" href="/explore?topic={{ t }}">{{ t }}</a>{% endfor %}</p>{% endif %}

    <p class="small mute counts-line"><span title="stars">★ {{ stars }}</span> · <span title="watchers">👁 {{ watchers }}</span></p>

    {% if shell.user.is_some() %}<form class="inline" method="post" action="{{ repo.url }}/star"><input type="hidden" name="_csrf" value="{{ shell.csrf }}"><button type="submit" class="small">{% if starred %}★ UNSTAR{% else %}☆ STAR{% endif %}</button></form>

    <form class="inline" method="post" action="{{ repo.url }}/watch"><input type="hidden" name="_csrf" value="{{ shell.csrf }}"><button type="submit" class="small">{% if watching %}UNWATCH{% else %}WATCH{% endif %}</button></form>

  <label for="topics">Topics</label><input type="text" id="topics" name="topics" value="{{ row.topics }}" placeholder="rust version-control retro">

  <p class="small mute">Separated by spaces or commas; letters, digits and dashes. People find repositories by them under Explore.</p>

/* topics, stars, explore */

.topics { margin: 4px 0 0; display: flex; flex-wrap: wrap; gap: 4px; }

.topic { display: inline-block; font-size: 12px; padding: 1px 8px; border-radius: 10px; background: color-mix(in srgb, var(--acc) 14%, transparent); color: var(--acc); }

.topic:hover { text-decoration: none; background: color-mix(in srgb, var(--acc) 24%, transparent); }

.explore-bar input[type=search] { flex: 1 1 240px; }

.counts-line span { margin-right: 2px; }