Directory lists the feeds inside an OPML, not the OPML

Popular still counts an OPML as one feed, since everyone subscribed to it
counts for every feed inside and they would bury the rest. The directory is
for finding a show, so it lists them one by one and never the OPML. A feed
inside an OPML that looks private is hidden with it.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TAC7sLVqfKmY6rsTLXzNgk

src/web.rs

@@ -579,25 +579,36 @@ struct PopularRow {
 }
 
 /// Every feed that may be listed, with everyone counted, you included, most subscribers
-/// first. Popular is the top of it, the directory is all of it, and it is all that
-/// `subscribe_popular` will subscribe you to.
-fn popular(state: &WebState, user_id: i64) -> Result<Vec<PopularRow>> {
+/// first. Popular is the top of one list and the directory is all of the other, and between
+/// them they are all that `subscribe_popular` will subscribe you to.
+///
+/// `folders` says how an OPML appears. Popular lists the OPML once and not the feeds inside:
+/// everyone subscribed to it counts for every one of them, and eighty of those would bury
+/// everything anyone chose on purpose. The directory, which is for finding a show, lists the
+/// feeds inside and never the OPML.
+fn popular(state: &WebState, user_id: i64, folders: bool) -> Result<Vec<PopularRow>> {
     let db = &state.ctx.db;
     let mine: std::collections::HashSet<String> =
         db.subscriptions_for(user_id)?.into_iter().map(|s| s.feed_id).collect();
     let counts = db.subscriber_counts()?;
+    let catalogue = crate::subscriptions(&state.ctx)?;
+    let by_id: std::collections::HashMap<&str, &crate::config::Feed> =
+        catalogue.iter().map(|s| (s.id.as_str(), &s.cfg)).collect();
+    let is_folder: std::collections::HashSet<&str> =
+        catalogue.iter().filter_map(|s| s.cfg.group.as_deref()).collect();
     let mut out = vec![];
-    for s in crate::subscriptions(&state.ctx)? {
+    for s in &catalogue {
         let n = counts.get(&s.id).copied().unwrap_or(0);
-        // A feed from an OPML rides on the OPML: everyone subscribed to it counts every feed
-        // inside, which would bury everything anyone chose on purpose.
-        let from_opml = s.managed || s.cfg.group.is_some();
-        if n == 0 || from_opml || looks_private(&s.cfg) {
+        let inside = s.managed || s.cfg.group.is_some();
+        let hidden = if folders { inside } else { is_folder.contains(s.id.as_str()) };
+        // A feed inside an OPML that looks private is as private as the OPML.
+        let folder = s.cfg.group.as_deref().and_then(|g| by_id.get(g));
+        if n == 0 || hidden || looks_private(&s.cfg) || folder.is_some_and(|f| looks_private(f)) {
             continue;
         }
         let sum = db.feed_summary(&s.id)?;
         let subscribed = mine.contains(&s.id);
-        out.push(PopularRow { id: s.id, title: sum.title, image: sum.image, subscribers: n, subscribed });
+        out.push(PopularRow { id: s.id.clone(), title: sum.title, image: sum.image, subscribers: n, subscribed });
     }
     out.sort_by(|a, b| b.subscribers.cmp(&a.subscribers).then_with(|| sort_name(a).cmp(&sort_name(b))));
     Ok(out)
@@ -607,17 +618,17 @@ async fn get_popular(
     State(state): State<WebState>,
     user: crate::db::User,
 ) -> Result<Json<Vec<PopularRow>>, ApiError> {
-    let mut rows = popular(&state, user.id)?;
+    let mut rows = popular(&state, user.id, true)?;
     rows.truncate(10);
     Ok(Json(rows))
 }
 
-/// Every feed that may be listed, A to Z.
+/// Every feed that may be listed, A to Z, with the feeds inside an OPML in place of the OPML.
 async fn get_directory(
     State(state): State<WebState>,
     user: crate::db::User,
 ) -> Result<Json<Vec<PopularRow>>, ApiError> {
-    let mut rows = popular(&state, user.id)?;
+    let mut rows = popular(&state, user.id, false)?;
     rows.sort_by_key(sort_name);
     Ok(Json(rows))
 }
@@ -626,15 +637,16 @@ fn sort_name(p: &PopularRow) -> String {
     p.title.clone().unwrap_or_else(|| p.id.clone()).to_lowercase()
 }
 
-/// Subscribes by id, because the list never shows a URL. Checked against the same list, so
+/// Subscribes by id, because the lists never show a URL. Checked against the same lists, so
 /// a guessed id cannot reach a private feed.
 async fn subscribe_popular(
     State(state): State<WebState>,
     user: crate::db::User,
     Path(id): Path<String>,
 ) -> Result<Json<serde_json::Value>, ApiError> {
-    if !popular(&state, user.id)?.iter().any(|p| p.id == id) {
-        return Err(ApiError::bad_request(format!("{id:?} is not on the popular list")));
+    let listed = |folders| popular(&state, user.id, folders).map(|rows| rows.iter().any(|p| p.id == id));
+    if !(listed(true)? || listed(false)?) {
+        return Err(ApiError::bad_request(format!("{id:?} is not in the directory")));
     }
     state.ctx.db.subscribe(user.id, &id)?;
     Ok(Json(serde_json::json!({ "id": id })))