extact more stuff

src/main.rs

···
     dry_run: bool,
 }
 
-async fn post(
-    client: &BasicClient,
-    identifier: &AtIdentifier<'_>,
-    repo_name: &str,
-    repo_url: &str,
-    title: &str,
-    repo_issues_url: &str,
-) -> Result<()> {
-    let message = format!(
-        r#"good-first-issue added for {repo_name}:
-
-> {title}"#
-    );
-
-    let repo_feature = serde_json::json!({
-        "$type": "app.bsky.richtext.facet#link",
-        "uri": repo_url,
-    });
-    let repo_facet = Facet {
-        features: vec![Data::from_json(&repo_feature)?],
-        index: ByteSlice {
-            byte_start: 27,
-            byte_end: 29 + repo_name.len() as i64,
-            extra_data: Default::default(),
-        },
-        extra_data: Default::default(),
-    };
-
-    let title_starts_at = (29 + repo_name.len() + 5) as i64;
-
-    let repo_issues_feature = serde_json::json!({
-        "$type": "app.bsky.richtext.facet#link",
-        "uri": repo_issues_url,
-    });
-    let issues_facet = Facet {
-        features: vec![Data::from_json(&repo_issues_feature)?],
-        index: ByteSlice {
-            byte_start: title_starts_at,
-            byte_end: title_starts_at + title.len() as i64,
-            extra_data: Default::default(),
-        },
-        extra_data: Default::default(),
-    };
-
-    // Make a post
-    let post = Post {
-        created_at: Datetime::now(),
-        langs: Some(vec![Language::new("en")?]),
-        text: message.into(),
-        facets: Some(vec![repo_facet, issues_facet]),
-        embed: Default::default(),
-        entities: Default::default(),
-        labels: Default::default(),
-        reply: Default::default(),
-        tags: Default::default(),
-        extra_data: Default::default(),
-    };
-
-    let json = serde_json::to_value(post)?;
-    let data = Data::from_json(&json)?;
-
-    log::info!("\nposting...");
-    client
-        .send(
-            CreateRecord::new()
-                .repo(identifier.clone())
-                .collection(Post::nsid())
-                .record(data)
-                .build(),
-        )
-        .await?
-        .into_output()?;
-
-    Ok(())
-}
-
-fn event_to_create_label<T: for<'a> Deserialize<'a>>(event: JetstreamEvent) -> Result<(T, Cursor)> {
-    if event.kind != EventKind::Commit {
-        return Err("not a commit".into());
-    }
-    let commit = event.commit.ok_or("commit event missing commit data")?;
-    if commit.operation != CommitOp::Create {
-        return Err("not a create event".into());
-    }
-
-    let raw = commit.record.ok_or("commit missing record")?;
-
-    // todo: delete post if label is removed
-    // delete sample: at://did:plc:hdhoaan3xa3jiuq4fg4mefid/sh.tangled.label.op/3m2jvx4c6wf22
-    // tldr: has a "delete" array just like "add" on the same op collection
-    let t = serde_json::from_str(raw.get())?;
-    Ok((t, event.cursor))
+struct IssueDetails {
+    repo_full_name: String,
+    repo_url: String,
+    title: String,
+    issues_url: String,
 }
 
 /// com.bad-example.identity.resolveMiniDoc bit we care about
···
     }
 }
 
+fn event_to_create_label<T: for<'a> Deserialize<'a>>(event: JetstreamEvent) -> Result<T> {
+    if event.kind != EventKind::Commit {
+        return Err("not a commit".into());
+    }
+    let commit = event.commit.ok_or("commit event missing commit data")?;
+    if commit.operation != CommitOp::Create {
+        return Err("not a create event".into());
+    }
+
+    let raw = commit.record.ok_or("commit missing record")?;
+
+    // todo: delete post if label is removed
+    // delete sample: at://did:plc:hdhoaan3xa3jiuq4fg4mefid/sh.tangled.label.op/3m2jvx4c6wf22
+    // tldr: has a "delete" array just like "add" on the same op collection
+    Ok(serde_json::from_str(raw.get())?)
+}
+
+async fn extract_issue_info(
+    client: &reqwest::Client,
+    adds: Vec<AddLabel>,
+    subject: String,
+) -> Result<IssueDetails> {
+    let mut added_good_first_issue = false;
+    for added in adds {
+        if added.key
+            == "at://did:plc:wshs7t2adsemcrrd4snkeqli/sh.tangled.label.definition/good-first-issue"
+        {
+            log::info!("found a good first issue label!!");
+            added_good_first_issue = true;
+            break; // inner
+        }
+        log::debug!("found a label but it wasn't good-first-issue, ignoring...");
+    }
+    if !added_good_first_issue {
+        return Err("good-first-issue label not found in added labels".into());
+    }
+
+    let IssueRecord { title, repo } = match get_record(client, &subject).await {
+        Ok(m) => m,
+        Err(e) => return Err(format!("failed to get issue record: {e} for {subject}").into()),
+    };
+
+    let Ok(repo_uri) = AtUri::new(&repo) else {
+        return Err("failed to parse repo to aturi for {subject}".into());
+    };
+
+    let RepoRecord { name: repo_name } = match get_record(client, &repo).await {
+        Ok(m) => m,
+        Err(e) => return Err(format!("failed to get repo record: {e} for {subject}").into()),
+    };
+
+    let nice_tangled_repo_id = match repo_uri.authority() {
+        AtIdentifier::Handle(h) => format!("@{h}"),
+        AtIdentifier::Did(did) => match get_handle(client, did.as_str()).await {
+            Err(e) => {
+                return Err(format!(
+                    "failed to get mini doc from repo identifier: {e} for {subject}"
+                )
+                .into());
+            }
+            Ok(None) => did.to_string(),
+            Ok(Some(h)) => format!("@{h}"),
+        },
+    };
+
+    let repo_full_name = format!("{nice_tangled_repo_id}/{repo_name}");
+    let repo_url = format!("https://tangled.org/{nice_tangled_repo_id}/{repo_name}");
+
+    let issues_url = format!("https://tangled.org/{nice_tangled_repo_id}/{repo_name}/issues");
+
+    Ok(IssueDetails {
+        repo_full_name,
+        repo_url,
+        title,
+        issues_url,
+    })
+}
+
+async fn post(
+    client: &BasicClient,
+    identifier: &AtIdentifier<'_>,
+    IssueDetails {
+        repo_full_name,
+        repo_url,
+        title,
+        issues_url,
+    }: &IssueDetails,
+) -> Result<()> {
+    let message = format!(
+        r#"good-first-issue added for {repo_full_name}:
+
+> {title}"#
+    );
+
+    let repo_feature = serde_json::json!({
+        "$type": "app.bsky.richtext.facet#link",
+        "uri": repo_url,
+    });
+    let repo_facet = Facet {
+        features: vec![Data::from_json(&repo_feature)?],
+        index: ByteSlice {
+            byte_start: 27,
+            byte_end: 29 + repo_full_name.len() as i64,
+            extra_data: Default::default(),
+        },
+        extra_data: Default::default(),
+    };
+
+    let title_starts_at = (29 + repo_full_name.len() + 5) as i64;
+
+    let repo_issues_feature = serde_json::json!({
+        "$type": "app.bsky.richtext.facet#link",
+        "uri": issues_url,
+    });
+    let issues_facet = Facet {
+        features: vec![Data::from_json(&repo_issues_feature)?],
+        index: ByteSlice {
+            byte_start: title_starts_at,
+            byte_end: title_starts_at + title.len() as i64,
+            extra_data: Default::default(),
+        },
+        extra_data: Default::default(),
+    };
+
+    // Make a post
+    let post = Post {
+        created_at: Datetime::now(),
+        langs: Some(vec![Language::new("en")?]),
+        text: message.into(),
+        facets: Some(vec![repo_facet, issues_facet]),
+        embed: Default::default(),
+        entities: Default::default(),
+        labels: Default::default(),
+        reply: Default::default(),
+        tags: Default::default(),
+        extra_data: Default::default(),
+    };
+
+    let json = serde_json::to_value(post)?;
+    let data = Data::from_json(&json)?;
+
+    log::info!("\nposting...");
+    client
+        .send(
+            CreateRecord::new()
+                .repo(identifier.clone())
+                .collection(Post::nsid())
+                .record(data)
+                .build(),
+        )
+        .await?
+        .into_output()?;
+
+    Ok(())
+}
+
 #[tokio::main]
 async fn main() -> Result<()> {
     env_logger::init();
···
     // Create HTTP client and session
     let client = BasicClient::new(args.pds);
     let bot_id = AtIdentifier::new(&args.identifier)?;
-    let session = Session::from(
-        client
-            .send(
-                CreateSession::new()
-                    .identifier(bot_id.to_string())
-                    .password(&args.app_password)
-                    .build(),
-            )
-            .await?
-            .into_output()?,
-    );
+    let create_session = CreateSession::new()
+        .identifier(bot_id.to_string())
+        .password(&args.app_password)
+        .build();
+    let session = Session::from(client.send(create_session.clone()).await?.into_output()?);
     log::debug!("logged in as {} ({})", session.handle, session.did);
     client.set_session(session).await?;
 
···
             log::error!("consumer: could not receive event, bailing");
             break;
         };
-
-        let Ok((CreateLabelRecord { add, subject }, cursor)) = event_to_create_label(event) else {
-            continue;
-        };
+        let cursor = event.cursor;
 
-        let mut added_good_first_issue = false;
-        for added in add {
-            if added.key
-                == "at://did:plc:wshs7t2adsemcrrd4snkeqli/sh.tangled.label.definition/good-first-issue"
-            {
-                log::info!("found a good first issue label!! {:?}", cursor);
-                added_good_first_issue = true;
-                break; // inner
-            }
-            log::debug!("found a label but it wasn't good-first-issue, ignoring...");
-        }
-        if !added_good_first_issue {
-            continue;
-        }
-
-        let IssueRecord { title, repo } = match get_record(&slingshot_client, &subject).await {
-            Ok(m) => m,
+        let CreateLabelRecord { add: adds, subject } = match event_to_create_label(event) {
+            Ok(clr) => clr,
             Err(e) => {
-                log::warn!("failed to get issue record: {e} for {subject}");
+                log::debug!("ignoring unparseable event (at {cursor:?}): {e}");
                 continue;
             }
         };
 
-        let Ok(repo_uri) = AtUri::new(&repo) else {
-            log::warn!("failed to parse repo to aturi for {subject}");
-            continue;
-        };
-
-        let RepoRecord { name: repo_name } = match get_record(&slingshot_client, &repo).await {
-            Ok(m) => m,
+        let issue_details = match extract_issue_info(&slingshot_client, adds, subject.clone()).await
+        {
+            Ok(deets) => deets,
             Err(e) => {
-                log::warn!("failed to get repo record: {e} for {subject}");
+                log::warn!("failed to extract issue details (at {cursor:?}): {e}");
                 continue;
             }
         };
 
-        let nice_tangled_repo_id = match repo_uri.authority() {
-            AtIdentifier::Handle(h) => format!("@{h}"),
-            AtIdentifier::Did(did) => match get_handle(&slingshot_client, did.as_str()).await {
-                Err(e) => {
-                    log::warn!("failed to get mini doc from repo identifier: {e} for {subject}");
-                    continue;
-                }
-                Ok(None) => did.to_string(),
-                Ok(Some(h)) => format!("@{h}"),
-            },
-        };
-
-        let repo_full_name = format!("{nice_tangled_repo_id}/{repo_name}");
-        let repo_url = format!("https://tangled.org/{nice_tangled_repo_id}/{repo_name}");
-
-        let issues_url = format!("https://tangled.org/{nice_tangled_repo_id}/{repo_name}/issues");
-
         if args.dry_run {
+            let IssueDetails {
+                repo_full_name,
+                repo_url,
+                title,
+                issues_url,
+            } = issue_details;
             log::info!(
                 r#"--dry-run, but would have posted:
 
···
             continue;
         }
 
-        if let Err(e) = post(
-            &client,
-            &bot_id,
-            &repo_full_name,
-            &repo_url,
-            &title,
-            &issues_url,
-        )
-        .await
-        {
+        if let Err(e) = post(&client, &bot_id, &issue_details).await {
             log::warn!("failed to post for {subject}: {e}, refreshing session for one retry...");
-            let session = Session::from(
-                client
-                    .send(
-                        CreateSession::new()
-                            .identifier(bot_id.to_string())
-                            .password(&args.app_password)
-                            .build(),
-                    )
-                    .await?
-                    .into_output()?,
-            );
+            let session = Session::from(client.send(create_session.clone()).await?.into_output()?);
             log::debug!("logged in as {} ({})", session.handle, session.did);
             client.set_session(session).await?;
 
-            if let Err(e) = post(
-                &client,
-                &bot_id,
-                &repo_full_name,
-                &repo_url,
-                &title,
-                &issues_url,
-            )
-            .await
-            {
+            if let Err(e) = post(&client, &bot_id, &issue_details).await {
                 log::error!(
                     "failed to post after a session refresh: {e:?}, something is wrong. bye."
                 );