repo stringlengths 6 65 | file_url stringlengths 81 311 | file_path stringlengths 6 227 | content stringlengths 0 32.8k | language stringclasses 1
value | license stringclasses 7
values | commit_sha stringlengths 40 40 | retrieved_at stringdate 2026-01-04 15:31:58 2026-01-04 20:25:31 | truncated bool 2
classes |
|---|---|---|---|---|---|---|---|---|
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/sources/news/fetch.rs | src/sources/news/fetch.rs | //! News fetching functionality with HTTP client and error handling.
use crate::sources::news::cache::{ARTICLE_CACHE, ARTICLE_CACHE_TTL_SECONDS, ArticleCacheEntry};
use crate::sources::news::parse::parse_arch_news_html;
use crate::sources::news::utils::is_archlinux_url;
use crate::sources::news::{
aur::extract_aur_pkg_from_url,
cache::{load_article_entry_from_disk_cache, save_article_to_disk_cache},
utils::is_arch_package_url,
};
use crate::state::NewsItem;
use reqwest;
use std::sync::LazyLock;
use std::time::{Duration, Instant};
use tracing::{info, warn};
/// Result type alias for Arch Linux news fetching operations.
type Result<T> = super::Result<T>;
/// What: Extract cache path from an official package URL.
///
/// Inputs:
/// - `url`: The official package URL.
///
/// Output:
/// - `Some(PathBuf)` if URL is valid; `None` otherwise.
///
/// Details:
/// - Parses URL format: `https://archlinux.org/packages/{repo}/{arch}/{name}/`
/// - Handles query parameters and fragments in the name.
fn extract_official_package_cache_path(url: &str) -> Option<std::path::PathBuf> {
let lower = url.to_ascii_lowercase();
let pos = lower.find("archlinux.org/packages/")?;
let after = &url[pos + "archlinux.org/packages/".len()..];
let parts: Vec<&str> = after.split('/').filter(|s| !s.is_empty()).collect();
if parts.len() >= 3 {
let repo = parts[0];
let arch = parts[1];
let name = parts[2]
.split('?')
.next()
.unwrap_or(parts[2])
.split('#')
.next()
.unwrap_or(parts[2]);
Some(crate::sources::official_json_cache_path(repo, arch, name))
} else {
None
}
}
/// What: Prepend official package JSON changes to content if available.
///
/// Inputs:
/// - `url`: The official package URL.
/// - `content`: The content to prepend changes to.
///
/// Output:
/// - Content with changes prepended if available; original content otherwise.
///
/// Details:
/// - Only modifies content if changes are detected and not already present.
fn prepend_official_package_changes(url: &str, content: &str) -> String {
let Some(cache_path) = extract_official_package_cache_path(url) else {
return content.to_string();
};
let Some(cached_json) = crate::sources::load_official_json_cache(&cache_path) else {
return content.to_string();
};
let pkg_obj = cached_json.get("pkg").unwrap_or(&cached_json);
let Some(pkg_name) = pkg_obj.get("pkgname").and_then(serde_json::Value::as_str) else {
return content.to_string();
};
let Some(changes) = crate::sources::get_official_json_changes(pkg_name) else {
return content.to_string();
};
if content.starts_with("Changes detected") {
content.to_string()
} else {
format!("{changes}\n\nβββ Package Info βββ\n\n{content}")
}
}
/// Shared HTTP client with connection pooling for news content fetching.
/// Connection pooling is enabled by default in `reqwest::Client`.
/// Uses browser-like headers to work with archlinux.org's `DDoS` protection.
static HTTP_CLIENT: LazyLock<reqwest::Client> = LazyLock::new(|| {
use reqwest::header::{ACCEPT, ACCEPT_LANGUAGE, HeaderMap, HeaderValue};
let mut headers = HeaderMap::new();
// Browser-like Accept header
headers.insert(
ACCEPT,
HeaderValue::from_static("text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"),
);
// Accept-Language header for completeness
headers.insert(ACCEPT_LANGUAGE, HeaderValue::from_static("en-US,en;q=0.5"));
reqwest::Client::builder()
.connect_timeout(Duration::from_secs(15))
.timeout(Duration::from_secs(30))
// Firefox-like User-Agent with Pacsea identifier for transparency
.user_agent(format!(
"Mozilla/5.0 (X11; Linux x86_64; rv:128.0) Gecko/20100101 Firefox/128.0 Pacsea/{}",
env!("CARGO_PKG_VERSION")
))
.default_headers(headers)
.build()
.expect("Failed to create HTTP client")
});
/// What: Fetch recent Arch Linux news items with optional early date filtering.
///
/// Input:
/// - `limit`: Maximum number of items to return (best-effort)
/// - `cutoff_date`: Optional date string (YYYY-MM-DD) for early filtering
///
/// Output: `Ok(Vec<NewsItem>)` with date/title/url; `Err` on network or parse failures
///
/// # Errors
/// - Returns `Err` when network request fails (curl execution error)
/// - Returns `Err` when RSS feed cannot be fetched from Arch Linux website
/// - Returns `Err` when response body cannot be decoded as UTF-8
///
/// Details: Downloads the Arch Linux news RSS feed and iteratively parses `<item>` blocks,
/// extracting `<title>`, `<link>`, and `<pubDate>`. The `pubDate` value is normalized to a
/// date-only form via `strip_time_and_tz`. If `cutoff_date` is provided, stops fetching when
/// items exceed the date limit.
pub async fn fetch_arch_news(limit: usize, cutoff_date: Option<&str>) -> Result<Vec<NewsItem>> {
use crate::sources::news::utils::{extract_between, strip_time_and_tz};
let url = "https://archlinux.org/feeds/news/";
// Use shorter timeout (10s connect, 15s max) to avoid blocking on slow/unreachable servers
let body = tokio::task::spawn_blocking(move || {
crate::util::curl::curl_text_with_args(
url,
&["--connect-timeout", "10", "--max-time", "15"],
)
})
.await?
.map_err(|e| {
warn!(error = %e, "failed to fetch arch news feed");
e
})?;
info!(bytes = body.len(), "fetched arch news feed");
let mut items: Vec<NewsItem> = Vec::new();
let mut pos = 0;
while items.len() < limit {
if let Some(start) = body[pos..].find("<item>") {
let s = pos + start;
let end = body[s..].find("</item>").map_or(body.len(), |e| s + e + 7);
let chunk = &body[s..end];
let title = extract_between(chunk, "<title>", "</title>").unwrap_or_default();
let link = extract_between(chunk, "<link>", "</link>").unwrap_or_default();
let raw_date = extract_between(chunk, "<pubDate>", "</pubDate>")
.map(|d| d.trim().to_string())
.unwrap_or_default();
let date = strip_time_and_tz(&raw_date);
// Early date filtering: stop if item is older than cutoff_date
if let Some(cutoff) = cutoff_date
&& date.as_str() < cutoff
{
break;
}
items.push(NewsItem {
date,
title,
url: link,
});
pos = end;
} else {
break;
}
}
info!(count = items.len(), "parsed arch news feed");
Ok(items)
}
/// What: Fetch the full article content from an Arch news URL.
///
/// Inputs:
/// - `url`: The news article URL (e.g., `https://archlinux.org/news/...`)
///
/// Output:
/// - `Ok(String)` with the article text content; `Err` on network/parse failure.
///
/// # Errors
/// - Network fetch failures
/// - HTML parsing failures
///
/// Details:
/// - For AUR package URLs, fetches and renders AUR comments instead.
/// - For Arch news URLs, checks cache first (15-minute in-memory, 14-day disk TTL).
/// - Applies rate limiting for archlinux.org URLs to prevent aggressive fetching.
/// - Fetches the HTML page and extracts content from the article body.
/// - Strips HTML tags and normalizes whitespace.
/// - Caches successful fetches in both in-memory and disk caches.
pub async fn fetch_news_content(url: &str) -> Result<String> {
use crate::sources::news::aur::render_aur_comments;
if let Some(pkg) = extract_aur_pkg_from_url(url) {
// Check for JSON changes first
let changes = crate::sources::get_aur_json_changes(&pkg);
let comments = crate::sources::fetch_aur_comments(pkg.clone()).await?;
let mut rendered = render_aur_comments(&pkg, &comments);
// Prepend JSON changes if available
if let Some(changes_text) = changes {
rendered = format!("{changes_text}\n\nβββ AUR Comments βββ\n\n{rendered}");
}
return Ok(rendered);
}
// Check for official package URL and load cached JSON to get package name and changes
if is_arch_package_url(url)
&& let Ok(cache) = ARTICLE_CACHE.lock()
&& let Some(entry) = cache.get(url)
&& entry.timestamp.elapsed().as_secs() < ARTICLE_CACHE_TTL_SECONDS
{
let content = prepend_official_package_changes(url, &entry.content);
return Ok(content);
}
// 1. Check in-memory cache first (fastest, 15-minute TTL)
let cached_entry: Option<ArticleCacheEntry> = if let Ok(cache) = ARTICLE_CACHE.lock()
&& let Some(entry) = cache.get(url)
&& entry.timestamp.elapsed().as_secs() < ARTICLE_CACHE_TTL_SECONDS
{
info!(url, "using in-memory cached article content");
return Ok(entry.content.clone());
} else {
None
};
// 2. Check disk cache (14-day TTL) - useful after app restart
let disk_entry = load_article_entry_from_disk_cache(url);
if let Some(ref entry) = disk_entry {
// Populate in-memory cache from disk
if let Ok(mut cache) = ARTICLE_CACHE.lock() {
cache.insert(
url.to_string(),
ArticleCacheEntry {
content: entry.content.clone(),
timestamp: Instant::now(),
etag: entry.etag.clone(),
last_modified: entry.last_modified.clone(),
},
);
}
// Check for official package changes and prepend if available
if is_arch_package_url(url) {
let content = prepend_official_package_changes(url, &entry.content);
return Ok(content);
}
return Ok(entry.content.clone());
}
// 3. Check circuit breaker before making request (no network call)
let endpoint_pattern = crate::sources::feeds::extract_endpoint_pattern(url);
if let Err(e) = crate::sources::feeds::check_circuit_breaker(&endpoint_pattern) {
warn!(url, endpoint_pattern, error = %e, "circuit breaker blocking request");
// Try to return cached content if available
if let Some(cached) = cached_entry {
return Ok(cached.content);
}
if let Some(disk) = disk_entry {
return Ok(disk.content);
}
return Err(e);
}
// 4. Fetch from network with conditional requests
// Get cached ETag/Last-Modified for conditional request
let cached_etag = cached_entry
.as_ref()
.and_then(|e: &ArticleCacheEntry| e.etag.as_ref())
.or_else(|| disk_entry.as_ref().and_then(|e| e.etag.as_ref()))
.cloned();
let cached_last_modified = cached_entry
.as_ref()
.and_then(|e: &ArticleCacheEntry| e.last_modified.as_ref())
.or_else(|| disk_entry.as_ref().and_then(|e| e.last_modified.as_ref()))
.cloned();
// Fetch from network
let (body, etag, last_modified) =
match fetch_from_network(url, cached_etag, cached_last_modified, &endpoint_pattern).await {
Ok(result) => result,
Err(e) if e.to_string() == "304 Not Modified" => {
// Return cached content on 304
if let Some(cached) = cached_entry {
return Ok(cached.content);
}
if let Some(disk) = disk_entry {
return Ok(disk.content);
}
warn!(url, "304 response but no cached content available");
return Err("304 Not Modified but no cache available".into());
}
Err(e) => return Err(e),
};
// Extract article content from HTML
let content = parse_arch_news_html(&body, Some(url));
// Prepend official package JSON changes if available
let content = if is_arch_package_url(url) {
prepend_official_package_changes(url, &content)
} else {
content
};
let parsed_len = content.len();
if parsed_len == 0 {
warn!(url, "parsed news content is empty");
} else {
info!(url, parsed_len, "parsed news content");
}
// 5. Cache the result with ETag/Last-Modified
// Save to in-memory cache
if let Ok(mut cache) = ARTICLE_CACHE.lock() {
cache.insert(
url.to_string(),
ArticleCacheEntry {
content: content.clone(),
timestamp: Instant::now(),
etag: etag.clone(),
last_modified: last_modified.clone(),
},
);
}
// Save to disk cache for persistence across restarts
save_article_to_disk_cache(url, &content, etag, last_modified);
Ok(content)
}
/// What: Fetch content from network with conditional requests.
///
/// Inputs:
/// - `url`: The URL to fetch.
/// - `cached_etag`: Optional `ETag` from cache.
/// - `cached_last_modified`: Optional `Last-Modified` from cache.
/// - `endpoint_pattern`: Endpoint pattern for circuit breaker.
///
/// Output:
/// - `Ok((body, etag, last_modified))` on success.
/// - `Err` on network or HTTP errors.
///
/// Details:
/// - Applies rate limiting for archlinux.org URLs.
/// - Uses conditional requests if `ETag`/`Last-Modified` available.
/// - Handles 304 Not Modified responses.
async fn fetch_from_network(
url: &str,
cached_etag: Option<String>,
cached_last_modified: Option<String>,
endpoint_pattern: &str,
) -> Result<(String, Option<String>, Option<String>)> {
// Apply rate limiting and acquire semaphore for archlinux.org URLs
let _permit = if is_archlinux_url(url) {
Some(crate::sources::feeds::rate_limit_archlinux().await)
} else {
None
};
// Fetch from network with conditional requests using reqwest (connection pooling)
let client = HTTP_CLIENT.clone();
let mut request = client.get(url);
// Add conditional request headers if we have cached ETag/Last-Modified
if let Some(ref etag) = cached_etag {
request = request.header("If-None-Match", etag);
}
if let Some(ref last_mod) = cached_last_modified {
request = request.header("If-Modified-Since", last_mod);
}
let http_response = request.send().await.map_err(|e| {
warn!(error = %e, url, "failed to fetch news content");
crate::sources::feeds::record_circuit_breaker_outcome(endpoint_pattern, false);
Box::<dyn std::error::Error + Send + Sync>::from(format!("Network error: {e}"))
})?;
let status = http_response.status();
let status_code = status.as_u16();
// Handle 304 Not Modified
if status_code == 304 {
info!(
url,
"server returned 304 Not Modified, using cached content"
);
return Err("304 Not Modified".into());
}
// Extract ETag and Last-Modified from response headers before consuming body
let etag = http_response
.headers()
.get("etag")
.and_then(|h| h.to_str().ok())
.map(ToString::to_string);
let last_modified = http_response
.headers()
.get("last-modified")
.and_then(|h| h.to_str().ok())
.map(ToString::to_string);
// Check for HTTP errors
if status.is_client_error() || status.is_server_error() {
crate::sources::feeds::record_circuit_breaker_outcome(endpoint_pattern, false);
return Err(handle_http_error(status, status_code, &http_response).into());
}
let body = http_response.text().await.map_err(|e| {
warn!(error = %e, url, "failed to read response body");
Box::<dyn std::error::Error + Send + Sync>::from(format!("Failed to read response: {e}"))
})?;
info!(url, bytes = body.len(), "fetched news page");
crate::sources::feeds::record_circuit_breaker_outcome(endpoint_pattern, true);
Ok((body, etag, last_modified))
}
/// What: Handle HTTP error responses and format error messages.
///
/// Inputs:
/// - `status`: HTTP status code object.
/// - `status_code`: HTTP status code as u16.
/// - `http_response`: HTTP response object to extract headers.
///
/// Output:
/// - Formatted error message string.
///
/// Details:
/// - Handles 429 (Too Many Requests) and 503 (Service Unavailable) with Retry-After headers.
/// - Formats generic error messages for other HTTP errors.
fn handle_http_error(
status: reqwest::StatusCode,
status_code: u16,
http_response: &reqwest::Response,
) -> String {
if status_code == 429 {
let mut msg = "HTTP 429 Too Many Requests - rate limited by server".to_string();
if let Some(retry_after) = http_response.headers().get("retry-after")
&& let Ok(retry_str) = retry_after.to_str()
{
msg.push_str(" (Retry-After: ");
msg.push_str(retry_str);
msg.push(')');
}
msg
} else if status_code == 503 {
let mut msg = "HTTP 503 Service Unavailable".to_string();
if let Some(retry_after) = http_response.headers().get("retry-after")
&& let Ok(retry_str) = retry_after.to_str()
{
msg.push_str(" (Retry-After: ");
msg.push_str(retry_str);
msg.push(')');
}
msg
} else {
format!("HTTP error: {status}")
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/sources/news/utils.rs | src/sources/news/utils.rs | //! Utility functions for news parsing and URL handling.
/// What: Return the substring strictly between `start` and `end` markers (if present).
///
/// Input: `s` source text; `start` opening marker; `end` closing marker
/// Output: `Some(String)` of enclosed content; `None` if markers are missing
///
/// Details: Searches for the first occurrence of `start`, then the next occurrence of `end`
/// after it; returns the interior substring when both are found in order.
pub fn extract_between(s: &str, start: &str, end: &str) -> Option<String> {
let i = s.find(start)? + start.len();
let j = s[i..].find(end)? + i;
Some(s[i..j].to_string())
}
/// What: Parse and normalize an RFC-like date string to `YYYY-MM-DD` format for sorting.
///
/// Input: `s` full date string, e.g., "Mon, 23 Oct 2023 12:34:56 +0000" or "Thu, 21 Aug 2025"
/// Output: Normalized date in `YYYY-MM-DD` format, e.g., "2023-10-23"
///
/// Details:
/// - First tries to parse as RFC 2822 (RSS date format like "Thu, 21 Aug 2025 12:34:56 +0000").
/// - Falls back to RFC 3339 parsing.
/// - If all parsing fails, returns the original stripped date (for backwards compatibility).
pub fn strip_time_and_tz(s: &str) -> String {
let trimmed = s.trim();
// Try RFC 2822 format first (RSS/Atom feeds: "Thu, 21 Aug 2025 12:34:56 +0000")
if let Ok(dt) = chrono::DateTime::parse_from_rfc2822(trimmed) {
return dt.format("%Y-%m-%d").to_string();
}
// Try RFC 3339 format
if let Ok(dt) = chrono::DateTime::parse_from_rfc3339(trimmed) {
return dt.format("%Y-%m-%d").to_string();
}
// Try ISO 8601 without timezone
if let Ok(dt) = chrono::NaiveDateTime::parse_from_str(trimmed, "%Y-%m-%dT%H:%M:%S") {
return dt.format("%Y-%m-%d").to_string();
}
// Try parsing just date part if it's already in YYYY-MM-DD format
if chrono::NaiveDate::parse_from_str(trimmed, "%Y-%m-%d").is_ok() {
return trimmed.to_string();
}
// Fallback: try to extract date from partial RFC 2822 without timezone
// Format: "Thu, 21 Aug 2025" or "Thu, 21 Aug 2025 12:34:56"
if let Some(date) = parse_partial_rfc2822(trimmed) {
return date;
}
// Last resort: strip time and timezone manually and return as-is
// (This preserves backwards compatibility but won't sort correctly)
let mut t = trimmed.to_string();
if let Some(pos) = t.rfind(" +") {
t.truncate(pos);
t = t.trim_end().to_string();
}
if t.len() >= 9 {
let n = t.len();
let time_part = &t[n - 8..n];
let looks_time = time_part.chars().enumerate().all(|(i, c)| match i {
2 | 5 => c == ':',
_ => c.is_ascii_digit(),
});
if looks_time && t.as_bytes()[n - 9] == b' ' {
t.truncate(n - 9);
}
}
t.trim_end().to_string()
}
/// What: Parse a partial RFC 2822 date string (without timezone) to `YYYY-MM-DD`.
///
/// Input: Partial RFC 2822 string like "Thu, 21 Aug 2025" or "21 Aug 2025"
/// Output: `Some("2025-08-21")` on success, `None` on failure
///
/// Details:
/// - Handles both with and without leading day-of-week.
/// - Parses common month abbreviations (Jan, Feb, etc.).
fn parse_partial_rfc2822(s: &str) -> Option<String> {
// Try to find day, month, year pattern
// Common formats: "Thu, 21 Aug 2025", "21 Aug 2025"
let parts: Vec<&str> = s.split_whitespace().collect();
// Find the numeric day, month abbreviation, and year
let (day_str, month_str, year_str) = if parts.len() >= 4 && parts[0].ends_with(',') {
// "Thu, 21 Aug 2025" format
(parts.get(1)?, parts.get(2)?, parts.get(3)?)
} else if parts.len() >= 3 {
// "21 Aug 2025" format
(parts.first()?, parts.get(1)?, parts.get(2)?)
} else {
return None;
};
// Parse day
let day: u32 = day_str.parse().ok()?;
// Parse month abbreviation
let month = match month_str.to_lowercase().as_str() {
"jan" => 1,
"feb" => 2,
"mar" => 3,
"apr" => 4,
"may" => 5,
"jun" => 6,
"jul" => 7,
"aug" => 8,
"sep" => 9,
"oct" => 10,
"nov" => 11,
"dec" => 12,
_ => return None,
};
// Parse year (take first 4 digits if there's more)
let year: i32 = year_str.chars().take(4).collect::<String>().parse().ok()?;
// Validate and format
if (1..=31).contains(&day) && (1970..=2100).contains(&year) {
Some(format!("{year:04}-{month:02}-{day:02}"))
} else {
None
}
}
/// What: Check if a URL is from archlinux.org (including www subdomain).
///
/// Inputs:
/// - `url`: URL string to check
///
/// Output:
/// - `true` if URL is from archlinux.org or www.archlinux.org, `false` otherwise
///
/// Details:
/// - Checks for both `https://archlinux.org/` and `https://www.archlinux.org/` prefixes.
pub fn is_archlinux_url(url: &str) -> bool {
url.starts_with("https://archlinux.org/") || url.starts_with("https://www.archlinux.org/")
}
/// What: Resolve relative hrefs against the provided origin.
pub fn resolve_href(href: &str, base_origin: Option<&str>) -> String {
if href.starts_with("http://") || href.starts_with("https://") {
return href.to_string();
}
if let Some(origin) = base_origin
&& href.starts_with('/')
{
return format!("{origin}{href}");
}
href.to_string()
}
/// What: Extract `<scheme://host>` from a URL for resolving relative links.
pub fn extract_origin(url: &str) -> Option<String> {
let scheme_split = url.split_once("://")?;
let scheme = scheme_split.0;
let rest = scheme_split.1;
let host_end = rest.find('/').unwrap_or(rest.len());
if host_end == 0 {
return None;
}
let host = &rest[..host_end];
Some(format!("{scheme}://{host}"))
}
/// What: Check if a URL points to an Arch package details page.
pub fn is_arch_package_url(url: &str) -> bool {
url.contains("://archlinux.org/packages/")
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/sources/news/tests_aur.rs | src/sources/news/tests_aur.rs | //! AUR-related tests for news module.
use crate::sources::news::aur::{extract_aur_pkg_from_url, render_aur_comments};
#[test]
/// What: Test `extract_aur_pkg_from_url` identifies AUR package URLs.
///
/// Inputs:
/// - Various AUR package URL formats.
///
/// Output:
/// - Package name extracted correctly from URL.
///
/// Details:
/// - Verifies AUR URL detection for comment rendering branch.
fn test_extract_aur_pkg_from_url() {
assert_eq!(
extract_aur_pkg_from_url("https://aur.archlinux.org/packages/foo"),
Some("foo".to_string())
);
assert_eq!(
extract_aur_pkg_from_url("https://aur.archlinux.org/packages/foo/"),
Some("foo".to_string())
);
assert_eq!(
extract_aur_pkg_from_url("https://aur.archlinux.org/packages/foo-bar"),
Some("foo-bar".to_string())
);
assert_eq!(
extract_aur_pkg_from_url("https://aur.archlinux.org/packages/foo?query=bar"),
Some("foo".to_string())
);
// URL fragments (e.g., #comment-123) should be stripped from package name
assert_eq!(
extract_aur_pkg_from_url(
"https://aur.archlinux.org/packages/discord-canary#comment-1050019"
),
Some("discord-canary".to_string())
);
assert_eq!(
extract_aur_pkg_from_url("https://aur.archlinux.org/packages/foo#section"),
Some("foo".to_string())
);
assert_eq!(
extract_aur_pkg_from_url("https://archlinux.org/news/item"),
None
);
}
#[test]
/// What: Test `render_aur_comments` formats comments correctly.
///
/// Inputs:
/// - AUR comments with pinned and recent items.
///
/// Output:
/// - Rendered text includes pinned section and recent comments.
///
/// Details:
/// - Verifies comment rendering for AUR package pages.
fn test_render_aur_comments() {
use crate::state::types::AurComment;
use chrono::{Duration, Utc};
let now = Utc::now().timestamp();
let cutoff = now - Duration::days(7).num_seconds();
let comments = vec![
AurComment {
id: Some("c1".into()),
author: "user1".into(),
date: "2025-01-01 00:00 (UTC)".into(),
date_timestamp: Some(cutoff + 86400), // Within 7 days
date_url: Some("https://aur.archlinux.org/packages/foo#comment-1".into()),
content: "Recent comment".into(),
pinned: false,
},
AurComment {
id: Some("c2".into()),
author: "maintainer".into(),
date: "2024-12-01 00:00 (UTC)".into(),
date_timestamp: Some(cutoff - 86400), // Older than 7 days
date_url: Some("https://aur.archlinux.org/packages/foo#comment-2".into()),
content: "Pinned comment".into(),
pinned: true,
},
];
let rendered = render_aur_comments("foo", &comments);
assert!(rendered.contains("AUR comments for foo"));
assert!(rendered.contains("[Pinned]"));
assert!(rendered.contains("Recent (last 7 days)"));
assert!(rendered.contains("Recent comment"));
assert!(rendered.contains("Pinned comment"));
}
/// What: Test that comments with None timestamps and future dates are excluded from "Recent".
///
/// Inputs:
/// - Comments with None timestamps
/// - Comments with future dates
///
/// Output:
/// - These comments should not appear in "Recent (last 7 days)" section.
///
/// Details:
/// - Verifies the fix for bug where unparseable or future dates were incorrectly marked as recent.
#[test]
fn test_render_aur_comments_excludes_invalid_dates() {
use crate::state::types::AurComment;
use chrono::{Duration, Utc};
let now = Utc::now().timestamp();
let cutoff = now - Duration::days(7).num_seconds();
let comments = vec![
AurComment {
id: Some("c1".into()),
author: "user1".into(),
date: "2025-04-14 11:52 (UTC+2)".into(),
date_timestamp: None, // Unparseable date
date_url: Some("https://aur.archlinux.org/packages/foo#comment-1".into()),
content: "Comment with unparseable date".into(),
pinned: false,
},
AurComment {
id: Some("c2".into()),
author: "user2".into(),
date: "2025-12-25 00:00 (UTC)".into(),
date_timestamp: Some(now + Duration::days(365).num_seconds()), // Future date
date_url: Some("https://aur.archlinux.org/packages/foo#comment-2".into()),
content: "Comment with future date".into(),
pinned: false,
},
AurComment {
id: Some("c3".into()),
author: "user3".into(),
date: "2024-01-01 00:00 (UTC)".into(),
date_timestamp: Some(cutoff - 86400), // Older than 7 days
date_url: Some("https://aur.archlinux.org/packages/foo#comment-3".into()),
content: "Old comment".into(),
pinned: false,
},
AurComment {
id: Some("c4".into()),
author: "user4".into(),
date: "2025-01-01 00:00 (UTC)".into(),
date_timestamp: Some(cutoff + 86400), // Within 7 days
date_url: Some("https://aur.archlinux.org/packages/foo#comment-4".into()),
content: "Recent comment".into(),
pinned: false,
},
];
let rendered = render_aur_comments("foo", &comments);
assert!(rendered.contains("AUR comments for foo"));
assert!(rendered.contains("Recent (last 7 days)"));
assert!(rendered.contains("Recent comment")); // Should include valid recent comment
assert!(!rendered.contains("Comment with unparseable date")); // Should exclude None timestamp
assert!(!rendered.contains("Comment with future date")); // Should exclude future date
assert!(!rendered.contains("Old comment")); // Should exclude old comment
}
/// What: Test that fallback comment shows "Latest comment" instead of "Recent (last 7 days)".
///
/// Inputs:
/// - Comments that are all older than 7 days or have invalid timestamps
///
/// Output:
/// - Should show "Latest comment" label when showing fallback comment
///
/// Details:
/// - Verifies that non-recent comments shown as fallback are labeled correctly
#[test]
fn test_render_aur_comments_fallback_label() {
use crate::state::types::AurComment;
use chrono::{Duration, Utc};
let now = Utc::now().timestamp();
let cutoff = now - Duration::days(7).num_seconds();
let comments = vec![AurComment {
id: Some("c1".into()),
author: "user1".into(),
date: "2024-01-01 00:00 (UTC)".into(),
date_timestamp: Some(cutoff - 86400), // Older than 7 days
date_url: Some("https://aur.archlinux.org/packages/foo#comment-1".into()),
content: "Old comment".into(),
pinned: false,
}];
let rendered = render_aur_comments("foo", &comments);
assert!(rendered.contains("AUR comments for foo"));
assert!(rendered.contains("Latest comment")); // Should show "Latest comment" for fallback
assert!(!rendered.contains("Recent (last 7 days)")); // Should not show "Recent" label
assert!(rendered.contains("Old comment")); // Should show the fallback comment
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/sources/news/mod.rs | src/sources/news/mod.rs | //! Arch Linux news fetching and parsing.
mod aur;
mod cache;
mod fetch;
mod parse;
mod utils;
/// Result type alias for Arch Linux news fetching operations.
type Result<T> = super::Result<T>;
pub use fetch::{fetch_arch_news, fetch_news_content};
pub use parse::parse_arch_news_html;
/// What: Parse raw news/advisory HTML into displayable text (public helper).
///
/// Inputs:
/// - `html`: Raw HTML source to parse.
///
/// Output:
/// - Plaintext content suitable for the details view.
#[must_use]
pub fn parse_news_html(html: &str) -> String {
parse_arch_news_html(html, None)
}
#[cfg(test)]
mod tests;
#[cfg(test)]
mod tests_aur;
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/sources/news/aur.rs | src/sources/news/aur.rs | //! AUR-related functionality for news module.
use crate::sources::news::parse::collapse_blank_lines;
/// What: Extract package name from an AUR package URL.
///
/// Inputs:
/// - `url`: URL to inspect.
///
/// Output:
/// - `Some(pkgname)` if the URL matches `https://aur.archlinux.org/packages/<name>`
/// or official package links we build for AUR items; `None` otherwise.
pub fn extract_aur_pkg_from_url(url: &str) -> Option<String> {
let lower = url.to_ascii_lowercase();
let needle = "aur.archlinux.org/packages/";
let pos = lower.find(needle)?;
let after = &url[pos + needle.len()..];
// Stop at path separator, query string, or URL fragment (e.g., #comment-123)
let end = after
.find('/')
.or_else(|| after.find('?'))
.or_else(|| after.find('#'))
.unwrap_or(after.len());
let pkg = &after[..end];
if pkg.is_empty() {
None
} else {
Some(pkg.to_string())
}
}
/// What: Render AUR comments into a readable text block for the details pane.
///
/// Inputs:
/// - `pkg`: Package name.
/// - `comments`: Full comment list (pinned + latest) sorted newest-first.
///
/// Output:
/// - Plaintext content including pinned comments (marked) and newest comments from the last 7 days
/// (or the latest available if timestamps are missing).
pub fn render_aur_comments(pkg: &str, comments: &[crate::state::types::AurComment]) -> String {
use chrono::{Duration, Utc};
let now = Utc::now().timestamp();
let cutoff = now - Duration::days(7).num_seconds();
let pinned: Vec<&crate::state::types::AurComment> =
comments.iter().filter(|c| c.pinned).collect();
let mut recent: Vec<&crate::state::types::AurComment> = comments
.iter()
.filter(|c| !c.pinned && c.date_timestamp.is_some_and(|ts| ts >= cutoff && ts <= now))
.collect();
// Track if we're using a fallback (showing non-recent comment)
let is_fallback = recent.is_empty();
if is_fallback {
// Show most recent non-pinned comment as fallback if no recent comments exist
if let Some(first_non_pinned) = comments.iter().find(|c| !c.pinned) {
recent.push(first_non_pinned);
}
}
let mut lines: Vec<String> = Vec::new();
lines.push(format!("AUR comments for {pkg}"));
lines.push(String::new());
if !pinned.is_empty() {
lines.push("[Pinned]".to_string());
for c in pinned {
push_comment_lines(&mut lines, c, true);
}
lines.push(String::new());
}
if recent.is_empty() {
lines.push("No recent comments.".to_string());
} else if is_fallback {
// Show fallback comment with appropriate label
lines.push("Latest comment".to_string());
for c in recent {
push_comment_lines(&mut lines, c, false);
}
} else {
lines.push("Recent (last 7 days)".to_string());
for c in recent {
push_comment_lines(&mut lines, c, false);
}
}
collapse_blank_lines(&lines.iter().map(String::as_str).collect::<Vec<_>>())
}
/// What: Append a single comment (with metadata) into the output lines.
fn push_comment_lines(lines: &mut Vec<String>, c: &crate::state::types::AurComment, pinned: bool) {
let mut header = String::new();
if pinned {
header.push_str("[Pinned] ");
}
header.push_str(&c.author);
if !c.date.is_empty() {
header.push_str(" β ");
header.push_str(&c.date);
}
if let Some(url) = &c.date_url
&& !url.is_empty()
{
header.push(' ');
header.push('(');
header.push_str(url);
header.push(')');
}
lines.push(header);
let content = c.content.trim();
if !content.is_empty() {
lines.push(content.to_string());
}
lines.push(String::new());
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/sources/news/cache.rs | src/sources/news/cache.rs | //! Cache management for article content.
use std::collections::HashMap;
use std::sync::{LazyLock, Mutex};
use std::time::Instant;
use tracing::{debug, info, warn};
/// Cache entry for article content with timestamp.
pub struct ArticleCacheEntry {
/// Cached article content.
pub content: String,
/// Timestamp when the cache entry was created.
pub timestamp: Instant,
/// `ETag` from last response (for conditional requests).
pub etag: Option<String>,
/// `Last-Modified` date from last response (for conditional requests).
pub last_modified: Option<String>,
}
/// Disk cache entry for article content with Unix timestamp (for serialization).
#[derive(serde::Serialize, serde::Deserialize, Clone)]
pub struct ArticleDiskCacheEntry {
/// Cached article content.
pub content: String,
/// Unix timestamp (seconds since epoch) when the cache was saved.
pub saved_at: i64,
/// `ETag` from last response (for conditional requests).
#[serde(skip_serializing_if = "Option::is_none")]
pub etag: Option<String>,
/// `Last-Modified` date from last response (for conditional requests).
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified: Option<String>,
}
/// In-memory cache for article content.
/// Key: URL string
/// TTL: 15 minutes (same as news feed)
pub static ARTICLE_CACHE: LazyLock<Mutex<HashMap<String, ArticleCacheEntry>>> =
LazyLock::new(|| Mutex::new(HashMap::new()));
/// Cache TTL in seconds (15 minutes, same as news feed).
pub const ARTICLE_CACHE_TTL_SECONDS: u64 = 900;
/// What: Get the disk cache TTL in seconds from settings.
///
/// Inputs: None
///
/// Output: TTL in seconds (defaults to 14 days = 1209600 seconds).
///
/// Details:
/// - Reads `news_cache_ttl_days` from settings and converts to seconds.
/// - Minimum is 1 day to prevent excessive network requests.
pub fn article_disk_cache_ttl_seconds() -> i64 {
let days = crate::theme::settings().news_cache_ttl_days.max(1);
i64::from(days) * 86400 // days to seconds
}
/// What: Get the path to the article content disk cache file.
///
/// Inputs: None
///
/// Output:
/// - `PathBuf` to the cache file.
pub fn article_disk_cache_path() -> std::path::PathBuf {
crate::theme::lists_dir().join("news_article_cache.json")
}
/// What: Load cached article entry from disk if available and not expired.
///
/// Inputs:
/// - `url`: URL of the article to load from cache.
///
/// Output:
/// - `Some(ArticleDiskCacheEntry)` if valid cache exists, `None` otherwise.
///
/// Details:
/// - Returns `None` if file doesn't exist, is corrupted, or cache is older than configured TTL.
pub fn load_article_entry_from_disk_cache(url: &str) -> Option<ArticleDiskCacheEntry> {
let path = article_disk_cache_path();
let content = std::fs::read_to_string(&path).ok()?;
let cache: HashMap<String, ArticleDiskCacheEntry> = serde_json::from_str(&content).ok()?;
let entry = cache.get(url)?.clone();
let now = chrono::Utc::now().timestamp();
let age = now - entry.saved_at;
let ttl = article_disk_cache_ttl_seconds();
if age < ttl {
info!(
url,
age_hours = age / 3600,
ttl_days = ttl / 86400,
"loaded article from disk cache"
);
Some(entry)
} else {
debug!(
url,
age_hours = age / 3600,
ttl_days = ttl / 86400,
"article disk cache expired"
);
None
}
}
/// What: Save article content to disk cache with current timestamp.
///
/// Inputs:
/// - `url`: URL of the article.
/// - `content`: Article content to cache.
/// - `etag`: Optional `ETag` from response.
/// - `last_modified`: Optional `Last-Modified` date from response.
///
/// Details:
/// - Writes to disk asynchronously to avoid blocking.
/// - Logs errors but does not propagate them.
/// - Updates existing cache file, adding or updating the entry for this URL.
pub fn save_article_to_disk_cache(
url: &str,
content: &str,
etag: Option<String>,
last_modified: Option<String>,
) {
let path = article_disk_cache_path();
// Load existing cache or create new
let mut cache: HashMap<String, ArticleDiskCacheEntry> = std::fs::read_to_string(&path)
.map_or_else(
|_| HashMap::new(),
|file_content| serde_json::from_str(&file_content).unwrap_or_default(),
);
// Update or insert entry
cache.insert(
url.to_string(),
ArticleDiskCacheEntry {
content: content.to_string(),
saved_at: chrono::Utc::now().timestamp(),
etag,
last_modified,
},
);
// Save back to disk
match serde_json::to_string_pretty(&cache) {
Ok(json) => {
if let Err(e) = std::fs::write(&path, json) {
warn!(error = %e, url, "failed to write article disk cache");
} else {
debug!(url, "saved article to disk cache");
}
}
Err(e) => warn!(error = %e, url, "failed to serialize article disk cache"),
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/sources/status/html.rs | src/sources/status/html.rs | use crate::state::ArchStatusColor;
use super::utils::{
extract_arch_systems_status_color, extract_aur_today_percent, extract_aur_today_rect_color,
extract_status_updates_today_color, severity_max, today_ymd_utc,
};
/// What: Check if AUR specifically shows "Down" status in the monitors section.
///
/// Inputs:
/// - `body`: Raw HTML content to analyze.
///
/// Output:
/// - `true` if AUR monitor shows "Down" status, `false` otherwise.
///
/// Details: Searches the monitors section for AUR and checks if it has "Down" status indicator.
/// Looks for patterns like `title="Down"`, `>Down<`, or "Down" text near AUR.
/// The actual HTML structure has: `<a title="AUR"...>` followed by `<div... title="Down">`
pub(super) fn is_aur_down_in_monitors(body: &str) -> bool {
let lowered = body.to_lowercase();
// Find the monitors section
if let Some(monitors_pos) = lowered.find("monitors") {
let monitors_window_start = monitors_pos;
let monitors_window_end = std::cmp::min(body.len(), monitors_pos + 15000);
let monitors_window = &lowered[monitors_window_start..monitors_window_end];
// Look for AUR in the monitors section - be more specific: look for title="aur" or "aur" in monitor context
// The actual HTML has: <a title="AUR" class="psp-monitor-name...
let aur_patterns = ["title=\"aur\"", "title='aur'", ">aur<", "\"aur\""];
let mut aur_pos_opt = None;
for pattern in aur_patterns {
if let Some(pos) = monitors_window.find(pattern) {
aur_pos_opt = Some(pos);
break;
}
}
// Fallback: just search for "aur" if pattern search didn't work
if aur_pos_opt.is_none() {
aur_pos_opt = monitors_window.find("aur");
}
if let Some(aur_pos) = aur_pos_opt {
// Check in a much larger window around AUR (2000 chars after) for "Down" status
// The actual HTML structure has quite a bit of content between AUR and Down
let aur_window_start = aur_pos;
let aur_window_end = std::cmp::min(monitors_window.len(), aur_pos + 2000);
let aur_window = &monitors_window[aur_window_start..aur_window_end];
// Check for "Down" status indicators near AUR
// Look for various patterns:
// 1. title="Down" or title='Down' (most reliable - this is what the actual HTML has)
// 2. psp-monitor-row-status-inner with title="Down" (specific to status page)
// 3. >down< (text content between tags)
// 4. "down" or 'down' (in quotes)
let has_title_down =
aur_window.contains("title=\"down\"") || aur_window.contains("title='down'");
let has_status_inner_down = aur_window.contains("psp-monitor-row-status-inner")
&& (aur_window.contains("title=\"down\"") || aur_window.contains("title='down'"));
let has_tagged_down = aur_window.contains(">down<");
let has_quoted_down = aur_window.contains("\"down\"") || aur_window.contains("'down'");
// Check for plain "down" text, but make sure it's a standalone word
// Look for word boundaries (space, >, <, etc.) before and after "down"
let has_plain_down = aur_window.contains(" down ")
|| aur_window.contains(">down<")
|| aur_window.contains(">down ")
|| aur_window.contains(" down<");
if has_title_down
|| has_status_inner_down
|| has_tagged_down
|| has_quoted_down
|| has_plain_down
{
// Verify it's not part of "operational" or other positive status
// Also check that we're not seeing "download" or similar words
if !aur_window.contains("operational")
&& !aur_window.contains("download")
&& !aur_window.contains("shutdown")
&& !aur_window.contains("breakdown")
{
return true;
}
}
}
}
false
}
/// What: Format AUR percentage suffix for status messages.
///
/// Inputs:
/// - `body`: Raw HTML content to extract percentage from.
///
/// Output:
/// - Formatted suffix string with AUR uptime percentage if available.
fn format_aur_pct_suffix(body: &str) -> String {
extract_aur_today_percent(body)
.map(|p| format!(" β AUR today: {p}%"))
.unwrap_or_default()
}
/// What: Handle arch systems status when problems are detected.
///
/// Inputs:
/// - `body`: Raw HTML content.
/// - `systems_status_color`: Detected systems status color.
/// - `aur_is_down`: Whether AUR is specifically down.
///
/// Output:
/// - `(text, color)` tuple representing the status.
fn handle_arch_systems_status(
body: &str,
systems_status_color: ArchStatusColor,
aur_is_down: bool,
) -> (String, ArchStatusColor) {
let aur_pct_suffix = format_aur_pct_suffix(body);
if aur_is_down {
return (
format!("Status: AUR Down{aur_pct_suffix}"),
ArchStatusColor::IncidentSevereToday,
);
}
let text = match systems_status_color {
ArchStatusColor::IncidentSevereToday => {
format!("Some Arch systems down (see status){aur_pct_suffix}")
}
ArchStatusColor::IncidentToday => {
format!("Arch systems degraded (see status){aur_pct_suffix}")
}
_ => format!("Arch systems nominal{aur_pct_suffix}"),
};
(text, systems_status_color)
}
/// What: Check if outage announcement is for today's date.
///
/// Inputs:
/// - `body`: Raw HTML content.
/// - `outage_pos`: Position where outage key was found.
///
/// Output:
/// - `true` if outage is for today, `false` otherwise.
fn is_outage_today(body: &str, outage_pos: usize) -> bool {
let start = outage_pos.saturating_sub(220);
let region = &body[start..std::cmp::min(body.len(), outage_pos + 220)];
let months = [
"January",
"February",
"March",
"April",
"May",
"June",
"July",
"August",
"September",
"October",
"November",
"December",
];
for m in &months {
if let Some(mi) = region.find(m) {
let mut idx = mi + m.len();
let rbytes = region.as_bytes();
while idx < region.len() && (rbytes[idx] == b' ' || rbytes[idx] == b',') {
idx += 1;
}
let day_start = idx;
while idx < region.len() && rbytes[idx].is_ascii_digit() {
idx += 1;
}
if idx == day_start {
continue;
}
let day_s = ®ion[day_start..idx];
while idx < region.len() && (rbytes[idx] == b' ' || rbytes[idx] == b',') {
idx += 1;
}
let year_start = idx;
let mut count = 0;
while idx < region.len() && rbytes[idx].is_ascii_digit() && count < 4 {
idx += 1;
count += 1;
}
if count == 4
&& let (Ok(day), Some((ty, tm, td))) =
(day_s.trim().parse::<u32>(), today_ymd_utc())
{
let month_idx = u32::try_from(
months
.iter()
.position(|mm| *mm == *m)
.expect("month should be found in months array since it came from there"),
)
.expect("month index fits in u32")
+ 1;
let year_s = ®ion[year_start..(year_start + 4)];
return tm == month_idx && td == day && ty.to_string() == year_s;
}
break;
}
}
false
}
/// What: Handle outage announcement parsing.
///
/// Inputs:
/// - `body`: Raw HTML content.
/// - `lowered`: Lowercased body.
/// - `outage_pos`: Position where outage key was found.
/// - `aur_pct_suffix`: AUR percentage suffix.
/// - `aur_pct_opt`: Optional AUR percentage.
/// - `final_color`: Final color determined from other sources.
/// - `has_all_ok`: Whether "all systems operational" text is present.
///
/// Output:
/// - `(text, color)` tuple representing the status.
fn handle_outage_announcement(
body: &str,
_lowered: &str,
outage_pos: usize,
aur_pct_suffix: &str,
aur_pct_opt: Option<u32>,
final_color: Option<ArchStatusColor>,
has_all_ok: bool,
) -> (String, ArchStatusColor) {
if is_outage_today(body, outage_pos) {
let forced_color = match aur_pct_opt {
Some(p) if p < 90 => ArchStatusColor::IncidentSevereToday,
_ => ArchStatusColor::IncidentToday,
};
return (
format!("AUR outage (see status){aur_pct_suffix}"),
severity_max(
forced_color,
final_color.unwrap_or(ArchStatusColor::IncidentToday),
),
);
}
if has_all_ok {
return (
format!("All systems operational{aur_pct_suffix}"),
final_color.unwrap_or(ArchStatusColor::IncidentToday),
);
}
(
format!("Arch systems nominal{aur_pct_suffix}"),
final_color.unwrap_or(ArchStatusColor::IncidentToday),
)
}
/// Parse a status message and color from the HTML of a status page.
///
/// Inputs:
/// - `body`: Raw HTML content to analyze.
///
/// Output:
/// - Tuple `(message, color)` representing a concise status and visual color classification.
pub(super) fn parse_arch_status_from_html(body: &str) -> (String, ArchStatusColor) {
let lowered = body.to_lowercase();
let has_all_ok = lowered.contains("all systems operational");
let arch_systems_status_color = extract_arch_systems_status_color(body);
let aur_is_down = is_aur_down_in_monitors(body);
if let Some(systems_status_color) = arch_systems_status_color
&& matches!(
systems_status_color,
ArchStatusColor::IncidentToday | ArchStatusColor::IncidentSevereToday
)
{
return handle_arch_systems_status(body, systems_status_color, aur_is_down);
}
if aur_is_down {
let aur_pct_suffix = format_aur_pct_suffix(body);
return (
format!("Status: AUR Down{aur_pct_suffix}"),
ArchStatusColor::IncidentSevereToday,
);
}
let aur_pct_opt = extract_aur_today_percent(body);
let aur_pct_suffix = format_aur_pct_suffix(body);
let aur_color_from_pct = aur_pct_opt.map(|p: u32| {
if p > 95 {
ArchStatusColor::Operational
} else if p >= 90 {
ArchStatusColor::IncidentToday
} else {
ArchStatusColor::IncidentSevereToday
}
});
let aur_color_from_rect = extract_aur_today_rect_color(body);
let status_update_color = extract_status_updates_today_color(body);
let final_color = arch_systems_status_color
.or(aur_color_from_rect)
.or(status_update_color)
.or(aur_color_from_pct);
let outage_key = "the aur is currently experiencing an outage";
if let Some(pos) = lowered.find(outage_key) {
return handle_outage_announcement(
body,
&lowered,
pos,
&aur_pct_suffix,
aur_pct_opt,
final_color,
has_all_ok,
);
}
if let Some(rect_color) = aur_color_from_rect
&& matches!(
rect_color,
ArchStatusColor::IncidentToday | ArchStatusColor::IncidentSevereToday
)
{
let text = if has_all_ok {
format!("AUR issues detected (see status){aur_pct_suffix}")
} else {
format!("AUR degraded (see status){aur_pct_suffix}")
};
return (text, rect_color);
}
if let Some(update_color) = status_update_color
&& matches!(
update_color,
ArchStatusColor::IncidentToday | ArchStatusColor::IncidentSevereToday
)
{
let text = if has_all_ok {
format!("AUR issues detected (see status){aur_pct_suffix}")
} else {
format!("AUR degraded (see status){aur_pct_suffix}")
};
return (text, update_color);
}
if has_all_ok {
return (
format!("All systems operational{aur_pct_suffix}"),
final_color.unwrap_or(ArchStatusColor::Operational),
);
}
(
format!("Arch systems nominal{aur_pct_suffix}"),
final_color.unwrap_or(ArchStatusColor::None),
)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
/// What: Verify that "Some systems down" heading is detected and returns correct status.
///
/// Inputs:
/// - HTML with "Some systems down" as a heading (actual status page format) but AUR is operational.
///
/// Output:
/// - Returns status text "Some Arch systems down (see status)" with `IncidentSevereToday` color.
///
/// Details:
/// - Ensures the early check for arch systems status works correctly and isn't overridden by other checks.
fn status_parse_detects_some_systems_down_heading() {
// HTML with "Some systems down" but AUR is operational (so it should show generic message)
let html = "<html><body><h2>Some systems down</h2><div>Monitors (default)</div><div>AUR</div><div>Operational</div></body></html>";
let (text, color) = parse_arch_status_from_html(html);
assert_eq!(color, ArchStatusColor::IncidentSevereToday);
assert!(text.contains("Some Arch systems down"));
}
#[test]
/// What: Parse Arch status HTML to derive AUR color by percentage buckets and outage flag.
///
/// Inputs:
/// - Synthetic HTML windows around today's date containing percentages of 97, 95, 89 and optional outage headings.
///
/// Output:
/// - Returns `ArchStatusColor::Operational` above 95%, `IncidentToday` for 90-95%, `IncidentSevereToday` below 90%, and elevates outage cases to at least `IncidentToday`.
///
/// Details:
/// - Builds several HTML variants to confirm the parser reacts to both high-level outage banners and raw percentages.
#[allow(clippy::many_single_char_names)]
fn status_parse_color_by_percentage_and_outage() {
let (y, m, d) = {
let out = std::process::Command::new("date")
.args(["-u", "+%Y-%m-%d"])
.output();
let Ok(o) = out else { return };
if !o.status.success() {
return;
}
let Ok(s) = String::from_utf8(o.stdout) else {
return;
};
let mut it = s.trim().split('-');
let (Some(y), Some(m), Some(d)) = (it.next(), it.next(), it.next()) else {
return;
};
let (Ok(y), Ok(m), Ok(d)) = (y.parse::<i32>(), m.parse::<u32>(), d.parse::<u32>())
else {
return;
};
(y, m, d)
};
let months = [
"January",
"February",
"March",
"April",
"May",
"June",
"July",
"August",
"September",
"October",
"November",
"December",
];
let month_name = months[(m - 1) as usize];
let date_str = format!("{month_name} {d}, {y}");
let make_html = |percent: u32, outage: bool| -> String {
format!(
"<html><body><h2>Uptime Last 90 days</h2><div>Monitors (default)</div><div>AUR</div><div>{date_str}</div><div>{percent}% uptime</div>{outage_block}</body></html>",
outage_block = if outage {
"<h4>The AUR is currently experiencing an outage</h4>"
} else {
""
}
)
};
let html_green = make_html(97, false);
let (_txt, color) = parse_arch_status_from_html(&html_green);
assert_eq!(color, ArchStatusColor::Operational);
let html_yellow = make_html(95, false);
let (_txt, color) = parse_arch_status_from_html(&html_yellow);
assert_eq!(color, ArchStatusColor::IncidentToday);
let html_red = make_html(89, false);
let (_txt, color) = parse_arch_status_from_html(&html_red);
assert_eq!(color, ArchStatusColor::IncidentSevereToday);
let html_outage = make_html(97, true);
let (_txt, color) = parse_arch_status_from_html(&html_outage);
assert_eq!(color, ArchStatusColor::IncidentToday);
let html_outage_red = make_html(80, true);
let (_txt, color) = parse_arch_status_from_html(&html_outage_red);
assert_eq!(color, ArchStatusColor::IncidentSevereToday);
}
#[test]
/// What: Prefer the SVG rect fill color over the textual percentage when both are present.
///
/// Inputs:
/// - HTML snippet around today's date with a green percentage but an SVG rect fill attribute set to yellow.
///
/// Output:
/// - Returns `ArchStatusColor::IncidentToday`, honoring the SVG-derived color.
///
/// Details:
/// - Ensures the parser checks the SVG dataset first so maintenance banners with stale percentages still reflect current outages.
#[allow(clippy::many_single_char_names)]
fn status_parse_prefers_svg_rect_color() {
let (y, m, d) = {
let out = std::process::Command::new("date")
.args(["-u", "+%Y-%m-%d"])
.output();
let Ok(o) = out else { return };
if !o.status.success() {
return;
}
let Ok(s) = String::from_utf8(o.stdout) else {
return;
};
let mut it = s.trim().split('-');
let (Some(y), Some(m), Some(d)) = (it.next(), it.next(), it.next()) else {
return;
};
let (Ok(y), Ok(m), Ok(d)) = (y.parse::<i32>(), m.parse::<u32>(), d.parse::<u32>())
else {
return;
};
(y, m, d)
};
let months = [
"January",
"February",
"March",
"April",
"May",
"June",
"July",
"August",
"September",
"October",
"November",
"December",
];
let month_name = months[(m - 1) as usize];
let date_str = format!("{month_name} {d}, {y}");
let html = format!(
"<html>\n <body>\n <h2>Uptime Last 90 days</h2>\n <div>Monitors (default)</div>\n <div>AUR</div>\n <svg>\n <rect x=\"900\" y=\"0\" width=\"10\" height=\"10\" fill=\"#f59e0b\"></rect>\n </svg>\n <div>{date_str}</div>\n <div>97% uptime</div>\n </body>\n</html>"
);
let (_txt, color) = parse_arch_status_from_html(&html);
assert_eq!(color, ArchStatusColor::IncidentToday);
}
#[test]
/// What: Verify that AUR "Down" status is detected and returns "Status: AUR Down" message.
///
/// Inputs:
/// - HTML with "Some systems down" heading and AUR showing "Down" in monitors section.
///
/// Output:
/// - Returns status text "Status: AUR Down" with `IncidentSevereToday` color.
///
/// Details:
/// - Ensures AUR-specific "Down" status is prioritized over generic "Some systems down" message.
fn status_parse_prioritizes_aur_down_over_some_systems_down() {
// HTML with "Some systems down" heading and AUR showing "Down"
let html = "<html><body><h2>Some systems down</h2><div>Monitors (default)</div><div>AUR</div><div>>Down<</div></body></html>";
let (text, color) = parse_arch_status_from_html(html);
assert_eq!(color, ArchStatusColor::IncidentSevereToday);
assert!(
text.contains("Status: AUR Down"),
"Expected 'Status: AUR Down' but got: {text}"
);
}
#[test]
/// What: Verify that `is_aur_down_in_monitors` correctly detects AUR "Down" status.
///
/// Inputs:
/// - HTML snippets with AUR showing "Down" in various formats in monitors section.
///
/// Output:
/// - Returns `true` when AUR shows "Down", `false` otherwise.
///
/// Details:
/// - Tests various HTML patterns for AUR "Down" status detection.
fn status_is_aur_down_in_monitors() {
// Test AUR Down with title="Down" pattern (actual status page format)
let html_title = "<html><body><div>Monitors</div><div>AUR</div><div title=\"Down\">Status</div></body></html>";
assert!(is_aur_down_in_monitors(html_title));
// Test AUR Down with title='Down' pattern
let html_title_single = "<html><body><div>Monitors</div><div>AUR</div><div title='Down'>Status</div></body></html>";
assert!(is_aur_down_in_monitors(html_title_single));
// Test AUR Down with actual status page HTML structure
let html_real = "<div class=\"psp-monitor-row\"><div>Monitors</div><div>AUR</div><div class=\"psp-monitor-row-status-inner\" title=\"Down\"><span>Down</span></div></div>";
assert!(is_aur_down_in_monitors(html_real));
// Test with actual website HTML structure (from status.archlinux.org)
// Must include "Monitors" text for the function to find the monitors section
let html_actual = "<div>Monitors (default)</div><div class=\"psp-monitor-row\"><div class=\"uk-flex uk-flex-between uk-flex-wrap\"><div class=\"psp-monitor-row-header uk-text-muted uk-flex uk-flex-auto\"><a title=\"AUR\" class=\"psp-monitor-name uk-text-truncate uk-display-inline-block\" href=\"https://status.archlinux.org/788139639\">AUR<svg class=\"icon icon-plus-square uk-flex-none\"><use href=\"/assets/symbol-defs.svg#icon-arrow-right\"></use></svg></a><div class=\"uk-flex-none\"><span class=\"m-r-5 m-l-5 uk-visible@s\">|</span><span class=\"uk-text-primary uk-visible@s\">94.864%</span><div class=\"uk-hidden@s uk-margin-small-left\"><div class=\"uk-text-danger psp-monitor-row-status-inner\" title=\"Down\"><span class=\"dot is-error\" aria-hidden=\"true\"></span><span class=\"uk-visible@s\">Down</span></div></div></div></div></div><div class=\"psp-monitor-row-status uk-visible@s\"><div class=\"uk-text-danger psp-monitor-row-status-inner\" title=\"Down\"><span class=\"dot is-error\" aria-hidden=\"true\"></span><span class=\"uk-visible@s\">Down</span></div></div></div>";
assert!(
is_aur_down_in_monitors(html_actual),
"Should detect AUR Down in actual website HTML structure"
);
// Test AUR Down with >down< pattern
let html1 = "<html><body><div>Monitors</div><div>AUR</div><div>>Down<</div></body></html>";
assert!(is_aur_down_in_monitors(html1));
// Test AUR Down with "down" pattern
let html2 =
"<html><body><div>Monitors</div><div>AUR</div><div>\"Down\"</div></body></html>";
assert!(is_aur_down_in_monitors(html2));
// Test AUR Down with 'down' pattern
let html3 = "<html><body><div>Monitors</div><div>AUR</div><div>'Down'</div></body></html>";
assert!(is_aur_down_in_monitors(html3));
// Test AUR Operational (should return false)
let html4 =
"<html><body><div>Monitors</div><div>AUR</div><div>Operational</div></body></html>";
assert!(!is_aur_down_in_monitors(html4));
// Test no monitors section (should return false)
let html5 = "<html><body><div>AUR</div><div>Down</div></body></html>";
assert!(!is_aur_down_in_monitors(html5));
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/sources/status/api.rs | src/sources/status/api.rs | use crate::state::ArchStatusColor;
use std::fmt::Write;
use super::utils::{severity_max, today_ymd_utc};
/// Parse the `UptimeRobot` API response to extract the worst status among all monitors (AUR, Forum, Website, Wiki).
///
/// Inputs:
/// - `v`: JSON value from <https://status.archlinux.org/api/getMonitorList/vmM5ruWEAB>
///
/// Output:
/// - `Some((text, color))` if monitor data is found, `None` otherwise.
/// Always returns the worst (lowest uptime) status among all monitored services.
pub(super) fn parse_uptimerobot_api(v: &serde_json::Value) -> Option<(String, ArchStatusColor)> {
let data = v.get("data")?.as_array()?;
// Get today's date in YYYY-MM-DD format
let (year, month, day) = today_ymd_utc()?;
let today_str = format!("{year}-{month:02}-{day:02}");
// Monitor names we care about
let monitor_names = ["AUR", "Forum", "Website", "Wiki"];
// Collect today's status for all monitors
let mut monitor_statuses: Vec<(String, f64, &str, &str)> = Vec::new();
for monitor in data {
let name = monitor.get("name")?.as_str()?;
if !monitor_names.iter().any(|&n| n.eq_ignore_ascii_case(name)) {
continue;
}
let daily_ratios = monitor.get("dailyRatios")?.as_array()?;
if let Some(today_data) = daily_ratios.iter().find(|d| {
d.get("date")
.and_then(|date| date.as_str())
.is_some_and(|date| date == today_str)
}) {
let ratio_str = today_data.get("ratio")?.as_str()?;
if let Ok(ratio) = ratio_str.parse::<f64>() {
let color_str = today_data.get("color")?.as_str()?;
let label = today_data.get("label")?.as_str()?;
monitor_statuses.push((name.to_string(), ratio, color_str, label));
}
}
}
if monitor_statuses.is_empty() {
return None;
}
// Find the worst status (lowest ratio, or if equal, worst color)
let worst = monitor_statuses.iter().min_by(|a, b| {
// First compare by ratio (lower is worse)
let ratio_cmp = a.1.partial_cmp(&b.1).unwrap_or(std::cmp::Ordering::Equal);
if ratio_cmp != std::cmp::Ordering::Equal {
return ratio_cmp;
}
// If ratios are equal, compare by color severity (red > yellow/blue > green)
let color_rank_a = match a.2 {
"red" => 3,
"yellow" | "blue" => 2,
"green" => 1,
_ => 0,
};
let color_rank_b = match b.2 {
"red" => 3,
"yellow" | "blue" => 2,
"green" => 1,
_ => 0,
};
color_rank_b.cmp(&color_rank_a) // Reverse because we want worst first
})?;
// Find AUR status separately
let aur_status = monitor_statuses
.iter()
.find(|s| s.0.eq_ignore_ascii_case("aur"));
let (name, ratio, color_str, label) = worst;
// Map UptimeRobot colors to our ArchStatusColor
let color = match *color_str {
"green" => ArchStatusColor::Operational,
"yellow" | "blue" => ArchStatusColor::IncidentToday,
"red" => ArchStatusColor::IncidentSevereToday,
_ => ArchStatusColor::None,
};
// Determine text based on ratio, label, and service name
let mut text = if *ratio < 90.0 {
format!("{name} outage (see status) β {name} today: {ratio:.1}%")
} else if *ratio < 95.0 {
format!("{name} degraded (see status) β {name} today: {ratio:.1}%")
} else if *label == "poor" || *color_str == "red" {
format!("{name} issues detected (see status) β {name} today: {ratio:.1}%")
} else {
format!("Arch systems nominal β {name} today: {ratio:.1}%")
};
// Always append AUR status in parentheses if AUR is not the worst service AND AUR has issues
if let Some((aur_name, aur_ratio, aur_color_str, _)) = aur_status
&& !aur_name.eq_ignore_ascii_case(name)
&& (*aur_ratio < 100.0 || *aur_color_str != "green")
{
let _ = write!(text, " (AUR: {aur_ratio:.1}%)");
}
Some((text, color))
}
/// Parse the Arch Status API summary JSON into a concise status line, color, and optional suffix.
///
/// Inputs:
/// - `v`: JSON value from <https://status.archlinux.org/api/v2/summary.json>
///
/// Output:
/// - `(text, color, suffix)` where `text` is either "All systems operational" or "Arch systems nominal",
/// `color` reflects severity, and `suffix` indicates the AUR component state when not operational.
pub(super) fn parse_status_api_summary(
v: &serde_json::Value,
) -> (String, ArchStatusColor, Option<String>) {
// Overall indicator severity
let indicator = v
.get("status")
.and_then(|s| s.get("indicator"))
.and_then(|i| i.as_str())
.unwrap_or("none");
let mut color = match indicator {
"none" => ArchStatusColor::Operational,
"minor" => ArchStatusColor::IncidentToday,
"major" | "critical" => ArchStatusColor::IncidentSevereToday,
_ => ArchStatusColor::None,
};
// AUR component detection and suffix mapping
let suffix: Option<String> = None;
let mut aur_state: Option<&str> = None;
if let Some(components) = v.get("components").and_then(|c| c.as_array())
&& let Some(aur_comp) = components.iter().find(|c| {
c.get("name")
.and_then(|n| n.as_str())
.is_some_and(|n| n.to_lowercase().contains("aur"))
})
&& let Some(state) = aur_comp.get("status").and_then(|s| s.as_str())
{
aur_state = Some(state);
match state {
"degraded_performance" => {
// Don't set suffix - text will already say "AUR RPC degraded"
color = severity_max(color, ArchStatusColor::IncidentToday);
}
"partial_outage" => {
// Don't set suffix - text will already say "AUR partial outage"
color = severity_max(color, ArchStatusColor::IncidentToday);
}
"major_outage" => {
// Don't set suffix - text will already say "AUR outage (see status)"
color = severity_max(color, ArchStatusColor::IncidentSevereToday);
}
"under_maintenance" => {
// Don't set suffix - text will already say "AUR maintenance ongoing"
color = severity_max(color, ArchStatusColor::IncidentToday);
}
_ => {}
}
}
// If AUR has a non-operational status, prioritize that in the text
let text = aur_state.map_or_else(
|| {
if indicator == "none" {
"All systems operational".to_string()
} else {
"Arch systems nominal".to_string()
}
},
|state| match state {
"major_outage" => "AUR outage (see status)".to_string(),
"partial_outage" => "AUR partial outage".to_string(),
"degraded_performance" => "AUR RPC degraded".to_string(),
"under_maintenance" => "AUR maintenance ongoing".to_string(),
_ => {
if indicator == "none" {
"All systems operational".to_string()
} else {
"Arch systems nominal".to_string()
}
}
},
);
(text, color, suffix)
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/sources/status/translate.rs | src/sources/status/translate.rs | use crate::state::AppState;
/// What: Extract AUR suffix information from remaining text after a service ratio.
///
/// Inputs:
/// - `remaining`: Text remaining after extracting service ratio
///
/// Output:
/// - `(Option<u32>, Option<f64>)` tuple with AUR percentage and ratio if found
fn extract_aur_suffix(remaining: &str) -> (Option<u32>, Option<f64>) {
let aur_suffix_pct = remaining.find(" β AUR today: ").and_then(|aur_pos| {
let aur_part = &remaining[aur_pos + 14..];
aur_part
.strip_suffix('%')
.and_then(|s| s.parse::<u32>().ok())
});
let aur_suffix_ratio = remaining.find(" (AUR: ").and_then(|aur_pos| {
let aur_part = &remaining[aur_pos + 7..];
aur_part
.strip_suffix("%)")
.and_then(|s| s.parse::<f64>().ok())
});
(aur_suffix_pct, aur_suffix_ratio)
}
/// What: Format translated text with optional AUR suffix.
///
/// Inputs:
/// - `app`: Application state
/// - `main_text`: Translated main text
/// - `aur_pct`: Optional AUR percentage
/// - `aur_ratio`: Optional AUR ratio
///
/// Output:
/// - Formatted text with AUR suffix if present
fn format_with_aur_suffix(
app: &AppState,
main_text: String,
aur_pct: Option<u32>,
aur_ratio: Option<f64>,
) -> String {
use crate::i18n;
if let Some(pct) = aur_pct {
format!(
"{}{}",
main_text,
i18n::t_fmt1(app, "app.arch_status.aur_today_suffix", pct)
)
} else if let Some(ratio) = aur_ratio {
format!("{main_text} (AUR: {ratio:.1}%)")
} else {
main_text
}
}
/// What: Parse and translate service status pattern with ratio.
///
/// Inputs:
/// - `app`: Application state
/// - `text`: Full status text
/// - `pattern`: Pattern to match (e.g., " outage (see status) β ")
/// - `translation_key`: Translation key for the pattern
///
/// Output:
/// - `Some(translated_text)` if pattern matches, `None` otherwise
fn translate_service_pattern(
app: &AppState,
text: &str,
pattern: &str,
translation_key: &str,
) -> Option<String> {
use crate::i18n;
if !text.contains(pattern) || !text.contains(" today: ") || text.contains(" β AUR today: ") {
return None;
}
let pattern_pos = text.find(pattern)?;
let service_name = &text[..pattern_pos];
let today_pos = text.find(" today: ")?;
let after_today = &text[today_pos + 8..];
let pct_pos = after_today.find('%')?;
let ratio_str = &after_today[..pct_pos];
let ratio: f64 = ratio_str.parse().ok()?;
let ratio_formatted = format!("{ratio:.1}");
let remaining = &after_today[pct_pos + 1..];
let (aur_pct, aur_ratio) = extract_aur_suffix(remaining);
let main_text = i18n::t_fmt(
app,
translation_key,
&[&service_name, &service_name, &ratio_formatted],
);
Some(format_with_aur_suffix(app, main_text, aur_pct, aur_ratio))
}
/// What: Translate simple status text patterns using lookup table.
///
/// Inputs:
/// - `app`: Application state
/// - `base_text`: Base text to translate
///
/// Output:
/// - `Some(translated_text)` if pattern matches, `None` otherwise
fn translate_simple_pattern(app: &AppState, base_text: &str) -> Option<String> {
use crate::i18n;
let translation_key = match base_text {
"Status: AUR Down" => Some("app.arch_status.aur_down"),
"Some Arch systems down (see status)" => Some("app.arch_status.some_systems_down"),
"Arch systems degraded (see status)" => Some("app.arch_status.systems_degraded"),
"Arch systems nominal" => Some("app.arch_status.systems_nominal"),
"All systems operational" => Some("app.arch_status.all_systems_operational"),
"AUR outage (see status)" => Some("app.arch_status.aur_outage"),
"AUR partial outage" => Some("app.arch_status.aur_partial_outage"),
"AUR RPC degraded" => Some("app.arch_status.aur_rpc_degraded"),
"AUR maintenance ongoing" => Some("app.arch_status.aur_maintenance_ongoing"),
"AUR issues detected (see status)" => Some("app.arch_status.aur_issues_detected"),
"AUR degraded (see status)" => Some("app.arch_status.aur_degraded"),
_ => None,
};
translation_key.map(|key| i18n::t(app, key))
}
/// What: Translate "Arch systems nominal β {service} today: {ratio}%" pattern.
///
/// Inputs:
/// - `app`: Application state
/// - `text`: Full status text
///
/// Output:
/// - `Some(translated_text)` if pattern matches, `None` otherwise
fn translate_nominal_with_service(app: &AppState, text: &str) -> Option<String> {
use crate::i18n;
if !text.starts_with("Arch systems nominal β ")
|| !text.contains(" today: ")
|| text.contains(" β AUR today: ")
{
return None;
}
let today_pos = text.find(" today: ")?;
let service_part = &text[24..today_pos]; // "Arch systems nominal β " is 24 chars
let after_today = &text[today_pos + 8..];
let pct_pos = after_today.find('%')?;
let ratio_str = &after_today[..pct_pos];
let ratio: f64 = ratio_str.parse().ok()?;
let ratio_formatted = format!("{ratio:.1}");
let remaining = &after_today[pct_pos + 1..];
let (aur_pct, aur_ratio) = extract_aur_suffix(remaining);
let main_text = i18n::t_fmt(
app,
"app.arch_status.systems_nominal_with_service",
&[&service_part, &ratio_formatted],
);
Some(format_with_aur_suffix(app, main_text, aur_pct, aur_ratio))
}
/// What: Translate Arch systems status text from English to the current locale.
///
/// Inputs:
/// - `app`: Application state containing translations
/// - `text`: English status text to translate
///
/// Output:
/// - Translated status text, or original text if translation not found
///
/// Details:
/// - Parses English status messages and maps them to translation keys
/// - Handles dynamic parts like percentages and service names
/// - Falls back to original text if pattern doesn't match
#[must_use]
pub fn translate_status_text(app: &AppState, text: &str) -> String {
// Check for complex patterns with service names first (before extracting AUR suffix)
// These patterns have their own "today: {ratio}%" that's not the AUR suffix
if let Some(result) = translate_service_pattern(
app,
text,
" outage (see status) β ",
"app.arch_status.service_outage",
) {
return result;
}
if let Some(result) = translate_service_pattern(
app,
text,
" degraded (see status) β ",
"app.arch_status.service_degraded",
) {
return result;
}
if let Some(result) = translate_service_pattern(
app,
text,
" issues detected (see status) β ",
"app.arch_status.service_issues_detected",
) {
return result;
}
if let Some(result) = translate_nominal_with_service(app, text) {
return result;
}
// Extract AUR percentage suffix if present (for simple patterns)
let (base_text, aur_pct) = text
.find(" β AUR today: ")
.map_or((text, None), |suffix_pos| {
let (base, suffix) = text.split_at(suffix_pos);
let pct = suffix
.strip_prefix(" β AUR today: ")
.and_then(|s| s.strip_suffix('%'))
.and_then(|s| s.parse::<u32>().ok());
(base, pct)
});
// Extract AUR suffix in parentheses if present
let (base_text, aur_ratio) =
base_text
.find(" (AUR: ")
.map_or((base_text, None), |suffix_pos| {
let (base, suffix) = base_text.split_at(suffix_pos);
let ratio = suffix
.strip_prefix(" (AUR: ")
.and_then(|s| s.strip_suffix("%)"))
.and_then(|s| s.parse::<f64>().ok());
(base, ratio)
});
// Match base text patterns and translate
let Some(translated) = translate_simple_pattern(app, base_text) else {
// Pattern not recognized, return original
return text.to_string();
};
// Append AUR percentage suffix if present
format_with_aur_suffix(app, translated, aur_pct, aur_ratio)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::state::AppState;
#[test]
/// What: Test translation of simple status messages.
///
/// Inputs:
/// - English status text
/// - `AppState` with translations
///
/// Output:
/// - Translated status text
///
/// Details:
/// - Verifies basic status message translation
fn test_translate_simple_status() {
let app = AppState::default();
let text = "Arch systems nominal";
let translated = translate_status_text(&app, text);
// Should return translation or fallback to English
assert!(!translated.is_empty());
}
#[test]
/// What: Test translation of status messages with AUR percentage.
///
/// Inputs:
/// - English status text with AUR percentage suffix
/// - `AppState` with translations
///
/// Output:
/// - Translated status text with translated suffix
///
/// Details:
/// - Verifies status message translation with dynamic percentage
fn test_translate_status_with_aur_pct() {
let app = AppState::default();
let text = "Arch systems nominal β AUR today: 97%";
let translated = translate_status_text(&app, text);
// Should return translation or fallback to English
assert!(!translated.is_empty());
// The translation should contain the percentage or be a valid translation
assert!(translated.contains("97") || translated.contains("AUR") || translated.len() > 10);
}
#[test]
/// What: Test translation of service degraded pattern with percentage formatting.
///
/// Inputs:
/// - English status text with service degraded pattern and percentage
/// - `AppState` with translations
///
/// Output:
/// - Translated status text with properly formatted percentage
///
/// Details:
/// - Verifies that percentage is formatted with .1 precision and not showing format specifier
fn test_translate_service_degraded_with_percentage() {
let app = AppState::default();
let text = "Website degraded (see status) β Website today: 91.275%";
let translated = translate_status_text(&app, text);
// Should return translation or fallback to English
assert!(!translated.is_empty());
// The main bug fix: should not contain the format specifier literal {:.1}
// This was the bug where {:.1}% was showing up instead of the actual percentage
// We need to check for the literal string "{:.1}" which clippy flags as a format specifier,
// but this is intentional - we're testing that translations don't contain this literal.
#[allow(clippy::literal_string_with_formatting_args)]
let format_spec = "{:.1}";
assert!(
!translated.contains(format_spec),
"Translation should not contain format specifier {format_spec}, got: {translated}"
);
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/sources/status/utils.rs | src/sources/status/utils.rs | use crate::state::ArchStatusColor;
/// What: Check for "Status: Arch systems..." pattern and detect if "Some Systems down" or "Down" is shown.
///
/// Inputs:
/// - `body`: Raw HTML content to analyze.
///
/// Output:
/// - `Some(ArchStatusColor)` if "Some Systems down" or "Down" is detected in the status context, `None` otherwise.
///
/// Details: Searches for the "Status: Arch systems..." pattern and checks if it's followed by "Some Systems down" or "Down" indicators.
/// Also checks for "Some systems down" as a standalone heading/text and the monitors section for individual systems showing "Down" status.
pub(super) fn extract_arch_systems_status_color(body: &str) -> Option<ArchStatusColor> {
let lowered = body.to_lowercase();
let mut found_severe = false;
let mut found_moderate = false;
// First, check for "Some systems down" as a standalone heading/text (most common case)
// This appears as a heading on the status page when systems are down
if lowered.contains("some systems down") {
found_severe = true;
}
// Look for "Status: Arch systems..." pattern (case-insensitive)
let status_patterns = ["status: arch systems", "status arch systems"];
// Check for overall status message pattern
for pattern in status_patterns {
if let Some(pos) = lowered.find(pattern) {
// Check in a window around the pattern (500 chars after)
let window_start = pos;
let window_end = std::cmp::min(body.len(), pos + pattern.len() + 500);
let window = &lowered[window_start..window_end];
// Check for "Some Systems down" or "Down" in the context
if window.contains("some systems down") {
found_severe = true;
} else if window.contains("down") {
// Only treat as incident if not part of "operational" or "all systems operational"
if !window.contains("all systems operational") && !window.contains("operational") {
found_moderate = true;
}
}
}
}
// Also check the monitors section for "Down" status
// Look for the monitors section and check if any monitor shows "Down"
if let Some(monitors_pos) = lowered.find("monitors") {
let monitors_window_start = monitors_pos;
let monitors_window_end = std::cmp::min(body.len(), monitors_pos + 5000);
let monitors_window = &lowered[monitors_window_start..monitors_window_end];
// Check if "Down" appears in the monitors section (but not as part of "operational")
// Look for patterns like ">Down<" or "Down" in quotes, indicating a status
if monitors_window.contains("down") {
// More specific check: look for "Down" that appears to be a status indicator
// This avoids false positives from words containing "down" like "download"
// Check for HTML patterns that indicate status: >down< or "down" or 'down'
if monitors_window.contains(">down<")
|| monitors_window.contains("\"down\"")
|| monitors_window.contains("'down'")
{
// Verify it's not part of "operational" or other positive status
if !monitors_window.contains("operational") {
found_moderate = true;
}
}
// Check for "Some Systems down" in monitors context
if monitors_window.contains("some systems down") {
found_severe = true;
}
}
}
if found_severe {
Some(ArchStatusColor::IncidentSevereToday)
} else if found_moderate {
Some(ArchStatusColor::IncidentToday)
} else {
None
}
}
/// What: Choose the more severe `ArchStatusColor` between two candidates.
///
/// Input: Two color severities `a` and `b`.
/// Output: The color with higher impact according to predefined ordering.
///
/// Details: Converts colors to integer ranks and returns the higher rank so callers can merge
/// multiple heuristics without under-reporting incidents.
pub(super) const fn severity_max(a: ArchStatusColor, b: ArchStatusColor) -> ArchStatusColor {
const fn rank(c: ArchStatusColor) -> u8 {
match c {
ArchStatusColor::None => 0,
ArchStatusColor::Operational => 1,
ArchStatusColor::IncidentToday => 2,
ArchStatusColor::IncidentSevereToday => 3,
}
}
if rank(a) >= rank(b) { a } else { b }
}
/// Return today's UTC date as (year, month, day) using the system `date` command.
///
/// Inputs:
/// - None
///
/// Output:
/// - `Some((year, month, day))` on success; `None` if the conversion fails.
pub(super) fn today_ymd_utc() -> Option<(i32, u32, u32)> {
use std::time::{SystemTime, UNIX_EPOCH};
let now = SystemTime::now().duration_since(UNIX_EPOCH).ok()?.as_secs();
// Convert Unix timestamp to UTC date using a simple algorithm
// This is a simplified version that works for dates from 1970 onwards
let days_since_epoch = now / 86400;
// Calculate year, month, day from days since epoch
// Using a simple approximation (not accounting for leap seconds, but good enough for our use case)
let mut year = 1970;
let mut days = days_since_epoch;
// Account for leap years
loop {
let days_in_year = if is_leap_year(year) { 366 } else { 365 };
if days < days_in_year {
break;
}
days -= days_in_year;
year += 1;
}
// Calculate month and day
let days_in_month = [
31,
if is_leap_year(year) { 29 } else { 28 },
31,
30,
31,
30,
31,
31,
30,
31,
30,
31,
];
let mut month: u32 = 1;
let mut day: u64 = days;
for &days_in_m in &days_in_month {
let days_in_m_u64 = u64::try_from(days_in_m).unwrap_or(0);
if day < days_in_m_u64 {
break;
}
day -= days_in_m_u64;
month += 1;
}
Some((
year,
month,
u32::try_from(day).expect("day fits in u32") + 1,
)) // +1 because day is 0-indexed
}
/// What: Determine whether a given year is a leap year in the Gregorian calendar.
///
/// Input: Four-digit year as signed integer.
/// Output: `true` when the year has 366 days; `false` otherwise.
///
/// Details: Applies the standard divisible-by-4 rule with century and 400-year exceptions.
#[inline]
const fn is_leap_year(year: i32) -> bool {
(year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)
}
/// Attempt to extract today's AUR uptime percentage from the Arch status page HTML.
/// Heuristic-based parsing: look near "Uptime Last 90 days" β "Monitors (default)" β "AUR",
/// then find today's date string and the closest percentage like "97%" around it.
/// Heuristically extract today's AUR uptime percentage from status HTML.
///
/// Inputs:
/// - `body`: Full HTML body string
///
/// Output:
/// - `Some(percent)` like 97 for today's cell; `None` if not found.
pub(super) fn extract_aur_today_percent(body: &str) -> Option<u32> {
let (year, month, day) = today_ymd_utc()?;
let months = [
"January",
"February",
"March",
"April",
"May",
"June",
"July",
"August",
"September",
"October",
"November",
"December",
];
let month_name = months.get((month.saturating_sub(1)) as usize)?;
let date_str = format!("{month_name} {day}, {year}");
let lowered = body.to_lowercase();
// Narrow down to the 90-day uptime monitors section around AUR
let base = "uptime last 90 days";
let mut base_pos = lowered.find(base)?;
if let Some(p) = lowered[base_pos..].find("monitors (default)") {
base_pos += p;
}
if let Some(p) = lowered[base_pos..].find("aur") {
base_pos += p;
}
let region_end = std::cmp::min(body.len(), base_pos.saturating_add(4000));
let region = &body[base_pos..region_end];
let region_lower = region.to_lowercase();
let date_pos = region_lower.find(&date_str.to_lowercase())?;
// Search in a small window around the date for a percentage like "97%"
let win_start = date_pos.saturating_sub(120);
let win_end = std::cmp::min(region_lower.len(), date_pos + 160);
let window = ®ion_lower[win_start..win_end];
// Find the first '%' closest to the date by scanning forward from date_pos within the window
// Prefer after-date occurrences; if none, fall back to before-date occurrences
let after_slice = &window[(date_pos - win_start)..];
if let Some(rel_idx) = after_slice.find('%') {
let abs_idx = win_start + (date_pos - win_start) + rel_idx;
if let Some(p) = digits_before_percent(®ion_lower, abs_idx) {
return p.parse::<u32>().ok();
}
}
// Fallback: search any percentage within the window
if let Some(rel_idx) = window.find('%') {
let abs_idx = win_start + rel_idx;
if let Some(p) = digits_before_percent(®ion_lower, abs_idx) {
return p.parse::<u32>().ok();
}
}
None
}
/// Collect up to 3 digits immediately preceding a '%' at `pct_idx` in `s`.
///
/// Inputs:
/// - `s`: Source string (typically a lowercase HTML slice)
/// - `pct_idx`: Index of the '%' character in `s`
///
/// Output:
/// - `Some(String)` containing the digits if present; otherwise `None`.
fn digits_before_percent(s: &str, pct_idx: usize) -> Option<String> {
if pct_idx == 0 || pct_idx > s.len() {
return None;
}
let mut i = pct_idx.saturating_sub(1);
let bytes = s.as_bytes();
let mut digits: Vec<u8> = Vec::new();
// Collect up to 3 digits directly preceding '%'
for _ in 0..3 {
if i < s.len() && bytes[i].is_ascii_digit() {
digits.push(bytes[i]);
if i == 0 {
break;
}
i = i.saturating_sub(1);
} else {
break;
}
}
if digits.is_empty() {
return None;
}
digits.reverse();
let s = String::from_utf8(digits).ok()?;
Some(s)
}
/// What: Infer today's AUR uptime color from the SVG heatmap on the status page.
///
/// Input: Full HTML string captured from status.archlinux.org.
/// Output: `Some(ArchStatusColor)` when a nearby `<rect>` fill value maps to a known palette; `None` otherwise.
///
/// Details: Focuses on the "Uptime Last 90 days" AUR section, locates today's date label, then scans
/// surrounding SVG rectangles for Tailwind-like fill colors that indicate green/yellow/red severity.
pub(super) fn extract_aur_today_rect_color(body: &str) -> Option<ArchStatusColor> {
let (year, month, day) = today_ymd_utc()?;
let months = [
"January",
"February",
"March",
"April",
"May",
"June",
"July",
"August",
"September",
"October",
"November",
"December",
];
let month_name = months.get((month.saturating_sub(1)) as usize)?;
let date_str = format!("{month_name} {day}, {year}");
let lowered = body.to_lowercase();
// Limit to the AUR monitors section
let base = "uptime last 90 days";
let mut base_pos = lowered.find(base)?;
if let Some(p) = lowered[base_pos..].find("monitors (default)") {
base_pos += p;
}
if let Some(p) = lowered[base_pos..].find("aur") {
base_pos += p;
}
let region_end = std::cmp::min(body.len(), base_pos.saturating_add(6000));
let region = &body[base_pos..region_end];
let region_lower = region.to_lowercase();
let date_pos = region_lower.find(&date_str.to_lowercase())?;
// Look around the date for the nearest preceding <rect ... fill="...">
let head = ®ion_lower[..date_pos];
if let Some(rect_pos) = head.rfind("<rect") {
// Extract attributes between <rect and the next '>' (bounded)
let tail = ®ion_lower[rect_pos..std::cmp::min(region_lower.len(), rect_pos + 400)];
if let Some(fill_idx) = tail.find("fill=") {
let after = &tail[fill_idx + 5..]; // skip 'fill='
// Accept values like "#f59e0b" or 'rgb(245 158 11)'
// Strip any leading quotes
let after = after.trim_start_matches(' ');
let quote = after.chars().next().unwrap_or('"');
let after = if quote == '"' || quote == '\'' {
&after[1..]
} else {
after
};
let value: String = after
.chars()
.take_while(|&c| c != '"' && c != '\'' && c != ' ' && c != '>')
.collect();
let v = value.to_lowercase();
// Common tailwind/statuspage palette guesses
if v.contains("#10b981") || v.contains("rgb(16 185 129)") {
return Some(ArchStatusColor::Operational);
}
if v.contains("#f59e0b") || v.contains("rgb(245 158 11)") || v.contains("#fbbf24") {
return Some(ArchStatusColor::IncidentToday);
}
if v.contains("#ef4444") || v.contains("rgb(239 68 68)") || v.contains("#dc2626") {
return Some(ArchStatusColor::IncidentSevereToday);
}
}
}
// Fallback: look forward as well (rect could trail the label)
let tail = ®ion_lower[date_pos..std::cmp::min(region_lower.len(), date_pos + 400)];
if let Some(rect_rel) = tail.find("<rect") {
let start = date_pos + rect_rel;
let slice = ®ion_lower[start..std::cmp::min(region_lower.len(), start + 400)];
if let Some(fill_idx) = slice.find("fill=") {
let after = &slice[fill_idx + 5..];
let after = after.trim_start_matches(' ');
let quote = after.chars().next().unwrap_or('"');
let after = if quote == '"' || quote == '\'' {
&after[1..]
} else {
after
};
let value: String = after
.chars()
.take_while(|&c| c != '"' && c != '\'' && c != ' ' && c != '>')
.collect();
let v = value.to_lowercase();
if v.contains("#10b981") || v.contains("rgb(16 185 129)") {
return Some(ArchStatusColor::Operational);
}
if v.contains("#f59e0b") || v.contains("rgb(245 158 11)") || v.contains("#fbbf24") {
return Some(ArchStatusColor::IncidentToday);
}
if v.contains("#ef4444") || v.contains("rgb(239 68 68)") || v.contains("#dc2626") {
return Some(ArchStatusColor::IncidentSevereToday);
}
}
}
None
}
/// What: Derive today's AUR severity from the textual "Status updates" section.
///
/// Input: Raw status page HTML used for keyword scanning.
/// Output: `Some(ArchStatusColor)` when today's entry references the AUR with notable keywords; `None` otherwise.
///
/// Details: Narrows to the status updates block, finds today's date string, and searches a sliding window for
/// AUR mentions coupled with severe or moderate keywords to upgrade incident severity heuristics.
pub(super) fn extract_status_updates_today_color(body: &str) -> Option<ArchStatusColor> {
let (year, month, day) = today_ymd_utc()?;
let months = [
"January",
"February",
"March",
"April",
"May",
"June",
"July",
"August",
"September",
"October",
"November",
"December",
];
let month_name = months.get((month.saturating_sub(1)) as usize)?;
let date_str = format!("{month_name} {day}, {year}");
let lowered = body.to_lowercase();
// Find the "Status updates" section
let base = "status updates";
let mut base_pos = lowered.find(base)?;
// Look for "Last 30 days" or "Last 7 days" or similar
let days_patterns = ["last 30 days", "last 7 days", "last 14 days"];
for pattern in days_patterns {
if let Some(p) = lowered[base_pos..].find(pattern) {
base_pos += p;
break;
}
}
// Search for today's date in the status updates section
// Look in a reasonable window (up to 10000 chars after "Status updates")
let region_end = std::cmp::min(body.len(), base_pos.saturating_add(10000));
let region = &body[base_pos..region_end];
let region_lower = region.to_lowercase();
// Find today's date in the region
let date_pos = region_lower.find(&date_str.to_lowercase())?;
// Look for keywords in a window around today's date (500 chars before and after)
let window_start = date_pos.saturating_sub(500);
let window_end = std::cmp::min(region_lower.len(), date_pos + 500);
let window = ®ion_lower[window_start..window_end];
// Keywords that indicate problems
let severe_keywords = [
"outage",
"down",
"unavailable",
"offline",
"failure",
"critical",
"major incident",
];
let moderate_keywords = [
"degraded",
"slow",
"intermittent",
"issues",
"problems",
"maintenance",
"partial",
];
// Check if AUR is mentioned in the context
let mentions_aur = window.contains("aur") || window.contains("arch user repository");
if !mentions_aur {
return None; // Not AUR-related
}
// Check for severe keywords
for keyword in &severe_keywords {
if window.contains(keyword) {
return Some(ArchStatusColor::IncidentSevereToday);
}
}
// Check for moderate keywords
for keyword in &moderate_keywords {
if window.contains(keyword) {
return Some(ArchStatusColor::IncidentToday);
}
}
None
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
/// What: Detect "Status: Arch systems..." pattern with "Some Systems down" or "Down" indicators.
///
/// Inputs:
/// - HTML snippets containing "Status: Arch systems..." followed by "Some Systems down" or "Down" status.
/// - HTML with monitors section showing "Down" status.
///
/// Output:
/// - Returns `ArchStatusColor::IncidentSevereToday` for "Some Systems down", `IncidentToday` for "Down", `None` when no issues detected.
///
/// Details:
/// - Verifies the function correctly identifies status patterns and monitor down indicators while avoiding false positives.
fn status_extract_arch_systems_status_color() {
// Test "Some Systems down" pattern
let html_severe =
"<html><body><div>Status: Arch systems Some Systems down</div></body></html>";
let color = extract_arch_systems_status_color(html_severe);
assert_eq!(color, Some(ArchStatusColor::IncidentSevereToday));
// Test "Down" pattern in status context
let html_moderate = "<html><body><div>Status: Arch systems Down</div></body></html>";
let color = extract_arch_systems_status_color(html_moderate);
assert_eq!(color, Some(ArchStatusColor::IncidentToday));
// Test "Down" in monitors section
let html_monitors_down =
"<html><body><div>Monitors (default)</div><div>AUR</div><div>Down</div></body></html>";
let color = extract_arch_systems_status_color(html_monitors_down);
assert_eq!(color, Some(ArchStatusColor::IncidentToday));
// Test "Down" in monitors section with HTML tags
let html_monitors_html = "<html><body><div>Monitors</div><div>>Down<</div></body></html>";
let color = extract_arch_systems_status_color(html_monitors_html);
assert_eq!(color, Some(ArchStatusColor::IncidentToday));
// Test "Down" in monitors section with quotes
let html_monitors_quotes =
"<html><body><div>Monitors</div><div>\"Down\"</div></body></html>";
let color = extract_arch_systems_status_color(html_monitors_quotes);
assert_eq!(color, Some(ArchStatusColor::IncidentToday));
// Test "Some Systems down" in monitors section
let html_monitors_severe =
"<html><body><div>Monitors</div><div>Some Systems down</div></body></html>";
let color = extract_arch_systems_status_color(html_monitors_severe);
assert_eq!(color, Some(ArchStatusColor::IncidentSevereToday));
// Test no issues (should return None)
let html_ok = "<html><body><div>Status: Arch systems Operational</div><div>Monitors</div><div>Operational</div></body></html>";
let color = extract_arch_systems_status_color(html_ok);
assert_eq!(color, None);
// Test "Down" but with "operational" context (should not trigger false positive)
let html_operational = "<html><body><div>Status: Arch systems Operational</div><div>Monitors</div><div>All systems operational</div></body></html>";
let color = extract_arch_systems_status_color(html_operational);
assert_eq!(color, None);
// Test case-insensitive matching
let html_lowercase =
"<html><body><div>status: arch systems some systems down</div></body></html>";
let color = extract_arch_systems_status_color(html_lowercase);
assert_eq!(color, Some(ArchStatusColor::IncidentSevereToday));
// Test "Down" without colon (alternative pattern)
let html_no_colon = "<html><body><div>Status Arch systems Down</div></body></html>";
let color = extract_arch_systems_status_color(html_no_colon);
assert_eq!(color, Some(ArchStatusColor::IncidentToday));
// Test "Some systems down" as a standalone heading (actual status page format)
let html_standalone_heading =
"<html><body><h2>Some systems down</h2><div>Monitors</div></body></html>";
let color = extract_arch_systems_status_color(html_standalone_heading);
assert_eq!(color, Some(ArchStatusColor::IncidentSevereToday));
// Test "Some systems down" in body text
let html_body_text = "<html><body><div>Some systems down</div></body></html>";
let color = extract_arch_systems_status_color(html_body_text);
assert_eq!(color, Some(ArchStatusColor::IncidentSevereToday));
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/sources/status/mod.rs | src/sources/status/mod.rs | //! Arch Linux status page parsing and monitoring.
use crate::state::ArchStatusColor;
use std::fmt::Write;
/// Status API parsing (`Statuspage` and `UptimeRobot` APIs).
mod api;
/// HTML parsing for status page.
mod html;
/// Translation utilities for status messages.
pub mod translate;
/// Utility functions for status parsing.
mod utils;
use api::{parse_status_api_summary, parse_uptimerobot_api};
use html::{is_aur_down_in_monitors, parse_arch_status_from_html};
use utils::{extract_aur_today_percent, extract_aur_today_rect_color, severity_max};
/// Result type alias for Arch Linux status fetching operations.
type Result<T> = super::Result<T>;
/// Fetch a short status text and color indicator from status.archlinux.org.
///
/// Inputs: none
///
/// Output:
/// - `Ok((text, color))` where `text` summarizes current status and `color` indicates severity.
/// - `Err` on network or parse failures.
///
/// # Errors
/// - Returns `Err` when network request fails (curl execution error)
/// - Returns `Err` when status API response cannot be fetched or parsed
/// - Returns `Err` when task spawn fails
///
#[allow(clippy::missing_const_for_fn)]
pub async fn fetch_arch_status_text() -> Result<(String, ArchStatusColor)> {
// 1) Prefer the official Statuspage API (reliable for active incidents and component states)
let api_url = "https://status.archlinux.org/api/v2/summary.json";
let api_result =
tokio::task::spawn_blocking(move || crate::util::curl::curl_json(api_url)).await;
if let Ok(Ok(v)) = api_result {
let (mut text, mut color, suffix) = parse_status_api_summary(&v);
// Always fetch HTML to check the visual indicator (rect color/beam) which may differ from API status
if let Ok(Ok(html)) = tokio::task::spawn_blocking(|| {
crate::util::curl::curl_text("https://status.archlinux.org")
})
.await
{
// FIRST PRIORITY: Check if AUR specifically shows "Down" status in monitors section
// This must be checked before anything else as it's the most specific indicator
if is_aur_down_in_monitors(&html) {
let aur_pct_opt = extract_aur_today_percent(&html);
let aur_pct_suffix = aur_pct_opt
.map(|p| format!(" β AUR today: {p}%"))
.unwrap_or_default();
let text = format!("Status: AUR Down{aur_pct_suffix}");
return Ok((text, ArchStatusColor::IncidentSevereToday));
}
// Extract today's AUR uptime percentage (best-effort)
let aur_pct_opt = extract_aur_today_percent(&html);
if let Some(p) = aur_pct_opt {
let _ = write!(text, " β AUR today: {p}%");
}
// Check the visual indicator (rect color/beam) - this is authoritative for current status
// The beam color can show red/yellow even when API says "operational"
if let Some(rect_color) = extract_aur_today_rect_color(&html) {
// If the visual indicator shows a problem but API says operational, trust the visual indicator
let api_says_operational = matches!(
v.get("components")
.and_then(|c| c.as_array())
.and_then(|arr| arr.iter().find(|c| {
c.get("name")
.and_then(|n| n.as_str())
.is_some_and(|n| n.to_lowercase().contains("aur"))
}))
.and_then(|c| c.get("status").and_then(|s| s.as_str())),
Some("operational")
);
if api_says_operational
&& matches!(
rect_color,
ArchStatusColor::IncidentToday | ArchStatusColor::IncidentSevereToday
)
{
// Visual indicator shows a problem but API says operational - trust the visual indicator
color = rect_color;
// Update text to reflect the visual indicator discrepancy
let text_lower = text.to_lowercase();
let pct_suffix = if text_lower.contains("aur today") {
String::new() // Already added
} else {
aur_pct_opt
.map(|p| format!(" β AUR today: {p}%"))
.unwrap_or_default()
};
match rect_color {
ArchStatusColor::IncidentSevereToday => {
if !text_lower.contains("outage") && !text_lower.contains("issues") {
text = format!("AUR issues detected (see status){pct_suffix}");
}
}
ArchStatusColor::IncidentToday => {
if !text_lower.contains("degraded")
&& !text_lower.contains("outage")
&& !text_lower.contains("issues")
{
text = format!("AUR degraded (see status){pct_suffix}");
}
}
_ => {}
}
} else {
// Use the more severe of API color or rect color
color = severity_max(color, rect_color);
}
}
}
if let Some(sfx) = suffix
&& !text.to_lowercase().contains(&sfx.to_lowercase())
{
text = format!("{text} {sfx}");
}
return Ok((text, color));
}
// 2) Try the UptimeRobot API endpoint (the actual API the status page uses)
let uptimerobot_api_url = "https://status.archlinux.org/api/getMonitorList/vmM5ruWEAB";
let uptimerobot_result =
tokio::task::spawn_blocking(move || crate::util::curl::curl_json(uptimerobot_api_url))
.await;
if let Ok(Ok(v)) = uptimerobot_result
&& let Some((mut text, mut color)) = parse_uptimerobot_api(&v)
{
// Also fetch HTML to check if AUR specifically shows "Down" status
// This takes priority over API response
if let Ok(Ok(html)) = tokio::task::spawn_blocking(|| {
crate::util::curl::curl_text("https://status.archlinux.org")
})
.await
&& is_aur_down_in_monitors(&html)
{
let aur_pct_opt = extract_aur_today_percent(&html);
let aur_pct_suffix = aur_pct_opt
.map(|p| format!(" β AUR today: {p}%"))
.unwrap_or_default();
text = format!("Status: AUR Down{aur_pct_suffix}");
color = ArchStatusColor::IncidentSevereToday;
}
return Ok((text, color));
}
// 3) Fallback: use the existing HTML parser + banner heuristic if APIs are unavailable
let url = "https://status.archlinux.org";
let body = tokio::task::spawn_blocking(move || crate::util::curl::curl_text(url)).await??;
// Skip AUR homepage keyword heuristic to avoid false outage flags
let (text, color) = parse_arch_status_from_html(&body);
// Heuristic banner scan disabled in fallback to avoid false positives.
Ok((text, color))
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/sources/feeds/rate_limit.rs | src/sources/feeds/rate_limit.rs | //! Rate limiting and circuit breaker for network requests.
use std::collections::HashMap;
use std::sync::{LazyLock, Mutex};
use std::time::{Duration, Instant};
use rand::Rng;
use tracing::{debug, warn};
use super::Result;
/// Rate limiter for news feed network requests.
/// Tracks the last request time to enforce minimum delay between requests.
static RATE_LIMITER: LazyLock<Mutex<Instant>> = LazyLock::new(|| Mutex::new(Instant::now()));
/// Minimum delay between news feed network requests (500ms).
const RATE_LIMIT_DELAY_MS: u64 = 500;
/// Rate limiter state for archlinux.org with exponential backoff.
struct ArchLinuxRateLimiter {
/// Last request timestamp.
last_request: Instant,
/// Current backoff delay in milliseconds (starts at base delay, increases exponentially).
current_backoff_ms: u64,
/// Number of consecutive failures/rate limits.
consecutive_failures: u32,
}
/// Rate limiter for archlinux.org requests with exponential backoff.
/// Tracks last request time and implements progressive delays on failures.
static ARCHLINUX_RATE_LIMITER: LazyLock<Mutex<ArchLinuxRateLimiter>> = LazyLock::new(|| {
Mutex::new(ArchLinuxRateLimiter {
last_request: Instant::now(),
current_backoff_ms: 500, // Start with 500ms base delay (reduced from 2s for faster initial requests)
consecutive_failures: 0,
})
});
/// Semaphore to serialize archlinux.org requests (only 1 concurrent request allowed).
/// This prevents multiple async tasks from overwhelming the server even when rate limiting
/// is applied, because the rate limiter alone doesn't prevent concurrent requests that
/// start at nearly the same time from all proceeding simultaneously.
static ARCHLINUX_REQUEST_SEMAPHORE: LazyLock<std::sync::Arc<tokio::sync::Semaphore>> =
LazyLock::new(|| std::sync::Arc::new(tokio::sync::Semaphore::new(1)));
/// Base delay for archlinux.org requests (2 seconds).
const ARCHLINUX_BASE_DELAY_MS: u64 = 500; // Reduced from 2000ms for faster initial requests
/// Maximum backoff delay (60 seconds).
const ARCHLINUX_MAX_BACKOFF_MS: u64 = 60000;
/// Circuit breaker state for tracking failures per endpoint type.
#[derive(Debug, Clone)]
enum CircuitState {
/// Circuit is closed - normal operation.
Closed,
/// Circuit is open - blocking requests due to failures.
Open {
/// Timestamp when circuit was opened (for cooldown calculation).
opened_at: Instant,
},
/// Circuit is half-open - allowing one test request.
HalfOpen,
}
/// Circuit breaker state tracking failures per endpoint pattern.
struct CircuitBreakerState {
/// Current circuit state.
state: CircuitState,
/// Recent request outcomes (true = success, false = failure).
/// Tracks last 10 requests to calculate failure rate.
recent_outcomes: Vec<bool>,
/// Endpoint pattern this breaker tracks (e.g., "/feeds/news/", "/packages/*/json/").
/// Stored for debugging/logging purposes.
#[allow(dead_code)]
endpoint_pattern: String,
}
/// Circuit breakers per endpoint pattern.
/// Key: endpoint pattern (e.g., "/feeds/news/", "/packages/*/json/")
static CIRCUIT_BREAKERS: LazyLock<Mutex<HashMap<String, CircuitBreakerState>>> =
LazyLock::new(|| Mutex::new(HashMap::new()));
/// Maximum number of recent outcomes to track for failure rate calculation.
const CIRCUIT_BREAKER_HISTORY_SIZE: usize = 10;
/// Failure rate threshold to open circuit (50% = 5 failures out of 10).
/// Used in calculation: `failure_count * 2 >= total_count` (equivalent to `>= 0.5`).
#[allow(dead_code)]
const CIRCUIT_BREAKER_FAILURE_THRESHOLD: f64 = 0.5;
/// Cooldown period before transitioning from `Open` to `HalfOpen` (60 seconds).
const CIRCUIT_BREAKER_COOLDOWN_SECS: u64 = 60;
/// Flag indicating a network error occurred during the last news fetch.
/// This can be checked by the UI to show a toast message.
static NETWORK_ERROR_FLAG: std::sync::atomic::AtomicBool =
std::sync::atomic::AtomicBool::new(false);
/// What: Check and clear the network error flag.
///
/// Inputs: None
///
/// Output: `true` if a network error occurred since the last check, `false` otherwise.
///
/// Details:
/// - Atomically loads and clears the flag.
/// - Used by the UI to show a toast when news fetch had network issues.
#[must_use]
pub fn take_network_error() -> bool {
NETWORK_ERROR_FLAG.swap(false, std::sync::atomic::Ordering::SeqCst)
}
/// What: Set the network error flag.
///
/// Inputs: None
///
/// Output: None
///
/// Details:
/// - Called when a network error occurs during news fetching.
pub(super) fn set_network_error() {
NETWORK_ERROR_FLAG.store(true, std::sync::atomic::Ordering::SeqCst);
}
/// What: Retry a network operation with exponential backoff on failure.
///
/// Inputs:
/// - `operation`: Async closure that returns a Result
/// - `max_retries`: Maximum number of retry attempts
///
/// Output:
/// - Result from the operation, or error if all retries fail
///
/// Details:
/// - On failure, waits with exponential backoff: 1s, 2s, 4s...
/// - Stops retrying after `max_retries` attempts
pub(super) async fn retry_with_backoff<T, E, F, Fut>(
mut operation: F,
max_retries: usize,
) -> std::result::Result<T, E>
where
F: FnMut() -> Fut,
Fut: std::future::Future<Output = std::result::Result<T, E>>,
{
let mut attempt = 0;
loop {
match operation().await {
Ok(result) => return Ok(result),
Err(e) => {
if attempt >= max_retries {
return Err(e);
}
attempt += 1;
let backoff_secs = 1u64 << (attempt - 1); // Exponential: 1, 2, 4, 8...
warn!(
attempt,
max_retries,
backoff_secs,
"network request failed, retrying with exponential backoff"
);
tokio::time::sleep(Duration::from_secs(backoff_secs)).await;
}
}
}
}
/// What: Apply rate limiting before making a network request.
///
/// Inputs: None
///
/// Output: None (async sleep if needed)
///
/// Details:
/// - Ensures minimum delay between network requests to avoid overwhelming servers.
/// - Thread-safe via mutex guarding the last request timestamp.
pub(super) async fn rate_limit() {
let delay_needed = {
let mut last_request = match RATE_LIMITER.lock() {
Ok(guard) => guard,
Err(poisoned) => poisoned.into_inner(),
};
let elapsed = last_request.elapsed();
let min_delay = Duration::from_millis(RATE_LIMIT_DELAY_MS);
let delay = if elapsed < min_delay {
// Safe to unwrap because we checked elapsed < min_delay above
#[allow(clippy::unwrap_used)]
min_delay.checked_sub(elapsed).unwrap()
} else {
Duration::ZERO
};
*last_request = Instant::now();
delay
};
if !delay_needed.is_zero() {
tokio::time::sleep(delay_needed).await;
}
}
/// Maximum jitter in milliseconds to add to rate limiting delays (prevents thundering herd).
const JITTER_MAX_MS: u64 = 500;
/// What: Apply rate limiting specifically for archlinux.org requests with exponential backoff.
///
/// Inputs: None
///
/// Output: `OwnedSemaphorePermit` that the caller MUST hold during the request.
///
/// # Panics
/// - Panics if the archlinux.org request semaphore is closed (should never happen in practice).
///
/// Details:
/// - Acquires a semaphore permit to serialize archlinux.org requests (only 1 at a time).
/// - Uses longer base delay (2 seconds) for archlinux.org to reduce request frequency.
/// - Implements exponential backoff: increases delay on consecutive failures (2s β 4s β 8s β 16s, max 60s).
/// - Adds random jitter (0-500ms) to prevent thundering herd when multiple clients retry simultaneously.
/// - Resets backoff after successful requests.
/// - Thread-safe via mutex guarding the rate limiter state.
/// - The returned permit MUST be held until the HTTP request completes to ensure serialization.
/// - If the permit is dropped before the HTTP request completes, another request may start concurrently,
/// defeating the serialization and potentially causing race conditions or overwhelming the server.
pub async fn rate_limit_archlinux() -> tokio::sync::OwnedSemaphorePermit {
// 1. Acquire semaphore to serialize requests (waits if another request is in progress)
// This is the key change - ensures only one archlinux.org request at a time
let permit = ARCHLINUX_REQUEST_SEMAPHORE
.clone()
.acquire_owned()
.await
// Semaphore is never closed, so this cannot fail in practice
.expect("archlinux.org request semaphore should never be closed");
// 2. Now that we have exclusive access, compute and apply the rate limiting delay
let delay_needed = {
let mut limiter = match ARCHLINUX_RATE_LIMITER.lock() {
Ok(guard) => guard,
Err(poisoned) => poisoned.into_inner(),
};
let elapsed = limiter.last_request.elapsed();
let min_delay = Duration::from_millis(limiter.current_backoff_ms);
let delay = if elapsed < min_delay {
// Safe to unwrap because we checked elapsed < min_delay above
#[allow(clippy::unwrap_used)]
min_delay.checked_sub(elapsed).unwrap()
} else {
Duration::ZERO
};
limiter.last_request = Instant::now();
delay
};
if !delay_needed.is_zero() {
// Add random jitter to prevent thundering herd when multiple clients retry simultaneously
let jitter_ms = rand::rng().random_range(0..=JITTER_MAX_MS);
let delay_with_jitter = delay_needed + Duration::from_millis(jitter_ms);
// Safe to unwrap: delay_ms will be small (max 60s = 60000ms, well within u64)
#[allow(clippy::cast_possible_truncation)]
let delay_ms = delay_needed.as_millis() as u64;
debug!(
delay_ms,
jitter_ms,
total_ms = delay_with_jitter.as_millis(),
"rate limiting archlinux.org request with jitter"
);
tokio::time::sleep(delay_with_jitter).await;
}
// 3. Return the permit - caller MUST hold it during the request
permit
}
/// What: Extract endpoint pattern from URL for circuit breaker tracking.
///
/// Inputs:
/// - `url`: Full URL to extract pattern from
///
/// Output:
/// - Endpoint pattern string (e.g., "/feeds/news/", "/packages/*/json/")
///
/// Details:
/// - Normalizes URLs to endpoint patterns for grouping similar requests.
/// - Replaces specific package names with "*" for JSON endpoints.
#[must_use]
pub fn extract_endpoint_pattern(url: &str) -> String {
// Extract path from URL
if let Some(path_start) = url.find("://")
&& let Some(path_pos) = url[path_start + 3..].find('/')
{
let path = &url[path_start + 3 + path_pos..];
// Normalize package-specific endpoints
if path.contains("/packages/") && path.contains("/json/") {
// Pattern: /packages/{repo}/{arch}/{name}/json/ -> /packages/*/json/
if let Some(json_pos) = path.find("/json/") {
let base = &path[..json_pos];
if let Some(last_slash) = base.rfind('/') {
return format!("{}/*/json/", &base[..=last_slash]);
}
}
}
// For feeds, use the full path
if path.starts_with("/feeds/") {
return path.to_string();
}
// For news articles, use /news/ pattern
if path.contains("/news/")
&& !path.ends_with('/')
&& let Some(news_pos) = path.find("/news/")
{
return format!("{}/*", &path[..news_pos + "/news/".len()]);
}
return path.to_string();
}
url.to_string()
}
/// What: Check circuit breaker state before making a request.
///
/// Inputs:
/// - `endpoint_pattern`: Endpoint pattern to check circuit breaker for
///
/// Output:
/// - `Ok(())` if request should proceed, `Err` with cached error if circuit is open
///
/// # Errors
/// - Returns `Err` if the circuit breaker is open and cooldown period has not expired.
///
/// Details:
/// - Returns error immediately if circuit is Open and cooldown not expired.
/// - Allows request if circuit is Closed or `HalfOpen`.
/// - Automatically transitions `Open` β `HalfOpen` after cooldown period.
#[allow(clippy::significant_drop_tightening)]
pub fn check_circuit_breaker(endpoint_pattern: &str) -> Result<()> {
// MutexGuard must be held for entire function to modify breaker state
let mut breakers = match CIRCUIT_BREAKERS.lock() {
Ok(guard) => guard,
Err(poisoned) => poisoned.into_inner(),
};
let breaker = breakers
.entry(endpoint_pattern.to_string())
.or_insert_with(|| CircuitBreakerState {
state: CircuitState::Closed,
recent_outcomes: Vec::new(),
endpoint_pattern: endpoint_pattern.to_string(),
});
match &breaker.state {
CircuitState::Open { opened_at } => {
let elapsed = opened_at.elapsed();
if elapsed.as_secs() >= CIRCUIT_BREAKER_COOLDOWN_SECS {
// Transition to HalfOpen after cooldown
breaker.state = CircuitState::HalfOpen;
debug!(
endpoint_pattern,
"circuit breaker transitioning Open β HalfOpen after cooldown"
);
Ok(())
} else {
// Still in cooldown, block request
let remaining = CIRCUIT_BREAKER_COOLDOWN_SECS - elapsed.as_secs();
warn!(
endpoint_pattern,
remaining_secs = remaining,
"circuit breaker is Open, blocking request"
);
Err(format!(
"Circuit breaker is Open for {endpoint_pattern} (cooldown: {remaining}s remaining)"
)
.into())
}
}
CircuitState::HalfOpen | CircuitState::Closed => Ok(()),
}
}
/// What: Record request outcome in circuit breaker.
///
/// Inputs:
/// - `endpoint_pattern`: Endpoint pattern for this request
/// - `success`: `true` if request succeeded, `false` if it failed
///
/// Output: None
///
/// Details:
/// - Records outcome in recent history (max 10 entries).
/// - On success: resets failure count, moves to Closed.
/// - On failure: increments failure count, opens circuit if >50% failure rate.
#[allow(clippy::significant_drop_tightening)]
pub fn record_circuit_breaker_outcome(endpoint_pattern: &str, success: bool) {
// MutexGuard must be held for entire function to modify breaker state
let mut breakers = match CIRCUIT_BREAKERS.lock() {
Ok(guard) => guard,
Err(poisoned) => poisoned.into_inner(),
};
let breaker = breakers
.entry(endpoint_pattern.to_string())
.or_insert_with(|| CircuitBreakerState {
state: CircuitState::Closed,
recent_outcomes: Vec::new(),
endpoint_pattern: endpoint_pattern.to_string(),
});
// Add outcome to history (keep last N)
breaker.recent_outcomes.push(success);
if breaker.recent_outcomes.len() > CIRCUIT_BREAKER_HISTORY_SIZE {
breaker.recent_outcomes.remove(0);
}
if success {
// On success, reset to Closed
breaker.state = CircuitState::Closed;
if !breaker.recent_outcomes.iter().all(|&x| x) {
debug!(
endpoint_pattern,
"circuit breaker: request succeeded, resetting to Closed"
);
}
} else {
// On failure, check if we should open circuit
let failure_count = breaker
.recent_outcomes
.iter()
.filter(|&&outcome| !outcome)
.count();
// Calculate failure rate using integer comparison to avoid precision loss
// Threshold is 0.5 (50%), so we check: failure_count * 2 >= total_count
let total_count = breaker.recent_outcomes.len();
if failure_count * 2 >= total_count && total_count >= CIRCUIT_BREAKER_HISTORY_SIZE {
// Open circuit
breaker.state = CircuitState::Open {
opened_at: Instant::now(),
};
warn!(
endpoint_pattern,
failure_count,
total = breaker.recent_outcomes.len(),
failure_percentage = (failure_count * 100) / total_count,
"circuit breaker opened due to high failure rate"
);
} else if matches!(breaker.state, CircuitState::HalfOpen) {
// HalfOpen test failed, go back to Open
breaker.state = CircuitState::Open {
opened_at: Instant::now(),
};
warn!(
endpoint_pattern,
"circuit breaker: HalfOpen test failed, reopening"
);
}
}
}
/// What: Extract Retry-After value from error message string.
///
/// Inputs:
/// - `error_msg`: Error message that may contain Retry-After information
///
/// Output:
/// - `Some(seconds)` if Retry-After found in error message, `None` otherwise
///
/// Details:
/// - Parses format: "error message (Retry-After: Ns)" where N is seconds.
#[must_use]
pub fn extract_retry_after_from_error(error_msg: &str) -> Option<u64> {
if let Some(start) = error_msg.find("Retry-After: ") {
let after_start = start + "Retry-After: ".len();
let remaining = &error_msg[after_start..];
if let Some(end) = remaining.find('s') {
let seconds_str = &remaining[..end];
return seconds_str.trim().parse::<u64>().ok();
}
}
None
}
/// What: Increase backoff delay for archlinux.org after a failure or rate limit.
///
/// Inputs:
/// - `retry_after_seconds`: Optional Retry-After value from server (in seconds)
///
/// Output: None
///
/// Details:
/// - If Retry-After is provided, uses that value (capped at maximum delay).
/// - Otherwise, doubles the current backoff delay (exponential backoff).
/// - Caps at maximum delay (60 seconds).
/// - Increments consecutive failure counter.
pub fn increase_archlinux_backoff(retry_after_seconds: Option<u64>) {
let mut limiter = match ARCHLINUX_RATE_LIMITER.lock() {
Ok(guard) => guard,
Err(poisoned) => poisoned.into_inner(),
};
limiter.consecutive_failures += 1;
// Use Retry-After value if provided, otherwise use exponential backoff
if let Some(retry_after) = retry_after_seconds {
// Convert seconds to milliseconds, cap at maximum
let retry_after_ms = (retry_after * 1000).min(ARCHLINUX_MAX_BACKOFF_MS);
limiter.current_backoff_ms = retry_after_ms;
warn!(
consecutive_failures = limiter.consecutive_failures,
retry_after_seconds = retry_after,
backoff_ms = limiter.current_backoff_ms,
"increased archlinux.org backoff delay using Retry-After header"
);
} else {
// Double the backoff delay, capped at maximum
limiter.current_backoff_ms = (limiter.current_backoff_ms * 2).min(ARCHLINUX_MAX_BACKOFF_MS);
warn!(
consecutive_failures = limiter.consecutive_failures,
backoff_ms = limiter.current_backoff_ms,
"increased archlinux.org backoff delay"
);
}
}
/// What: Reset backoff delay for archlinux.org after a successful request.
///
/// Inputs: None
///
/// Output: None
///
/// Details:
/// - Resets backoff to base delay (2 seconds).
/// - Resets consecutive failure counter.
pub fn reset_archlinux_backoff() {
let mut limiter = match ARCHLINUX_RATE_LIMITER.lock() {
Ok(guard) => guard,
Err(poisoned) => poisoned.into_inner(),
};
if limiter.consecutive_failures > 0 {
debug!(
previous_failures = limiter.consecutive_failures,
previous_backoff_ms = limiter.current_backoff_ms,
"resetting archlinux.org backoff after successful request"
);
}
limiter.current_backoff_ms = ARCHLINUX_BASE_DELAY_MS;
limiter.consecutive_failures = 0;
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/sources/feeds/tests.rs | src/sources/feeds/tests.rs | //! Tests for news feed functionality.
use crate::state::types::{AdvisorySeverity, AurComment, NewsFeedSource};
use std::collections::HashMap;
use super::cache::{CACHE_TTL_SECONDS, CacheEntry, DiskCacheEntry, disk_cache_ttl_seconds};
use super::helpers::{
build_official_update_item, extract_date_from_pkg_json, normalize_pkg_date,
update_seen_for_comments,
};
use super::*;
#[test]
/// What: Ensure date-descending sorting orders news items by date with newest first.
///
/// Inputs:
/// - News items with different dates.
///
/// Output:
/// - Items ordered by date in descending order (newest first).
///
/// Details:
/// - Verifies `sort_news_items` with `NewsSortMode::DateDesc` correctly sorts items.
fn sort_news_items_orders_by_date_desc() {
let mut items = vec![
NewsFeedItem {
id: "1".into(),
date: "2024-01-02".into(),
title: "B".into(),
summary: None,
url: None,
source: NewsFeedSource::ArchNews,
severity: None,
packages: vec![],
},
NewsFeedItem {
id: "2".into(),
date: "2024-01-03".into(),
title: "A".into(),
summary: None,
url: None,
source: NewsFeedSource::ArchNews,
severity: None,
packages: vec![],
},
];
sort_news_items(&mut items, NewsSortMode::DateDesc);
assert_eq!(items.first().map(|i| &i.id), Some(&"2".to_string()));
}
#[test]
/// What: Ensure severity-first sorting prioritises higher severities, then recency.
///
/// Inputs:
/// - Mixed severities across advisories with overlapping dates.
///
/// Output:
/// - Items ordered Critical > High > Medium > Low/Unknown/None, with date descending inside ties.
///
/// Details:
/// - Uses titles as a final tiebreaker to keep ordering deterministic.
fn sort_news_items_orders_by_severity_then_date() {
let mut items = vec![
NewsFeedItem {
id: "c-critical".into(),
date: "2024-01-02".into(),
title: "crit".into(),
summary: None,
url: None,
source: NewsFeedSource::SecurityAdvisory,
severity: Some(AdvisorySeverity::Critical),
packages: vec![],
},
NewsFeedItem {
id: "d-medium".into(),
date: "2024-01-04".into(),
title: "med".into(),
summary: None,
url: None,
source: NewsFeedSource::SecurityAdvisory,
severity: Some(AdvisorySeverity::Medium),
packages: vec![],
},
NewsFeedItem {
id: "b-high-older".into(),
date: "2023-12-31".into(),
title: "high-old".into(),
summary: None,
url: None,
source: NewsFeedSource::SecurityAdvisory,
severity: Some(AdvisorySeverity::High),
packages: vec![],
},
NewsFeedItem {
id: "a-high-newer".into(),
date: "2024-01-03".into(),
title: "high-new".into(),
summary: None,
url: None,
source: NewsFeedSource::SecurityAdvisory,
severity: Some(AdvisorySeverity::High),
packages: vec![],
},
NewsFeedItem {
id: "e-unknown".into(),
date: "2024-01-05".into(),
title: "unknown".into(),
summary: None,
url: None,
source: NewsFeedSource::SecurityAdvisory,
severity: Some(AdvisorySeverity::Unknown),
packages: vec![],
},
NewsFeedItem {
id: "f-none".into(),
date: "2024-01-06".into(),
title: "none".into(),
summary: None,
url: None,
source: NewsFeedSource::ArchNews,
severity: None,
packages: vec![],
},
];
sort_news_items(&mut items, NewsSortMode::SeverityThenDate);
let ids: Vec<String> = items.into_iter().map(|i| i.id).collect();
assert_eq!(
ids,
vec![
"c-critical",
"a-high-newer",
"b-high-older",
"d-medium",
"e-unknown",
"f-none"
]
);
}
#[test]
fn update_seen_for_comments_emits_on_first_run() {
let mut seen = HashMap::new();
let comments = vec![AurComment {
id: Some("c1".into()),
author: "a".into(),
date: "2025-01-01 00:00 (UTC)".into(),
date_timestamp: Some(0),
date_url: Some("https://aur.archlinux.org/packages/foo#comment-1".into()),
content: "hello world".into(),
pinned: false,
}];
let emitted = update_seen_for_comments("foo", &comments, &mut seen, 5, true);
assert_eq!(emitted.len(), 1, "first run should emit newest comments");
assert_eq!(emitted[0].id, "aur-comment:foo:c1");
assert_eq!(seen.get("foo"), Some(&"c1".to_string()));
}
#[test]
fn update_seen_for_comments_emits_until_seen_marker() {
let mut seen = HashMap::from([("foo".to_string(), "c1".to_string())]);
let comments = vec![
AurComment {
id: Some("c2".into()),
author: "a".into(),
date: "2025-01-02 00:00 (UTC)".into(),
date_timestamp: Some(0),
date_url: Some("https://aur.archlinux.org/packages/foo#comment-2".into()),
content: "second".into(),
pinned: false,
},
AurComment {
id: Some("c1".into()),
author: "a".into(),
date: "2025-01-01 00:00 (UTC)".into(),
date_timestamp: Some(0),
date_url: Some("https://aur.archlinux.org/packages/foo#comment-1".into()),
content: "first".into(),
pinned: false,
},
];
let emitted = update_seen_for_comments("foo", &comments, &mut seen, 5, false);
assert_eq!(emitted.len(), 1);
assert_eq!(emitted[0].id, "aur-comment:foo:c2");
assert_eq!(seen.get("foo"), Some(&"c2".to_string()));
}
#[test]
fn normalize_pkg_date_handles_rfc3339_and_utc_formats() {
assert_eq!(
normalize_pkg_date("2025-12-07T11:09:38Z"),
Some("2025-12-07".to_string())
);
assert_eq!(
normalize_pkg_date("2025-12-07 11:09 UTC"),
Some("2025-12-07".to_string())
);
// Test format with milliseconds (as returned by archlinux.org JSON API)
assert_eq!(
normalize_pkg_date("2025-12-15T19:30:14.422Z"),
Some("2025-12-15".to_string())
);
}
#[test]
fn extract_date_from_pkg_json_prefers_last_update() {
let val = serde_json::json!({
"pkg": {
"last_update": "2025-12-07T11:09:38Z",
"build_date": "2024-01-01T00:00:00Z"
}
});
let Some(pkg) = val.get("pkg") else {
panic!("pkg key missing");
};
let date = extract_date_from_pkg_json(pkg);
assert_eq!(date, Some("2025-12-07".to_string()));
}
#[test]
fn build_official_update_item_uses_metadata_date_when_available() {
let pkg = crate::state::PackageItem {
name: "xterm".into(),
version: "1".into(),
description: "term".into(),
source: crate::state::Source::Official {
repo: "extra".into(),
arch: "x86_64".into(),
},
popularity: None,
out_of_date: None,
orphaned: false,
};
let item = build_official_update_item(&pkg, None, Some("1"), "2", Some("2025-12-07".into()));
assert_eq!(item.date, "2025-12-07");
}
#[test]
/// What: Test disk cache loading with valid, expired, and corrupted cache files.
///
/// Inputs:
/// - Valid cache file (recent timestamp)
/// - Expired cache file (old timestamp)
/// - Corrupted cache file (invalid JSON)
///
/// Output:
/// - Valid cache returns data, expired/corrupted return None.
///
/// Details:
/// - Verifies `load_from_disk_cache` handles TTL and corruption gracefully.
fn test_load_from_disk_cache_handles_ttl_and_corruption() {
use std::fs;
use tempfile::TempDir;
let temp_dir = TempDir::new().expect("Failed to create temp dir");
let cache_path = temp_dir.path().join("arch_news_cache.json");
// Test 1: Valid cache (recent timestamp)
let valid_entry = DiskCacheEntry {
data: vec![NewsFeedItem {
id: "test-1".into(),
date: "2025-01-01".into(),
title: "Test News".into(),
summary: None,
url: Some("https://example.com".into()),
source: NewsFeedSource::ArchNews,
severity: None,
packages: Vec::new(),
}],
saved_at: chrono::Utc::now().timestamp(),
};
fs::write(
&cache_path,
serde_json::to_string(&valid_entry).expect("Failed to serialize"),
)
.expect("Failed to write cache file");
// Temporarily override disk_cache_path to use temp dir
// Since disk_cache_path uses theme::lists_dir(), we need to test the logic differently
// For now, test the serialization/deserialization logic
let content = fs::read_to_string(&cache_path).expect("Failed to read cache file");
let entry: DiskCacheEntry = serde_json::from_str(&content).expect("Failed to parse cache");
let now = chrono::Utc::now().timestamp();
let age = now - entry.saved_at;
let ttl = disk_cache_ttl_seconds();
assert!(age < ttl, "Valid cache should not be expired");
// Test 2: Expired cache
let expired_entry = DiskCacheEntry {
data: vec![],
saved_at: chrono::Utc::now().timestamp() - (ttl + 86400), // 1 day past TTL
};
fs::write(
&cache_path,
serde_json::to_string(&expired_entry).expect("Failed to serialize"),
)
.expect("Failed to write cache file");
let content = fs::read_to_string(&cache_path).expect("Failed to read cache file");
let entry: DiskCacheEntry = serde_json::from_str(&content).expect("Failed to parse cache");
let age = now - entry.saved_at;
assert!(age >= ttl, "Expired cache should be detected");
// Test 3: Corrupted cache
fs::write(&cache_path, "invalid json{").expect("Failed to write corrupted cache");
assert!(
serde_json::from_str::<DiskCacheEntry>(
&fs::read_to_string(&cache_path).expect("Failed to read corrupted cache")
)
.is_err()
);
}
#[test]
/// What: Test in-memory cache TTL behavior.
///
/// Inputs:
/// - Cache entry with recent timestamp (within TTL)
/// - Cache entry with old timestamp (past TTL)
///
/// Output:
/// - Recent entry returns data, old entry is considered expired.
///
/// Details:
/// - Verifies in-memory cache respects 5-minute TTL.
fn test_in_memory_cache_ttl() {
use std::collections::HashMap;
use std::time::{Duration, Instant};
let mut cache: HashMap<String, CacheEntry> = HashMap::new();
let now = Instant::now();
// Add entry with current timestamp
cache.insert(
"arch_news".to_string(),
CacheEntry {
data: vec![NewsFeedItem {
id: "test-1".into(),
date: "2025-01-01".into(),
title: "Test".into(),
summary: None,
url: Some("https://example.com".into()),
source: NewsFeedSource::ArchNews,
severity: None,
packages: Vec::new(),
}],
timestamp: now,
},
);
// Check recent entry (should be valid)
if let Some(entry) = cache.get("arch_news") {
let elapsed = entry.timestamp.elapsed().as_secs();
assert!(
elapsed < CACHE_TTL_SECONDS,
"Recent entry should be within TTL"
);
}
// Simulate expired entry (by using old timestamp)
let old_timestamp = now
.checked_sub(Duration::from_secs(CACHE_TTL_SECONDS + 1))
.expect("Timestamp subtraction should not overflow");
cache.insert(
"arch_news".to_string(),
CacheEntry {
data: vec![],
timestamp: old_timestamp,
},
);
if let Some(entry) = cache.get("arch_news") {
let elapsed = entry.timestamp.elapsed().as_secs();
assert!(elapsed >= CACHE_TTL_SECONDS, "Old entry should be expired");
}
}
#[test]
/// What: Test disk cache save and load roundtrip.
///
/// Inputs:
/// - News feed items to cache.
///
/// Output:
/// - Saved cache can be loaded and matches original data.
///
/// Details:
/// - Verifies disk cache serialization/deserialization works correctly.
fn test_disk_cache_save_and_load() {
use std::fs;
use tempfile::TempDir;
let temp_dir = TempDir::new().expect("Failed to create temp dir");
let cache_path = temp_dir.path().join("arch_news_cache.json");
let items = vec![NewsFeedItem {
id: "test-1".into(),
date: "2025-01-01".into(),
title: "Test News".into(),
summary: None,
url: Some("https://example.com".into()),
source: NewsFeedSource::ArchNews,
severity: None,
packages: Vec::new(),
}];
// Save to disk
let entry = DiskCacheEntry {
data: items.clone(),
saved_at: chrono::Utc::now().timestamp(),
};
fs::write(
&cache_path,
serde_json::to_string(&entry).expect("Failed to serialize"),
)
.expect("Failed to write cache file");
// Load from disk
let content = fs::read_to_string(&cache_path).expect("Failed to read cache file");
let loaded_entry: DiskCacheEntry =
serde_json::from_str(&content).expect("Failed to parse cache");
assert_eq!(loaded_entry.data.len(), items.len());
assert_eq!(loaded_entry.data[0].id, items[0].id);
}
#[test]
/// What: Test `cutoff_date` disables caching.
///
/// Inputs:
/// - `append_arch_news` called with `cutoff_date`.
///
/// Output:
/// - Cache is not checked or updated when `cutoff_date` is provided.
///
/// Details:
/// - Verifies `cutoff_date` bypasses cache logic.
fn test_cutoff_date_disables_caching() {
// This test verifies the logic that cutoff_date skips cache checks
// Since append_arch_news is async and requires network, we test the logic indirectly
// by verifying that cutoff_date.is_none() is checked before cache access
let cutoff_date = Some("2025-01-01");
assert!(cutoff_date.is_some(), "cutoff_date should disable caching");
// When cutoff_date is Some, cache should be bypassed
// This is tested indirectly through the code structure
}
#[test]
/// What: Test `NewsFeedContext` toggles control source inclusion.
///
/// Inputs:
/// - Context with various include_* flags set.
///
/// Output:
/// - Only enabled sources are fetched.
///
/// Details:
/// - Verifies toggle logic respects include flags.
fn test_news_feed_context_toggles() {
use std::collections::HashSet;
let mut seen_versions = HashMap::new();
let mut seen_comments = HashMap::new();
let installed = HashSet::new();
let ctx = NewsFeedContext {
force_emit_all: false,
updates_list_path: None,
limit: 10,
include_arch_news: true,
include_advisories: false,
include_pkg_updates: false,
include_aur_comments: false,
installed_filter: Some(&installed),
installed_only: false,
sort_mode: NewsSortMode::DateDesc,
seen_pkg_versions: &mut seen_versions,
seen_aur_comments: &mut seen_comments,
max_age_days: None,
};
assert!(ctx.include_arch_news);
assert!(!ctx.include_advisories);
assert!(!ctx.include_pkg_updates);
assert!(!ctx.include_aur_comments);
}
#[test]
/// What: Test `max_age_days` cutoff date calculation.
///
/// Inputs:
/// - `max_age_days` value.
///
/// Output:
/// - Cutoff date calculated correctly.
///
/// Details:
/// - Verifies date filtering logic.
fn test_max_age_cutoff_date_calculation() {
let max_age_days = Some(7u32);
let cutoff_date = max_age_days.and_then(|days| {
chrono::Utc::now()
.checked_sub_signed(chrono::Duration::days(i64::from(days)))
.map(|dt| dt.format("%Y-%m-%d").to_string())
});
let cutoff = cutoff_date.expect("cutoff_date should be Some");
// Should be in YYYY-MM-DD format
assert_eq!(cutoff.len(), 10);
assert!(cutoff.contains('-'));
}
#[test]
/// What: Test seen maps are updated by `update_seen_for_comments`.
///
/// Inputs:
/// - Comments with IDs, seen map.
///
/// Output:
/// - Seen map updated with latest comment ID.
///
/// Details:
/// - Verifies seen map mutation for deduplication.
fn test_seen_map_updates_for_comments() {
let mut seen = HashMap::new();
let comments = vec![
AurComment {
id: Some("c2".into()),
author: "a".into(),
date: "2025-01-02 00:00 (UTC)".into(),
date_timestamp: Some(0),
date_url: Some("https://aur.archlinux.org/packages/foo#comment-2".into()),
content: "second".into(),
pinned: false,
},
AurComment {
id: Some("c1".into()),
author: "a".into(),
date: "2025-01-01 00:00 (UTC)".into(),
date_timestamp: Some(0),
date_url: Some("https://aur.archlinux.org/packages/foo#comment-1".into()),
content: "first".into(),
pinned: false,
},
];
let _emitted = update_seen_for_comments("foo", &comments, &mut seen, 5, false);
// Should update seen map with latest comment ID
assert_eq!(seen.get("foo"), Some(&"c2".to_string()));
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/sources/feeds/helpers.rs | src/sources/feeds/helpers.rs | //! Helper functions for building feed items, date parsing, and utilities.
use std::collections::HashMap;
use std::fs;
use std::hash::BuildHasher;
use std::path::PathBuf;
use chrono::{DateTime, Utc};
use serde_json::Value;
use crate::state::types::{AurComment, NewsFeedItem, NewsFeedSource};
use crate::util::parse_update_entry;
use super::rate_limit::{
check_circuit_breaker, extract_retry_after_from_error, increase_archlinux_backoff,
rate_limit_archlinux, record_circuit_breaker_outcome, reset_archlinux_backoff,
};
use super::updates::{AurVersionInfo, FetchDateResult};
/// What: Build a feed item for an official package update.
///
/// Inputs:
/// - `pkg`: Official package metadata (includes repo/arch for links).
/// - `last_seen`: Previously seen version (if any) for summary formatting.
/// - `old_version`: Old version from updates list (if available).
/// - `remote_version`: Current version detected in the official index.
/// - `pkg_date`: Optional package date string.
///
/// Output:
/// - `NewsFeedItem` representing the update.
///
/// Details:
/// - Prefers package metadata date (last update/build); falls back to today when unavailable.
/// - Includes repo/arch link when available.
pub(super) fn build_official_update_item(
pkg: &crate::state::PackageItem,
last_seen: Option<&String>,
old_version: Option<&str>,
remote_version: &str,
pkg_date: Option<String>,
) -> NewsFeedItem {
let date = pkg_date.unwrap_or_else(|| Utc::now().date_naive().to_string());
let url = if let crate::state::Source::Official { repo, arch } = &pkg.source {
let repo_lc = repo.to_lowercase();
let arch_slug = if arch.is_empty() {
std::env::consts::ARCH
} else {
arch.as_str()
};
Some(format!(
"https://archlinux.org/packages/{repo}/{arch}/{name}/",
repo = repo_lc,
arch = arch_slug,
name = pkg.name
))
} else {
None
};
// Only show summary if there's an actual version change (old != new)
let summary = old_version
.and_then(|prev| {
if prev == remote_version {
None
} else {
Some(format!("{prev} β {remote_version}"))
}
})
.or_else(|| {
last_seen.and_then(|prev| {
if prev == remote_version {
None
} else {
Some(format!("{prev} β {remote_version}"))
}
})
});
// Simplified title: just the package name
NewsFeedItem {
id: format!("pkg-update:official:{}:{remote_version}", pkg.name),
date,
title: pkg.name.clone(),
summary,
url,
source: NewsFeedSource::InstalledPackageUpdate,
severity: None,
packages: vec![pkg.name.clone()],
}
}
/// What: Build a feed item for an AUR package update.
///
/// Inputs:
/// - `pkg`: AUR version info (name, version, optional last-modified timestamp).
/// - `last_seen`: Previously seen version, if any.
/// - `old_version`: Old version from updates list (if available).
/// - `remote_version`: Current version.
///
/// Output:
/// - `NewsFeedItem` representing the update.
///
/// Details:
/// - Uses last-modified timestamp for the date when available, otherwise today.
pub(super) fn build_aur_update_item(
pkg: &AurVersionInfo,
last_seen: Option<&String>,
old_version: Option<&str>,
remote_version: &str,
) -> NewsFeedItem {
let date = pkg
.last_modified
.and_then(ts_to_date_string)
.unwrap_or_else(|| Utc::now().date_naive().to_string());
let summary = old_version
.map(|prev| format!("{prev} β {remote_version}"))
.or_else(|| last_seen.map(|prev| format!("{prev} β {remote_version}")))
.or_else(|| Some(remote_version.to_string()));
NewsFeedItem {
id: format!("pkg-update:aur:{}:{remote_version}", pkg.name),
date,
title: format!("{} updated to {remote_version}", pkg.name),
summary,
url: Some(format!("https://aur.archlinux.org/packages/{}", pkg.name)),
source: NewsFeedSource::AurPackageUpdate,
severity: None,
packages: vec![pkg.name.clone()],
}
}
/// What: Convert a Unix timestamp to a `YYYY-MM-DD` string.
///
/// Inputs:
/// - `ts`: Unix timestamp in seconds.
///
/// Output:
/// - `Some(date)` when conversion succeeds; `None` on invalid timestamp.
///
/// Details:
/// - Uses UTC date component only.
pub(super) fn ts_to_date_string(ts: i64) -> Option<String> {
DateTime::<Utc>::from_timestamp(ts, 0).map(|dt| dt.date_naive().to_string())
}
/// What: Build list of architecture candidates to try for package JSON.
///
/// Inputs:
/// - `arch`: The architecture from the package source (may be empty).
///
/// Output:
/// - Vector of architectures to try, in order of preference.
///
/// Details:
/// - If arch is empty or `x86_64`, tries both `x86_64` and "any" (for arch-independent packages).
/// - If arch is "any", only tries "any".
/// - Otherwise tries the specific arch, then "any" as fallback.
fn build_arch_candidates(arch: &str) -> Vec<String> {
if arch.is_empty() || arch.eq_ignore_ascii_case("x86_64") {
vec!["x86_64".to_string(), "any".to_string()]
} else if arch.eq_ignore_ascii_case("any") {
vec!["any".to_string()]
} else {
vec![arch.to_string(), "any".to_string()]
}
}
/// What: Build list of repository candidates to try for package JSON.
///
/// Inputs:
/// - `repo`: The repository from the package source (may be empty).
///
/// Output:
/// - Vector of repositories to try, in order of preference.
///
/// Details:
/// - If repo is empty, tries core and extra.
/// - Otherwise tries the specified repo first, then others as fallback.
fn build_repo_candidates(repo: &str) -> Vec<String> {
if repo.is_empty() {
vec!["core".to_string(), "extra".to_string()]
} else {
let repo_lower = repo.to_lowercase();
if repo_lower == "core" {
vec!["core".to_string(), "extra".to_string()]
} else if repo_lower == "extra" {
vec!["extra".to_string(), "core".to_string()]
} else {
// For other repos (multilib, etc.), try specified first, then core/extra
vec![repo_lower, "extra".to_string(), "core".to_string()]
}
}
}
/// What: Try fetching package JSON from multiple repo/arch combinations.
///
/// Inputs:
/// - `name`: Package name.
/// - `repo_candidates`: List of repositories to try.
/// - `arch_candidates`: List of architectures to try.
///
/// Output:
/// - Result containing either the JSON value or an error string.
///
/// Details:
/// - Tries each combination until one succeeds.
/// - On 404, tries the next combination.
/// - On other errors (rate limiting, etc.), returns the error immediately.
async fn try_fetch_package_json(
name: &str,
repo_candidates: &[String],
arch_candidates: &[String],
) -> Result<serde_json::Value, String> {
let mut last_error = String::new();
for repo in repo_candidates {
for arch in arch_candidates {
let url = format!("https://archlinux.org/packages/{repo}/{arch}/{name}/json/",);
let fetch_result = tokio::time::timeout(
tokio::time::Duration::from_millis(2000),
tokio::task::spawn_blocking({
let url = url.clone();
move || crate::util::curl::curl_json(&url)
}),
)
.await;
match fetch_result {
Ok(Ok(Ok(json))) => {
tracing::debug!(
package = %name,
repo = %repo,
arch = %arch,
"successfully fetched package JSON"
);
return Ok(json);
}
Ok(Ok(Err(e))) => {
let error_str = e.to_string();
// 404 means wrong repo/arch combo - try next one
if error_str.contains("404") {
tracing::debug!(
package = %name,
repo = %repo,
arch = %arch,
"package not found at this URL, trying next candidate"
);
last_error = error_str;
continue;
}
// Other errors (rate limiting, server errors) - return immediately
return Err(error_str);
}
Ok(Err(e)) => {
// spawn_blocking failed
return Err(format!("task join error: {e}"));
}
Err(_) => {
// Timeout
return Err("timeout".to_string());
}
}
}
}
// All candidates returned 404
Err(last_error)
}
/// What: Fetch and normalize the last update/build date for an official package.
///
/// Inputs:
/// - `pkg`: Package item expected to originate from an official repository.
///
/// Output:
/// - `FetchDateResult` indicating success, cached fallback, or needs retry.
///
/// Details:
/// - Queries the Arch package JSON endpoint, preferring `last_update` then `build_date`.
/// - Tries multiple repo/arch combinations if the first one returns 404.
/// - Falls back to cached JSON when network errors occur.
/// - Returns `NeedsRetry` when fetch fails and no cache is available.
/// - Uses rate limiting to prevent IP blocking by archlinux.org.
/// - Applies circuit breaker pattern to avoid overwhelming the server during outages.
pub(super) async fn fetch_official_package_date(
pkg: &crate::state::PackageItem,
) -> FetchDateResult {
let crate::state::Source::Official { repo, arch } = &pkg.source else {
return FetchDateResult::Success(None);
};
let endpoint_pattern = "/packages/*/json/";
// Build list of repo/arch candidates to try
// Some packages use "any" arch instead of x86_64, and may be in different repos
let repo_slug = repo.to_lowercase();
let arch_candidates = build_arch_candidates(arch);
let repo_candidates = build_repo_candidates(&repo_slug);
// Use first candidate for cache path (most likely to be correct)
let first_arch = arch_candidates.first().map_or("x86_64", String::as_str);
let first_repo = repo_candidates
.first()
.map_or("extra", |s| s.as_str())
.to_lowercase();
let cache_path = crate::sources::feeds::updates::official_json_cache_path(
&first_repo,
first_arch,
&pkg.name,
);
// Check circuit breaker before making request
if let Err(e) = check_circuit_breaker(endpoint_pattern) {
tracing::debug!(
package = %pkg.name,
error = %e,
"circuit breaker blocking package date fetch, trying cached JSON"
);
// Fall back to cached JSON if available, otherwise needs retry
return extract_date_from_cached_json(&cache_path)
.map_or(FetchDateResult::NeedsRetry, |date| {
FetchDateResult::CachedFallback(Some(date))
});
}
// Apply rate limiting before request to prevent IP blocking
let _permit = rate_limit_archlinux().await;
// Try each repo/arch combination until one succeeds
let result = try_fetch_package_json(&pkg.name, &repo_candidates, &arch_candidates).await;
match result {
Ok(json) => {
// Success: reset backoff and record success
reset_archlinux_backoff();
record_circuit_breaker_outcome(endpoint_pattern, true);
// Save and compare JSON for change detection
let old_json = crate::sources::feeds::updates::load_official_json_cache(&cache_path);
// Compare with previous JSON if it exists
if let Some(old_json) = old_json
&& let Some(change_desc) =
crate::sources::feeds::updates::compare_official_json_changes(
&old_json, &json, &pkg.name,
)
{
// Store changes in cache
if let Ok(mut cache) =
crate::sources::feeds::updates::OFFICIAL_JSON_CHANGES_CACHE.lock()
{
cache.insert(pkg.name.clone(), change_desc);
}
}
// Save the JSON to disk (after comparison)
if let Err(e) =
crate::sources::feeds::updates::save_official_json_cache(&cache_path, &json)
{
tracing::debug!(
error = %e,
path = ?cache_path,
"failed to save official package JSON cache"
);
}
// last_update is at the top level, not inside pkg
// Check top-level first, then fall back to pkg object
let date = extract_date_from_pkg_json(&json)
.or_else(|| json.get("pkg").and_then(extract_date_from_pkg_json));
FetchDateResult::Success(date)
}
Err(error_str) => {
// Check for HTTP 404 - all repo/arch combinations returned not found
// This means the package truly doesn't exist in the JSON API
if error_str.contains("404") {
tracing::debug!(
package = %pkg.name,
"package not found in any repository JSON API (may be a virtual package)"
);
// 404s are NOT failures for circuit breaker - they're expected for some packages
// Record as success to not trip circuit breaker
record_circuit_breaker_outcome(endpoint_pattern, true);
// Return Success(None) to indicate "no date available" permanently
return FetchDateResult::Success(None);
}
// Check for rate limiting errors (429, 502, 503, 504) or timeout
if error_str.contains("429")
|| error_str.contains("502")
|| error_str.contains("503")
|| error_str.contains("504")
{
let retry_after = extract_retry_after_from_error(&error_str);
increase_archlinux_backoff(retry_after);
tracing::warn!(
package = %pkg.name,
error = %error_str,
"rate limited fetching official package date"
);
} else if error_str.contains("timeout") {
// Timeout - mild backoff increase
increase_archlinux_backoff(None);
tracing::debug!(
package = %pkg.name,
"timeout fetching official package date, trying cached JSON"
);
} else {
increase_archlinux_backoff(None);
tracing::warn!(
package = %pkg.name,
error = %error_str,
"failed to fetch official package date"
);
}
record_circuit_breaker_outcome(endpoint_pattern, false);
// Fall back to cached JSON if available, otherwise needs retry
cached_fallback_or_retry(&cache_path)
}
}
}
/// What: Return cached fallback or needs retry result.
///
/// Inputs:
/// - `cache_path`: Path to the cached JSON file.
///
/// Output:
/// - `FetchDateResult::CachedFallback` if cache exists; `NeedsRetry` otherwise.
///
/// Details:
/// - Helper to reduce code duplication in error handling paths.
fn cached_fallback_or_retry(cache_path: &std::path::Path) -> FetchDateResult {
extract_date_from_cached_json(cache_path).map_or(FetchDateResult::NeedsRetry, |date| {
FetchDateResult::CachedFallback(Some(date))
})
}
/// What: Extract date from cached official package JSON.
///
/// Inputs:
/// - `cache_path`: Path to the cached JSON file.
///
/// Output:
/// - `Some(YYYY-MM-DD)` if cached JSON exists and date can be extracted; `None` otherwise.
///
/// Details:
/// - Used as fallback when network requests fail.
fn extract_date_from_cached_json(cache_path: &std::path::Path) -> Option<String> {
let cached_json = crate::sources::feeds::updates::load_official_json_cache(cache_path)?;
extract_date_from_pkg_json(&cached_json)
.or_else(|| cached_json.get("pkg").and_then(extract_date_from_pkg_json))
}
/// What: Extract a normalized date from Arch package JSON metadata.
///
/// Inputs:
/// - `obj`: JSON value from the package endpoint (`pkg` object or root).
///
/// Output:
/// - `Some(YYYY-MM-DD)` when `last_update` or `build_date` can be parsed; `None` otherwise.
///
/// Details:
/// - Prefers `last_update`; falls back to `build_date`.
pub(super) fn extract_date_from_pkg_json(obj: &Value) -> Option<String> {
obj.get("last_update")
.and_then(Value::as_str)
.and_then(normalize_pkg_date)
.or_else(|| {
obj.get("build_date")
.and_then(Value::as_str)
.and_then(normalize_pkg_date)
})
}
/// What: Normalize a package timestamp string to `YYYY-MM-DD`.
///
/// Inputs:
/// - `raw`: Date/time string (RFC3339 with optional fractional seconds, or `YYYY-MM-DD HH:MM UTC` formats).
///
/// Output:
/// - `Some(YYYY-MM-DD)` when parsing succeeds; `None` on invalid inputs.
///
/// Details:
/// - Handles Arch JSON date formats including milliseconds (`2025-12-15T19:30:14.422Z`).
/// - Falls back to simple date prefix extraction for other formats.
pub(super) fn normalize_pkg_date(raw: &str) -> Option<String> {
let trimmed = raw.trim();
// Try RFC3339 parsing (handles formats with and without fractional seconds)
if let Ok(dt) = DateTime::parse_from_rfc3339(trimmed) {
return Some(dt.date_naive().to_string());
}
// Try parsing with explicit format for fractional seconds
if let Ok(dt) = DateTime::parse_from_str(trimmed, "%Y-%m-%dT%H:%M:%S%.fZ") {
return Some(dt.date_naive().to_string());
}
// Try standard UTC format
if let Ok(dt) = DateTime::parse_from_str(trimmed, "%Y-%m-%d %H:%M %Z") {
return Some(dt.date_naive().to_string());
}
// Fallback: extract date prefix if it looks like YYYY-MM-DD
let prefix = trimmed.chars().take(10).collect::<String>();
if prefix.len() == 10
&& prefix.as_bytes()[4] == b'-'
&& prefix.as_bytes()[7] == b'-'
&& prefix[..4].chars().all(|c| c.is_ascii_digit())
&& prefix[5..7].chars().all(|c| c.is_ascii_digit())
&& prefix[8..10].chars().all(|c| c.is_ascii_digit())
{
return Some(prefix);
}
None
}
/// What: Normalize an AUR comment date string to `YYYY-MM-DD`.
///
/// Inputs:
/// - `date`: Comment date string as displayed (e.g., "2025-01-01 10:00 (UTC)").
///
/// Output:
/// - Normalized date component; falls back to today's date if parsing fails.
///
/// Details:
/// - Splits on whitespace and takes the first token.
pub(super) fn normalize_comment_date(date: &str) -> String {
date.split_whitespace().next().map_or_else(
|| Utc::now().date_naive().to_string(),
std::string::ToString::to_string,
)
}
/// What: Summarize comment content for feed display.
///
/// Inputs:
/// - `content`: Full comment text.
///
/// Output:
/// - Trimmed string capped to 180 characters with ellipsis when truncated.
///
/// Details:
/// - Counts characters (not bytes) to avoid breaking UTF-8 boundaries.
pub(super) fn summarize_comment(content: &str) -> String {
const MAX: usize = 180;
if content.chars().count() <= MAX {
return content.to_string();
}
let mut out = content.chars().take(MAX).collect::<String>();
out.push('β¦');
out
}
/// What: Load package names and target versions from `available_updates.txt` if present.
///
/// Inputs:
/// - `path`: Optional path to the updates list file.
///
/// Output:
/// - `Some(HashMap<String, (String, String)>)` mapping package name -> (old, new); `None` on error or empty.
pub(super) fn load_update_versions(
path: Option<&PathBuf>,
) -> Option<HashMap<String, (String, String)>> {
let path = path?;
let data = fs::read_to_string(path).ok()?;
let mut map: HashMap<String, (String, String)> = HashMap::new();
for line in data.lines() {
if let Some((name, old_v, new_v)) = parse_update_entry(line) {
map.insert(name, (old_v, new_v));
}
}
if map.is_empty() { None } else { Some(map) }
}
/// What: Update last-seen comment map and return new feed items until the last seen marker.
///
/// Inputs:
/// - `pkgname`: Package name associated with the comments.
/// - `comments`: Comments sorted newest-first.
/// - `seen_aur_comments`: Mutable last-seen comment map.
/// - `remaining_allowance`: Maximum number of items to emit.
/// - `force_emit_all`: Whether to emit all comments regardless of seen state.
///
/// Output:
/// - `Vec<NewsFeedItem>` containing new comment items.
///
/// Details:
/// - Emits from newest to oldest until the previous marker (if any) or allowance is exhausted.
pub(super) fn update_seen_for_comments<H>(
pkgname: &str,
comments: &[AurComment],
seen_aur_comments: &mut HashMap<String, String, H>,
remaining_allowance: usize,
force_emit_all: bool,
) -> Vec<NewsFeedItem>
where
H: BuildHasher + Send + Sync + 'static,
{
let mut emitted = Vec::new();
let latest_id = comments
.first()
.and_then(|c| c.id.clone().or_else(|| c.date_url.clone()));
let prev_seen = seen_aur_comments.get(pkgname).cloned();
if let Some(ref latest) = latest_id {
seen_aur_comments.insert(pkgname.to_string(), latest.clone());
}
for comment in comments {
if emitted.len() >= remaining_allowance {
break;
}
let cid = comment
.id
.as_ref()
.or(comment.date_url.as_ref())
.unwrap_or(&comment.date);
if !force_emit_all && prev_seen.as_deref() == Some(cid) {
break;
}
emitted.push(NewsFeedItem {
id: format!("aur-comment:{pkgname}:{cid}"),
date: normalize_comment_date(&comment.date),
title: format!("New AUR comment on {pkgname}"),
summary: Some(summarize_comment(&comment.content)),
url: comment.date_url.clone(),
source: NewsFeedSource::AurComment,
severity: None,
packages: vec![pkgname.to_string()],
});
}
emitted
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/sources/feeds/mod.rs | src/sources/feeds/mod.rs | //! Aggregated news feed fetcher (Arch news + security advisories).
mod cache;
mod helpers;
mod news_fetch;
mod rate_limit;
mod updates;
use std::collections::{HashMap, HashSet};
use std::hash::BuildHasher;
use std::path::PathBuf;
use crate::state::types::{NewsFeedItem, NewsSortMode, severity_rank};
use tracing::{info, warn};
use helpers::load_update_versions;
use news_fetch::fetch_slow_sources;
use updates::{fetch_installed_aur_comments, fetch_installed_updates};
/// Result type alias for news feed fetching operations.
type Result<T> = super::Result<T>;
/// What: Calculate optimal `max_age_days` based on last startup timestamp.
///
/// Inputs:
/// - `last_startup`: Optional timestamp in `YYYYMMDD:HHMMSS` format.
/// - `default_max_age`: Default max age in days if no optimization applies.
///
/// Output:
/// - Optimized `max_age_days` value, or `None` to fetch all.
///
/// Details:
/// - If last startup was within 1 hour: use 1 day (recent data likely cached)
/// - If last startup was within 24 hours: use 2 days
/// - If last startup was within 7 days: use configured `max_age` or 7 days
/// - Otherwise: use configured `max_age`
/// - This reduces unnecessary fetching when the app was recently used.
/// - NOTE: This only affects Arch news and advisories date filtering.
/// Package updates are ALWAYS fetched fresh to detect new packages and version changes.
#[must_use]
pub fn optimize_max_age_for_startup(
last_startup: Option<&str>,
default_max_age: Option<u32>,
) -> Option<u32> {
let Some(ts) = last_startup else {
// No previous startup recorded, use default
return default_max_age;
};
// Parse timestamp: YYYYMMDD:HHMMSS
let parsed = chrono::NaiveDateTime::parse_from_str(ts, "%Y%m%d:%H%M%S").ok();
let Some(last_dt) = parsed else {
tracing::debug!(timestamp = %ts, "failed to parse last startup timestamp");
return default_max_age;
};
let now = chrono::Local::now().naive_local();
let elapsed = now.signed_duration_since(last_dt);
if elapsed.num_hours() < 1 {
// Very recent startup (< 1 hour): minimal fresh fetch needed
info!(
hours_since_last = elapsed.num_hours(),
"recent startup detected, using minimal fetch window"
);
Some(1)
} else if elapsed.num_hours() < 24 {
// Within last day: use 2 days to be safe
info!(
hours_since_last = elapsed.num_hours(),
"startup within 24h, using 2-day fetch window"
);
Some(2)
} else if elapsed.num_days() < 7 {
// Within last week: use configured or 7 days
let optimized = default_max_age.map_or(7, |d| d.min(7));
info!(
days_since_last = elapsed.num_days(),
optimized_max_age = optimized,
"startup within 7 days, using optimized fetch window"
);
Some(optimized)
} else {
// More than a week: use configured max_age
default_max_age
}
}
/// What: Input context for fetching a combined news feed.
///
/// Inputs:
/// - `limit`: Maximum number of items per source.
/// - `include_*`: Source toggles.
/// - `installed_filter`: Optional installed-package set for scoping.
/// - `installed_only`: Whether to restrict advisories to installed packages.
/// - `sort_mode`: Sort order.
/// - `seen_pkg_versions`: Last-seen map for package updates.
/// - `seen_aur_comments`: Last-seen map for AUR comments.
/// - `max_age_days`: Optional maximum age in days for filtering items (enables early filtering).
///
/// Output:
/// - Mutable references updated in place alongside returned feed items.
///
/// Details:
/// - Hashers are generic to remain compatible with caller-supplied maps.
/// - `max_age_days` enables early date filtering during fetch to improve performance.
#[allow(clippy::struct_excessive_bools)]
pub struct NewsFeedContext<'a, HS, HV, HC>
where
HS: BuildHasher + Send + Sync + 'static,
HV: BuildHasher + Send + Sync + 'static,
HC: BuildHasher + Send + Sync + 'static,
{
/// Emit all sources even on first run (bypasses baseline gating).
pub force_emit_all: bool,
/// Optional path to `available_updates.txt` for filtering noisy first-run emissions.
pub updates_list_path: Option<PathBuf>,
/// Maximum number of items per source.
pub limit: usize,
/// Whether to include Arch news RSS posts.
pub include_arch_news: bool,
/// Whether to include security advisories.
pub include_advisories: bool,
/// Whether to include installed package updates.
pub include_pkg_updates: bool,
/// Whether to include installed AUR comments.
pub include_aur_comments: bool,
/// Optional installed-package filter set.
pub installed_filter: Option<&'a HashSet<String, HS>>,
/// Whether to restrict advisories to installed packages.
pub installed_only: bool,
/// Sort mode for the resulting feed.
pub sort_mode: NewsSortMode,
/// Last-seen versions map (updated in place).
pub seen_pkg_versions: &'a mut HashMap<String, String, HV>,
/// Last-seen AUR comments map (updated in place).
pub seen_aur_comments: &'a mut HashMap<String, String, HC>,
/// Optional maximum age in days for early date filtering during fetch.
pub max_age_days: Option<u32>,
}
/// Configuration for fetching fast sources.
struct FastSourcesConfig<'a, HS, HV, HC> {
/// Whether to fetch package updates.
include_pkg_updates: bool,
/// Whether to fetch AUR comments.
include_aur_comments: bool,
/// Optional set of installed package names.
installed_filter: Option<&'a HashSet<String, HS>>,
/// Maximum items per source.
limit: usize,
/// Last-seen versions map (updated in place).
seen_pkg_versions: &'a mut HashMap<String, String, HV>,
/// Last-seen AUR comments map (updated in place).
seen_aur_comments: &'a mut HashMap<String, String, HC>,
/// Whether to emit all items regardless of last-seen.
force_emit_all: bool,
/// Optional pre-loaded update versions.
updates_versions: Option<&'a HashMap<String, (String, String)>>,
}
/// What: Fetch fast sources (package updates and AUR comments) in parallel.
///
/// Inputs:
/// - `config`: Configuration struct containing all fetch parameters.
///
/// Output:
/// - Tuple of (`updates_result`, `comments_result`).
///
/// Details:
/// - Fetches both sources in parallel for better performance.
/// - Returns empty vectors on errors (graceful degradation).
async fn fetch_fast_sources<HS, HV, HC>(
config: FastSourcesConfig<'_, HS, HV, HC>,
) -> (
std::result::Result<Vec<NewsFeedItem>, Box<dyn std::error::Error + Send + Sync>>,
std::result::Result<Vec<NewsFeedItem>, Box<dyn std::error::Error + Send + Sync>>,
)
where
HS: BuildHasher + Send + Sync + 'static,
HV: BuildHasher + Send + Sync + 'static,
HC: BuildHasher + Send + Sync + 'static,
{
tokio::join!(
async {
if config.include_pkg_updates {
if let Some(installed) = config.installed_filter {
if installed.is_empty() {
warn!(
"include_pkg_updates set but installed set is empty; skipping updates"
);
Ok::<Vec<NewsFeedItem>, Box<dyn std::error::Error + Send + Sync>>(Vec::new())
} else {
info!(
"fetching package updates: installed_count={}, limit={}",
installed.len(),
config.limit
);
let result = fetch_installed_updates(
installed,
config.limit,
config.seen_pkg_versions,
config.force_emit_all,
config.updates_versions,
)
.await;
match &result {
Ok(updates) => {
info!("package updates fetch completed: items={}", updates.len());
}
Err(e) => {
warn!(error = %e, "installed package updates fetch failed");
}
}
match result {
Ok(updates) => Ok(updates),
Err(_e) => Ok::<
Vec<NewsFeedItem>,
Box<dyn std::error::Error + Send + Sync>,
>(Vec::new()),
}
}
} else {
warn!("include_pkg_updates set but installed_filter missing; skipping updates");
Ok::<Vec<NewsFeedItem>, Box<dyn std::error::Error + Send + Sync>>(Vec::new())
}
} else {
Ok::<Vec<NewsFeedItem>, Box<dyn std::error::Error + Send + Sync>>(Vec::new())
}
},
async {
if config.include_aur_comments {
if let Some(installed) = config.installed_filter {
if installed.is_empty() {
warn!(
"include_aur_comments set but installed set is empty; skipping comments"
);
Ok::<Vec<NewsFeedItem>, Box<dyn std::error::Error + Send + Sync>>(Vec::new())
} else {
info!(
"fetching AUR comments: installed_count={}, limit={}",
installed.len(),
config.limit
);
let result = fetch_installed_aur_comments(
installed,
config.limit,
config.seen_aur_comments,
config.force_emit_all,
)
.await;
match &result {
Ok(comments) => {
info!("AUR comments fetch completed: items={}", comments.len());
}
Err(e) => {
warn!(error = %e, "installed AUR comments fetch failed");
}
}
match result {
Ok(comments) => Ok(comments),
Err(_e) => Ok::<
Vec<NewsFeedItem>,
Box<dyn std::error::Error + Send + Sync>,
>(Vec::new()),
}
}
} else {
warn!(
"include_aur_comments set but installed_filter missing; skipping comments"
);
Ok::<Vec<NewsFeedItem>, Box<dyn std::error::Error + Send + Sync>>(Vec::new())
}
} else {
Ok::<Vec<NewsFeedItem>, Box<dyn std::error::Error + Send + Sync>>(Vec::new())
}
}
)
}
/// What: Combine feed results from all sources into a single sorted vector.
///
/// Inputs:
/// - `arch_result`: Arch news fetch result.
/// - `advisories_result`: Advisories fetch result.
/// - `updates_result`: Package updates fetch result.
/// - `comments_result`: AUR comments fetch result.
/// - `sort_mode`: Sort mode for the final result.
///
/// Output:
/// - Combined and sorted vector of news feed items.
///
/// Details:
/// - Gracefully handles errors by logging warnings and continuing.
/// - Sorts items according to the specified sort mode.
fn combine_feed_results(
arch_result: std::result::Result<Vec<NewsFeedItem>, Box<dyn std::error::Error + Send + Sync>>,
advisories_result: std::result::Result<
Vec<NewsFeedItem>,
Box<dyn std::error::Error + Send + Sync>,
>,
updates_result: std::result::Result<
Vec<NewsFeedItem>,
Box<dyn std::error::Error + Send + Sync>,
>,
comments_result: std::result::Result<
Vec<NewsFeedItem>,
Box<dyn std::error::Error + Send + Sync>,
>,
sort_mode: NewsSortMode,
) -> Vec<NewsFeedItem> {
let mut items: Vec<NewsFeedItem> = Vec::new();
match arch_result {
Ok(mut arch_items) => items.append(&mut arch_items),
Err(e) => warn!(error = %e, "arch news fetch failed; continuing without Arch news"),
}
match advisories_result {
Ok(mut adv_items) => items.append(&mut adv_items),
Err(e) => warn!(error = %e, "advisories fetch failed; continuing without advisories"),
}
match updates_result {
Ok(mut upd_items) => items.append(&mut upd_items),
Err(e) => warn!(error = %e, "updates fetch failed; continuing without updates"),
}
match comments_result {
Ok(mut cmt_items) => items.append(&mut cmt_items),
Err(e) => warn!(error = %e, "comments fetch failed; continuing without comments"),
}
sort_news_items(&mut items, sort_mode);
items
}
/// Return type for `prepare_fetch_context` function.
type PrepareFetchContextReturn<'a, HS, HV, HC> = (
Option<String>,
Option<HashMap<String, (String, String)>>,
usize,
bool,
bool,
bool,
bool,
Option<&'a HashSet<String, HS>>,
bool,
NewsSortMode,
&'a mut HashMap<String, String, HV>,
&'a mut HashMap<String, String, HC>,
bool,
);
/// What: Prepare fetch context and calculate derived values.
///
/// Inputs:
/// - `ctx`: News feed context.
///
/// Output:
/// - Tuple of (`cutoff_date`, `updates_versions`, and extracted context fields).
///
/// Details:
/// - Extracts context fields and calculates cutoff date and update versions.
fn prepare_fetch_context<HS, HV, HC>(
ctx: NewsFeedContext<'_, HS, HV, HC>,
) -> PrepareFetchContextReturn<'_, HS, HV, HC>
where
HS: BuildHasher + Send + Sync + 'static,
HV: BuildHasher + Send + Sync + 'static,
HC: BuildHasher + Send + Sync + 'static,
{
let NewsFeedContext {
limit,
include_arch_news,
include_advisories,
include_pkg_updates,
include_aur_comments,
installed_filter,
installed_only,
sort_mode,
seen_pkg_versions,
seen_aur_comments,
force_emit_all,
updates_list_path,
max_age_days,
} = ctx;
info!(
limit,
include_arch_news,
include_advisories,
include_pkg_updates,
include_aur_comments,
installed_only,
installed_filter = installed_filter.is_some(),
sort_mode = ?sort_mode,
max_age_days,
"fetch_news_feed start"
);
let cutoff_date = max_age_days.and_then(|days| {
chrono::Utc::now()
.checked_sub_signed(chrono::Duration::days(i64::from(days)))
.map(|dt| dt.format("%Y-%m-%d").to_string())
});
let updates_versions = if force_emit_all {
load_update_versions(updates_list_path.as_ref())
} else {
None
};
(
cutoff_date,
updates_versions,
limit,
include_arch_news,
include_advisories,
include_pkg_updates,
include_aur_comments,
installed_filter,
installed_only,
sort_mode,
seen_pkg_versions,
seen_aur_comments,
force_emit_all,
)
}
/// What: Sort news feed items by the specified mode.
///
/// Inputs:
/// - `items`: Mutable slice of news feed items to sort.
/// - `mode`: Sort mode (date descending, etc.).
///
/// Output: Items are sorted in place.
///
/// Details: Sorts news items according to the specified sort mode.
fn sort_news_items(items: &mut [NewsFeedItem], mode: NewsSortMode) {
match mode {
NewsSortMode::DateDesc => items.sort_by(|a, b| b.date.cmp(&a.date)),
NewsSortMode::DateAsc => items.sort_by(|a, b| a.date.cmp(&b.date)),
NewsSortMode::Title => {
items.sort_by(|a, b| {
a.title
.to_lowercase()
.cmp(&b.title.to_lowercase())
.then(b.date.cmp(&a.date))
});
}
NewsSortMode::SourceThenTitle => items.sort_by(|a, b| {
a.source
.cmp(&b.source)
.then(b.date.cmp(&a.date))
.then(a.title.to_lowercase().cmp(&b.title.to_lowercase()))
}),
NewsSortMode::SeverityThenDate => items.sort_by(|a, b| {
let sa = severity_rank(a.severity);
let sb = severity_rank(b.severity);
sb.cmp(&sa)
.then(b.date.cmp(&a.date))
.then(a.title.to_lowercase().cmp(&b.title.to_lowercase()))
}),
NewsSortMode::UnreadThenDate => {
// Fetch pipeline lacks read-state context; fall back to newest-first.
items.sort_by(|a, b| b.date.cmp(&a.date));
}
}
}
/// # Errors
/// - Network failures fetching sources
/// - JSON parse errors from upstream feeds
pub async fn fetch_news_feed<HS, HV, HC>(
ctx: NewsFeedContext<'_, HS, HV, HC>,
) -> Result<Vec<NewsFeedItem>>
where
HS: BuildHasher + Send + Sync + 'static,
HV: BuildHasher + Send + Sync + 'static,
HC: BuildHasher + Send + Sync + 'static,
{
let (
cutoff_date,
updates_versions,
limit,
include_arch_news,
include_advisories,
include_pkg_updates,
include_aur_comments,
installed_filter,
installed_only,
sort_mode,
seen_pkg_versions,
seen_aur_comments,
force_emit_all,
) = prepare_fetch_context(ctx);
info!(
"starting fetch: arch_news={include_arch_news}, advisories={include_advisories}, pkg_updates={include_pkg_updates}, aur_comments={include_aur_comments}"
);
rate_limit::reset_archlinux_backoff();
// Fetch ALL sources in parallel for best responsiveness:
// - Fast sources (AUR comments, package updates) run in parallel and complete quickly
// - Slow sources (arch news, advisories from archlinux.org) run sequentially with each other
// but IN PARALLEL with the fast sources, so they don't block everything
let ((updates_result, comments_result), (arch_result, advisories_result)) = tokio::join!(
fetch_fast_sources(FastSourcesConfig {
include_pkg_updates,
include_aur_comments,
installed_filter,
limit,
seen_pkg_versions,
seen_aur_comments,
force_emit_all,
updates_versions: updates_versions.as_ref(),
}),
fetch_slow_sources(
include_arch_news,
include_advisories,
limit,
installed_filter,
installed_only,
cutoff_date.as_deref(),
)
);
info!("fetch completed, combining results...");
let items = combine_feed_results(
arch_result,
advisories_result,
updates_result,
comments_result,
sort_mode,
);
info!(
total = items.len(),
arch = items
.iter()
.filter(|i| matches!(i.source, crate::state::types::NewsFeedSource::ArchNews))
.count(),
advisories = items
.iter()
.filter(|i| matches!(
i.source,
crate::state::types::NewsFeedSource::SecurityAdvisory
))
.count(),
updates = items
.iter()
.filter(|i| {
matches!(
i.source,
crate::state::types::NewsFeedSource::InstalledPackageUpdate
| crate::state::types::NewsFeedSource::AurPackageUpdate
)
})
.count(),
aur_comments = items
.iter()
.filter(|i| matches!(i.source, crate::state::types::NewsFeedSource::AurComment))
.count(),
"fetch_news_feed success"
);
Ok(items)
}
/// Limit for continuation fetching (effectively unlimited).
const CONTINUATION_LIMIT: usize = 1000;
/// What: Fetch continuation items for background loading after initial batch.
///
/// Inputs:
/// - `installed`: Set of installed package names.
/// - `initial_ids`: IDs of items already fetched in initial batch.
///
/// Output:
/// - `Ok(Vec<NewsFeedItem>)`: Additional items not in initial batch.
///
/// # Errors
/// - Network errors when fetching from any source.
/// - Parsing errors from upstream feeds.
///
/// Details:
/// - Fetches items from all sources with a high limit (1000).
/// - Filters out items already in `initial_ids`.
/// - Used by background continuation worker to stream additional items to UI.
pub async fn fetch_continuation_items<HS, HI>(
installed: &HashSet<String, HS>,
initial_ids: &HashSet<String, HI>,
) -> Result<Vec<NewsFeedItem>>
where
HS: std::hash::BuildHasher + Send + Sync + 'static,
HI: std::hash::BuildHasher + Send + Sync,
{
use crate::state::types::NewsFeedSource;
info!(
installed_count = installed.len(),
initial_count = initial_ids.len(),
"starting continuation fetch"
);
// Fetch from all sources in parallel
let ((updates_result, comments_result), (arch_result, advisories_result)) = tokio::join!(
async {
// Package updates - use fresh seen maps (continuation doesn't track seen state)
let mut seen_versions: HashMap<String, String> = HashMap::new();
let mut seen_aur_comments: HashMap<String, String> = HashMap::new();
let updates = fetch_installed_updates(
installed,
CONTINUATION_LIMIT,
&mut seen_versions,
true, // force_emit_all
None,
)
.await;
let comments = fetch_installed_aur_comments(
installed,
CONTINUATION_LIMIT,
&mut seen_aur_comments,
true, // force_emit_all
)
.await;
(updates, comments)
},
fetch_slow_sources(
true, // include_arch_news
true, // include_advisories
CONTINUATION_LIMIT,
Some(installed),
false, // installed_only
None, // cutoff_date
)
);
let mut items = Vec::new();
// Add Arch news (filter out already-sent items)
if let Ok(arch_items) = arch_result {
for item in arch_items {
if !initial_ids.contains(&item.id) {
items.push(item);
}
}
}
// Add advisories (filter out already-sent items)
if let Ok(adv_items) = advisories_result {
for item in adv_items {
if !initial_ids.contains(&item.id) {
items.push(item);
}
}
}
// Add package updates (filter out already-sent items)
if let Ok(upd_items) = updates_result {
for item in upd_items {
if !initial_ids.contains(&item.id) {
items.push(item);
}
}
}
// Add AUR comments (filter out already-sent items)
if let Ok(comment_items) = comments_result {
for item in comment_items {
if !initial_ids.contains(&item.id) {
items.push(item);
}
}
}
// Sort by date descending
sort_news_items(&mut items, NewsSortMode::DateDesc);
info!(
total = items.len(),
arch = items
.iter()
.filter(|i| matches!(i.source, NewsFeedSource::ArchNews))
.count(),
advisories = items
.iter()
.filter(|i| matches!(i.source, NewsFeedSource::SecurityAdvisory))
.count(),
updates = items
.iter()
.filter(|i| matches!(
i.source,
NewsFeedSource::InstalledPackageUpdate | NewsFeedSource::AurPackageUpdate
))
.count(),
"continuation fetch complete"
);
Ok(items)
}
// Re-export public functions from submodules
pub use rate_limit::{
check_circuit_breaker, extract_endpoint_pattern, extract_retry_after_from_error,
increase_archlinux_backoff, rate_limit_archlinux, record_circuit_breaker_outcome,
reset_archlinux_backoff, take_network_error,
};
pub use updates::{
get_aur_json_changes, get_official_json_changes, load_official_json_cache,
official_json_cache_path,
};
#[cfg(test)]
mod tests;
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/sources/feeds/updates.rs | src/sources/feeds/updates.rs | //! Package updates fetching (official and AUR).
use std::collections::{HashMap, HashSet};
use std::hash::BuildHasher;
use std::path::PathBuf;
use std::sync::{LazyLock, Mutex};
use std::time::Instant;
use futures::stream::{self, StreamExt};
use serde_json::Value;
use tracing::{debug, info, warn};
use crate::state::types::NewsFeedItem;
use super::Result;
use super::cache::{AUR_COMMENTS_CACHE, SKIP_CACHE_TTL_SECONDS, UPDATES_CACHE};
use super::helpers::{
build_aur_update_item, build_official_update_item, fetch_official_package_date,
normalize_pkg_date, update_seen_for_comments,
};
use super::rate_limit::rate_limit;
/// What: Result of fetching an official package date.
///
/// Inputs: None (enum variants).
///
/// Output: Indicates whether the fetch succeeded, failed with cached fallback, or needs retry.
///
/// Details:
/// - `Success(date)`: Fetch succeeded with the date.
/// - `CachedFallback(date)`: Fetch failed but cached date was available.
/// - `NeedsRetry`: Fetch failed, no cache available, should retry later.
#[derive(Debug, Clone)]
pub(super) enum FetchDateResult {
/// Fetch succeeded with the date from network.
Success(Option<String>),
/// Fetch failed but cached date was available.
CachedFallback(Option<String>),
/// Fetch failed with no cache, should retry later.
NeedsRetry,
}
/// Cache for AUR JSON changes per package.
/// Key: package name, Value: formatted change description.
static AUR_JSON_CHANGES_CACHE: LazyLock<Mutex<HashMap<String, String>>> =
LazyLock::new(|| Mutex::new(HashMap::new()));
/// Cache for official package JSON changes per package.
/// Key: package name, Value: formatted change description.
pub(super) static OFFICIAL_JSON_CHANGES_CACHE: LazyLock<Mutex<HashMap<String, String>>> =
LazyLock::new(|| Mutex::new(HashMap::new()));
/// What: Minimal AUR version record for update feed generation.
///
/// Inputs:
/// - `name`: Package name.
/// - `version`: Latest version string.
/// - `last_modified`: Optional last modified timestamp (UTC seconds).
///
/// Output:
/// - Data holder used during update feed construction.
///
/// Details:
/// - Derived from AUR RPC v5 info responses.
#[derive(Debug, Clone)]
pub(super) struct AurVersionInfo {
/// Package name.
pub name: String,
/// Latest version string.
pub version: String,
/// Optional last-modified timestamp from AUR.
pub last_modified: Option<i64>,
}
/// What: Helper container for official package update processing with bounded concurrency.
#[derive(Clone)]
struct OfficialCandidate {
/// Original order in the installed list to keep stable rendering.
order: usize,
/// Package metadata from the official index.
pkg: crate::state::PackageItem,
/// Previously seen version (if any).
last_seen: Option<String>,
/// Old version string captured from updates list (if available).
old_version: Option<String>,
/// Current remote version.
remote_version: String,
}
/// What: Process official packages and build candidates for update items.
///
/// Inputs:
/// - `installed_sorted`: Sorted list of installed package names.
/// - `seen_pkg_versions`: Last-seen versions map (mutated).
/// - `updates_versions`: Optional map of update versions (used for version information only, not for filtering).
/// - `force_emit_all`: Whether to emit all packages regardless of version changes.
/// - `remaining`: Remaining slots for updates.
///
/// Output:
/// - Tuple of (`official_candidates`, `aur_candidates`, `new_packages_count`, `updated_packages_count`, `baseline_only_count`, `remaining`)
///
/// Details:
/// - All installed packages are checked, regardless of whether they appear in `updates_versions`.
/// - `updates_versions` is used only to provide version information (old/new versions) when available.
/// - Packages are shown if they are new (not previously tracked) or have version changes.
fn process_official_packages<HV>(
installed_sorted: &[String],
seen_pkg_versions: &mut HashMap<String, String, HV>,
updates_versions: Option<&HashMap<String, (String, String)>>,
force_emit_all: bool,
mut remaining: usize,
) -> (
Vec<OfficialCandidate>,
Vec<String>,
usize,
usize,
usize,
usize,
)
where
HV: BuildHasher,
{
let mut aur_candidates: Vec<String> = Vec::new();
let mut official_candidates: Vec<OfficialCandidate> = Vec::new();
let mut baseline_only = 0usize;
let mut new_packages = 0usize;
let mut updated_packages = 0usize;
for name in installed_sorted {
if let Some(pkg) = crate::index::find_package_by_name(name) {
let (old_version_opt, remote_version) = updates_versions
.and_then(|m| m.get(&pkg.name))
.map_or((None, pkg.version.as_str()), |(old_v, new_v)| {
(Some(old_v.as_str()), new_v.as_str())
});
let remote_version = remote_version.to_string();
let last_seen = seen_pkg_versions.insert(pkg.name.clone(), remote_version.clone());
let is_new_package = last_seen.is_none();
let has_version_change = last_seen.as_ref() != Some(&remote_version);
// Always emit new packages (not previously tracked) and version changes
// Note: updates_versions is used only for version information, not for filtering
let should_emit = remaining > 0 && (force_emit_all || has_version_change);
if should_emit {
if is_new_package {
new_packages = new_packages.saturating_add(1);
} else if has_version_change {
updated_packages = updated_packages.saturating_add(1);
}
let order = official_candidates.len();
official_candidates.push(OfficialCandidate {
order,
pkg: pkg.clone(),
last_seen,
old_version: old_version_opt.map(str::to_string),
remote_version,
});
remaining = remaining.saturating_sub(1);
} else {
baseline_only = baseline_only.saturating_add(1);
}
} else {
aur_candidates.push(name.clone());
}
}
(
official_candidates,
aur_candidates,
new_packages,
updated_packages,
baseline_only,
remaining,
)
}
/// What: Process AUR packages and build update items.
///
/// Inputs:
/// - `aur_info`: AUR package information.
/// - `seen_pkg_versions`: Last-seen versions map (mutated).
/// - `updates_versions`: Optional map of update versions (used for version information only, not for filtering).
/// - `force_emit_all`: Whether to emit all packages regardless of version changes.
/// - `remaining`: Remaining slots for updates.
///
/// Output:
/// - Tuple of (`items`, `new_packages_count`, `updated_packages_count`, `baseline_only_count`, `remaining`)
///
/// Details:
/// - All AUR packages are checked, regardless of whether they appear in `updates_versions`.
/// - `updates_versions` is used only to provide version information (old/new versions) when available.
/// - Packages are shown if they are new (not previously tracked) or have version changes.
fn process_aur_packages<HV>(
aur_info: Vec<AurVersionInfo>,
seen_pkg_versions: &mut HashMap<String, String, HV>,
updates_versions: Option<&HashMap<String, (String, String)>>,
force_emit_all: bool,
mut remaining: usize,
) -> (Vec<NewsFeedItem>, usize, usize, usize, usize)
where
HV: BuildHasher,
{
let mut items = Vec::new();
let mut aur_new_packages = 0usize;
let mut aur_updated_packages = 0usize;
let mut baseline_only = 0usize;
for pkg in aur_info {
if remaining == 0 {
break;
}
let (old_version_opt, remote_version) = updates_versions
.and_then(|m| m.get(&pkg.name))
.map_or((None, pkg.version.as_str()), |(old_v, new_v)| {
(Some(old_v.as_str()), new_v.as_str())
});
let remote_version = remote_version.to_string();
let last_seen = seen_pkg_versions.insert(pkg.name.clone(), remote_version.clone());
let is_new_package = last_seen.is_none();
let has_version_change = last_seen.as_ref() != Some(&remote_version);
// Always emit new packages (not previously tracked) and version changes
// Note: updates_versions is used only for version information, not for filtering
let should_emit = remaining > 0 && (force_emit_all || has_version_change);
if should_emit {
if is_new_package {
aur_new_packages = aur_new_packages.saturating_add(1);
} else if has_version_change {
aur_updated_packages = aur_updated_packages.saturating_add(1);
}
items.push(build_aur_update_item(
&pkg,
last_seen.as_ref(),
old_version_opt,
&remote_version,
));
remaining = remaining.saturating_sub(1);
} else {
baseline_only = baseline_only.saturating_add(1);
}
}
(
items,
aur_new_packages,
aur_updated_packages,
baseline_only,
remaining,
)
}
/// Maximum retry attempts per package before giving up.
const MAX_RETRIES_PER_PACKAGE: u8 = 3;
/// Base delay in milliseconds between retry attempts (increases with each retry).
const RETRY_BASE_DELAY_MS: u64 = 10_000; // 10 seconds base
/// Delay multiplier for exponential backoff.
const RETRY_DELAY_MULTIPLIER: u64 = 2;
/// What: Candidate with retry tracking for background processing.
#[derive(Clone)]
struct BackgroundRetryCandidate {
/// Package name for logging.
pkg_name: String,
/// Repository slug.
repo_slug: String,
/// Architecture slug.
arch_slug: String,
/// Number of retry attempts so far.
retry_count: u8,
}
/// What: Fetch official package dates and spawn background retries for failures.
///
/// Inputs:
/// - `candidates`: List of official package candidates to fetch dates for.
///
/// Output:
/// - Vector of (order, `NewsFeedItem`) tuples - returned immediately.
///
/// Details:
/// - Performs initial fetch for all candidates concurrently.
/// - Returns immediately with successful fetches and cached fallbacks.
/// - Items needing retry use cached date or today's date initially.
/// - Spawns a background task to process retries conservatively.
/// - Background retries update the JSON cache for future fetches.
async fn fetch_official_dates_with_retry(
candidates: Vec<OfficialCandidate>,
) -> Vec<(usize, NewsFeedItem)> {
let mut retry_queue: Vec<BackgroundRetryCandidate> = Vec::new();
let mut official_items: Vec<(usize, NewsFeedItem)> = Vec::new();
// First pass: fetch all packages concurrently
let fetch_results: Vec<(OfficialCandidate, FetchDateResult)> = stream::iter(candidates)
.map(|candidate| async move {
let result = fetch_official_package_date(&candidate.pkg).await;
(candidate, result)
})
.buffer_unordered(5)
.collect::<Vec<_>>()
.await;
for (candidate, result) in fetch_results {
match result {
FetchDateResult::Success(date) | FetchDateResult::CachedFallback(date) => {
let item = build_official_update_item(
&candidate.pkg,
candidate.last_seen.as_ref(),
candidate.old_version.as_deref(),
&candidate.remote_version,
date,
);
official_items.push((candidate.order, item));
}
FetchDateResult::NeedsRetry => {
// Use today's date for now, queue for background retry
debug!(
package = %candidate.pkg.name,
"package needs retry, using today's date and queuing for background retry"
);
let item = build_official_update_item(
&candidate.pkg,
candidate.last_seen.as_ref(),
candidate.old_version.as_deref(),
&candidate.remote_version,
None, // Today's date for now
);
official_items.push((candidate.order, item));
// Extract info for background retry
if let crate::state::Source::Official { repo, arch } = &candidate.pkg.source {
let repo_slug = repo.to_lowercase();
let arch_slug = if arch.is_empty() {
std::env::consts::ARCH.to_string()
} else {
arch.clone()
};
retry_queue.push(BackgroundRetryCandidate {
pkg_name: candidate.pkg.name.clone(),
repo_slug,
arch_slug,
retry_count: 0,
});
}
}
}
}
// Spawn background retry task if there are items to retry
if !retry_queue.is_empty() {
info!(
"spawning background retry task for {} packages",
retry_queue.len()
);
tokio::spawn(process_retry_queue_background(retry_queue));
}
official_items
}
/// What: Process retry queue in the background (conservative, one at a time).
///
/// Inputs:
/// - `retry_queue`: Initial list of packages needing retry.
///
/// Output:
/// - None (updates JSON cache on disk for successful retries).
///
/// Details:
/// - Processes retries sequentially with exponential backoff delays.
/// - Failed retries go back to the end of the queue.
/// - Each package can retry up to `MAX_RETRIES_PER_PACKAGE` times.
/// - Successful retries update the JSON cache for future fetches.
async fn process_retry_queue_background(initial_queue: Vec<BackgroundRetryCandidate>) {
use std::collections::VecDeque;
let mut retry_queue: VecDeque<BackgroundRetryCandidate> = initial_queue.into_iter().collect();
info!(
"background retry task started with {} packages",
retry_queue.len()
);
while let Some(mut retry_item) = retry_queue.pop_front() {
retry_item.retry_count += 1;
// Calculate delay with exponential backoff
let delay_ms = RETRY_BASE_DELAY_MS
* RETRY_DELAY_MULTIPLIER
.saturating_pow(u32::from(retry_item.retry_count).saturating_sub(1));
info!(
package = %retry_item.pkg_name,
retry_attempt = retry_item.retry_count,
queue_remaining = retry_queue.len(),
delay_ms,
"background retry: waiting before attempt"
);
tokio::time::sleep(tokio::time::Duration::from_millis(delay_ms)).await;
// Fetch the JSON to update cache
let result = fetch_official_json_for_cache(
&retry_item.pkg_name,
&retry_item.repo_slug,
&retry_item.arch_slug,
)
.await;
match result {
Ok(()) => {
info!(
package = %retry_item.pkg_name,
retry_attempt = retry_item.retry_count,
"background retry succeeded, cache updated"
);
}
Err(needs_retry) if needs_retry => {
if retry_item.retry_count < MAX_RETRIES_PER_PACKAGE {
// Add back to the END of the queue for later retry
debug!(
package = %retry_item.pkg_name,
retry_attempt = retry_item.retry_count,
"background retry failed, adding back to end of queue"
);
retry_queue.push_back(retry_item);
} else {
warn!(
package = %retry_item.pkg_name,
max_retries = MAX_RETRIES_PER_PACKAGE,
"background retry: all attempts exhausted"
);
}
}
Err(_) => {
// Non-retryable error (e.g., used cache)
debug!(
package = %retry_item.pkg_name,
"background retry: completed (cache or non-retryable)"
);
}
}
}
info!("background retry task completed");
}
/// What: Fetch official package JSON and save to cache (for background retry).
///
/// Inputs:
/// - `pkg_name`: Package name.
/// - `repo_slug`: Repository slug (lowercase).
/// - `arch_slug`: Architecture slug.
///
/// Output:
/// - `Ok(())` on success (cache updated).
/// - `Err(true)` if fetch failed and should retry.
/// - `Err(false)` if fetch failed but no retry needed.
///
/// Details:
/// - Applies rate limiting and circuit breaker checks.
/// - Saves JSON to disk cache on success.
async fn fetch_official_json_for_cache(
pkg_name: &str,
repo_slug: &str,
arch_slug: &str,
) -> std::result::Result<(), bool> {
use super::rate_limit::{
check_circuit_breaker, increase_archlinux_backoff, rate_limit_archlinux,
record_circuit_breaker_outcome, reset_archlinux_backoff,
};
let url = format!("https://archlinux.org/packages/{repo_slug}/{arch_slug}/{pkg_name}/json/",);
let endpoint_pattern = "/packages/*/json/";
let cache_path = official_json_cache_path(repo_slug, arch_slug, pkg_name);
// Check circuit breaker
if check_circuit_breaker(endpoint_pattern).is_err() {
debug!(
package = %pkg_name,
"background retry: circuit breaker blocking"
);
return Err(true); // Should retry later
}
// Apply rate limiting
let _permit = rate_limit_archlinux().await;
// Fetch with timeout (longer for background)
let result = tokio::time::timeout(
tokio::time::Duration::from_millis(5000),
tokio::task::spawn_blocking({
let url = url.clone();
move || crate::util::curl::curl_json(&url)
}),
)
.await;
match result {
Ok(Ok(Ok(json))) => {
reset_archlinux_backoff();
record_circuit_breaker_outcome(endpoint_pattern, true);
// Save to cache
if let Err(e) = save_official_json_cache(&cache_path, &json) {
debug!(
error = %e,
package = %pkg_name,
"background retry: failed to save cache"
);
}
Ok(())
}
Ok(Ok(Err(e))) => {
increase_archlinux_backoff(None);
record_circuit_breaker_outcome(endpoint_pattern, false);
debug!(
package = %pkg_name,
error = %e,
"background retry: fetch failed"
);
Err(true) // Should retry
}
Ok(Err(e)) => {
increase_archlinux_backoff(None);
record_circuit_breaker_outcome(endpoint_pattern, false);
debug!(
package = %pkg_name,
error = ?e,
"background retry: task join failed"
);
Err(true) // Should retry
}
Err(_) => {
increase_archlinux_backoff(None);
record_circuit_breaker_outcome(endpoint_pattern, false);
debug!(package = %pkg_name, "background retry: timeout");
Err(true) // Should retry
}
}
}
/// What: Get the path to the AUR JSON cache directory.
///
/// Inputs: None.
///
/// Output:
/// - `PathBuf` pointing to the cache directory.
///
/// Details:
/// - Uses the lists directory from theme configuration.
#[must_use]
fn aur_json_cache_dir() -> PathBuf {
crate::theme::lists_dir().join("aur_json_cache")
}
/// What: Get the path to a cached AUR JSON file for a set of packages.
///
/// Inputs:
/// - `pkgnames`: Package names to generate cache key from.
///
/// Output:
/// - `PathBuf` to the cache file.
///
/// Details:
/// - Creates a deterministic filename from sorted package names.
fn aur_json_cache_path(pkgnames: &[String]) -> PathBuf {
let mut sorted = pkgnames.to_vec();
sorted.sort();
let key = sorted.join(",");
// Create a safe filename from the key
let safe_key = key
.chars()
.map(|c| {
if c.is_alphanumeric() || c == ',' || c == '-' || c == '_' {
c
} else {
'_'
}
})
.collect::<String>();
aur_json_cache_dir().join(format!("{safe_key}.json"))
}
/// What: Load previously cached AUR JSON from disk.
///
/// Inputs:
/// - `cache_path`: Path to the cache file.
///
/// Output:
/// - `Some(Value)` if cache exists and is valid JSON; `None` otherwise.
///
/// Details:
/// - Returns `None` on file read errors or JSON parse errors.
fn load_aur_json_cache(cache_path: &PathBuf) -> Option<Value> {
let data = std::fs::read_to_string(cache_path).ok()?;
serde_json::from_str::<Value>(&data).ok()
}
/// What: Save AUR JSON response to disk cache.
///
/// Inputs:
/// - `cache_path`: Path where to save the cache.
/// - `json`: JSON value to save.
///
/// Output:
/// - `Ok(())` on success, `Err` on failure.
///
/// Details:
/// - Creates parent directories if they don't exist.
/// - Saves pretty-printed JSON for readability.
fn save_aur_json_cache(cache_path: &PathBuf, json: &Value) -> std::io::Result<()> {
if let Some(parent) = cache_path.parent() {
std::fs::create_dir_all(parent)?;
}
let pretty = serde_json::to_string_pretty(json)?;
std::fs::write(cache_path, pretty)
}
/// What: Compare two AUR package JSON objects and generate a change description.
///
/// Inputs:
/// - `old_json`: Previous JSON object for the package.
/// - `new_json`: Current JSON object for the package.
/// - `pkg_name`: Package name for context.
///
/// Output:
/// - `Some(String)` with formatted changes if differences found; `None` if identical.
///
/// Details:
/// - Compares key fields like Version, Description, Maintainer, etc.
/// - Formats changes in a human-readable way.
fn compare_aur_json_changes(old_json: &Value, new_json: &Value, pkg_name: &str) -> Option<String> {
let mut changes = Vec::new();
// Compare Version
let old_version = old_json.get("Version").and_then(Value::as_str);
let new_version = new_json.get("Version").and_then(Value::as_str);
if old_version != new_version
&& let (Some(old_v), Some(new_v)) = (old_version, new_version)
&& old_v != new_v
{
changes.push(format!("Version: {old_v} β {new_v}"));
}
// Compare Description
let old_desc = old_json.get("Description").and_then(Value::as_str);
let new_desc = new_json.get("Description").and_then(Value::as_str);
if old_desc != new_desc
&& let (Some(old_d), Some(new_d)) = (old_desc, new_desc)
&& old_d != new_d
{
changes.push("Description changed".to_string());
}
// Compare Maintainer
let old_maintainer = old_json.get("Maintainer").and_then(Value::as_str);
let new_maintainer = new_json.get("Maintainer").and_then(Value::as_str);
if old_maintainer != new_maintainer
&& let (Some(old_m), Some(new_m)) = (old_maintainer, new_maintainer)
&& old_m != new_m
{
changes.push(format!("Maintainer: {old_m} β {new_m}"));
}
// Compare URL
let old_url = old_json.get("URL").and_then(Value::as_str);
let new_url = new_json.get("URL").and_then(Value::as_str);
if old_url != new_url
&& let (Some(old_u), Some(new_u)) = (old_url, new_url)
&& old_u != new_u
{
changes.push("URL changed".to_string());
}
// Compare License
let old_license = old_json.get("License").and_then(Value::as_array);
let new_license = new_json.get("License").and_then(Value::as_array);
if old_license != new_license {
changes.push("License changed".to_string());
}
// Compare Keywords
let old_keywords = old_json.get("Keywords").and_then(Value::as_array);
let new_keywords = new_json.get("Keywords").and_then(Value::as_array);
if old_keywords != new_keywords {
changes.push("Keywords changed".to_string());
}
if changes.is_empty() {
None
} else {
Some(format!(
"Changes detected for {pkg_name}:\n{}",
changes.join("\n")
))
}
}
/// What: Get the path to the official package JSON cache directory.
///
/// Inputs: None.
///
/// Output:
/// - `PathBuf` pointing to the cache directory.
///
/// Details:
/// - Uses the lists directory from theme configuration.
#[must_use]
fn official_json_cache_dir() -> PathBuf {
crate::theme::lists_dir().join("official_json_cache")
}
/// What: Get the path to a cached official package JSON file.
///
/// Inputs:
/// - `repo`: Repository name.
/// - `arch`: Architecture.
/// - `pkg_name`: Package name.
///
/// Output:
/// - `PathBuf` to the cache file.
///
/// Details:
/// - Creates a deterministic filename from repo, arch, and package name.
#[must_use]
pub fn official_json_cache_path(repo: &str, arch: &str, pkg_name: &str) -> PathBuf {
let safe_repo = repo
.chars()
.map(|c| {
if c.is_alphanumeric() || c == '-' || c == '_' {
c
} else {
'_'
}
})
.collect::<String>();
let safe_arch = arch
.chars()
.map(|c| {
if c.is_alphanumeric() || c == '-' || c == '_' {
c
} else {
'_'
}
})
.collect::<String>();
let safe_name = pkg_name
.chars()
.map(|c| {
if c.is_alphanumeric() || c == '-' || c == '_' {
c
} else {
'_'
}
})
.collect::<String>();
official_json_cache_dir().join(format!("{safe_repo}_{safe_arch}_{safe_name}.json"))
}
/// What: Load previously cached official package JSON from disk.
///
/// Inputs:
/// - `cache_path`: Path to the cache file.
///
/// Output:
/// - `Some(Value)` if cache exists and is valid JSON; `None` otherwise.
///
/// Details:
/// - Returns `None` on file read errors or JSON parse errors.
#[must_use]
pub fn load_official_json_cache(cache_path: &std::path::Path) -> Option<Value> {
let data = std::fs::read_to_string(cache_path).ok()?;
serde_json::from_str::<Value>(&data).ok()
}
/// What: Save official package JSON response to disk cache.
///
/// Inputs:
/// - `cache_path`: Path where to save the cache.
/// - `json`: JSON value to save.
///
/// Output:
/// - `Ok(())` on success, `Err` on failure.
///
/// Details:
/// - Creates parent directories if they don't exist.
/// - Saves pretty-printed JSON for readability.
pub(super) fn save_official_json_cache(cache_path: &PathBuf, json: &Value) -> std::io::Result<()> {
if let Some(parent) = cache_path.parent() {
std::fs::create_dir_all(parent)?;
}
let pretty = serde_json::to_string_pretty(json)?;
std::fs::write(cache_path, pretty)
}
/// What: Compare two official package JSON objects and generate a change description.
///
/// Inputs:
/// - `old_json`: Previous JSON object for the package.
/// - `new_json`: Current JSON object for the package.
/// - `pkg_name`: Package name for context.
///
/// Output:
/// - `Some(String)` with formatted changes if differences found; `None` if identical.
///
/// Details:
/// - Compares key fields like version, description, licenses, etc.
/// - Formats changes in a human-readable way.
pub(super) fn compare_official_json_changes(
old_json: &Value,
new_json: &Value,
pkg_name: &str,
) -> Option<String> {
let mut changes = Vec::new();
// Get the pkg object from both JSONs
let old_pkg = old_json.get("pkg").unwrap_or(old_json);
let new_pkg = new_json.get("pkg").unwrap_or(new_json);
// Compare Version
let old_version = old_pkg.get("pkgver").and_then(Value::as_str);
let new_version = new_pkg.get("pkgver").and_then(Value::as_str);
if old_version != new_version
&& let (Some(old_v), Some(new_v)) = (old_version, new_version)
&& old_v != new_v
{
changes.push(format!("Version: {old_v} β {new_v}"));
}
// Compare Description
let old_desc = old_pkg.get("pkgdesc").and_then(Value::as_str);
let new_desc = new_pkg.get("pkgdesc").and_then(Value::as_str);
if old_desc != new_desc
&& let (Some(old_d), Some(new_d)) = (old_desc, new_desc)
&& old_d != new_d
{
changes.push("Description changed".to_string());
}
// Compare Licenses
let old_licenses = old_pkg.get("licenses").and_then(Value::as_array);
let new_licenses = new_pkg.get("licenses").and_then(Value::as_array);
if old_licenses != new_licenses {
changes.push("Licenses changed".to_string());
}
// Compare URL
let old_url = old_pkg.get("url").and_then(Value::as_str);
let new_url = new_pkg.get("url").and_then(Value::as_str);
if old_url != new_url
&& let (Some(old_u), Some(new_u)) = (old_url, new_url)
&& old_u != new_u
{
changes.push("URL changed".to_string());
}
// Compare Groups
let old_groups = old_pkg.get("groups").and_then(Value::as_array);
let new_groups = new_pkg.get("groups").and_then(Value::as_array);
if old_groups != new_groups {
changes.push("Groups changed".to_string());
}
// Compare Dependencies
let old_depends = old_pkg.get("depends").and_then(Value::as_array);
let new_depends = new_pkg.get("depends").and_then(Value::as_array);
if old_depends != new_depends {
changes.push("Dependencies changed".to_string());
}
// Compare last_update date (check top-level JSON, not pkg object)
let old_last_update = old_json.get("last_update").and_then(Value::as_str);
let new_last_update = new_json.get("last_update").and_then(Value::as_str);
if old_last_update != new_last_update
&& let (Some(old_date), Some(new_date)) = (old_last_update, new_last_update)
&& old_date != new_date
{
// Normalize dates for comparison
if let (Some(old_norm), Some(new_norm)) =
(normalize_pkg_date(old_date), normalize_pkg_date(new_date))
&& old_norm != new_norm
{
changes.push(format!("Last update: {old_norm} β {new_norm}"));
}
}
if changes.is_empty() {
None
} else {
Some(format!(
"Changes detected for {pkg_name}:\n{}",
changes.join("\n")
))
}
}
/// What: Get cached JSON changes for an AUR package.
///
/// Inputs:
/// - `pkg_name`: Package name to look up.
///
/// Output:
/// - `Some(String)` with change description if changes were detected; `None` otherwise.
///
/// Details:
/// - Returns changes that were detected during the last `fetch_aur_versions` call.
#[must_use]
pub fn get_aur_json_changes(pkg_name: &str) -> Option<String> {
AUR_JSON_CHANGES_CACHE
.lock()
.ok()
.and_then(|cache| cache.get(pkg_name).cloned())
}
/// What: Get cached JSON changes for an official package.
///
/// Inputs:
/// - `pkg_name`: Package name to look up.
///
/// Output:
/// - `Some(String)` with change description if changes were detected; `None` otherwise.
///
/// Details:
/// - Returns changes that were detected during the last `fetch_official_package_date` call.
#[must_use]
pub fn get_official_json_changes(pkg_name: &str) -> Option<String> {
OFFICIAL_JSON_CHANGES_CACHE
.lock()
.ok()
.and_then(|cache| cache.get(pkg_name).cloned())
}
/// What: Fetch version info for a list of AUR packages via RPC v5.
///
/// Inputs:
/// - `pkgnames`: Package names to query (will be percent-encoded).
///
/// Output:
/// - `Ok(Vec<AurVersionInfo>)` with name/version/last-modified data; empty on empty input.
///
/// Details:
/// - Uses a single multi-arg RPC call to minimize network requests.
/// - Returns an empty list when request or parsing succeeds but yields no results.
/// - Saves JSON response to disk and compares with previous version to detect changes.
async fn fetch_aur_versions(pkgnames: &[String]) -> Result<Vec<AurVersionInfo>> {
if pkgnames.is_empty() {
return Ok(Vec::new());
}
let args: String = pkgnames
.iter()
.map(|n| format!("arg[]={}", crate::util::percent_encode(n)))
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | true |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/sources/feeds/cache.rs | src/sources/feeds/cache.rs | //! Cache management for news feeds (in-memory and disk).
use std::collections::HashMap;
use std::sync::{LazyLock, Mutex};
use std::time::Instant;
use crate::state::types::NewsFeedItem;
use tracing::{debug, info, warn};
/// Cache entry with data and timestamp (in-memory).
pub(super) struct CacheEntry {
/// Cached news feed items.
pub data: Vec<NewsFeedItem>,
/// Timestamp when the cache entry was created.
pub timestamp: Instant,
}
/// Disk cache entry with data and Unix timestamp (for serialization).
#[derive(serde::Serialize, serde::Deserialize, Debug)]
pub(super) struct DiskCacheEntry {
/// Cached news feed items.
pub data: Vec<NewsFeedItem>,
/// Unix timestamp (seconds since epoch) when the cache was saved.
pub saved_at: i64,
}
/// Simple in-memory cache for Arch news and advisories.
/// Key: source type (`"arch_news"` or `"advisories"`)
/// TTL: 15 minutes
pub(super) static NEWS_CACHE: LazyLock<Mutex<HashMap<String, CacheEntry>>> =
LazyLock::new(|| Mutex::new(HashMap::new()));
/// Cache TTL in seconds (15 minutes).
pub(super) const CACHE_TTL_SECONDS: u64 = 900;
/// Type alias for skip cache entry (results + timestamp).
pub(super) type SkipCacheEntry = Option<(Vec<NewsFeedItem>, Instant)>;
/// Cache for package updates results (time-based skip).
/// Stores last fetch results and timestamp to avoid re-fetching within 5 minutes.
pub(super) static UPDATES_CACHE: LazyLock<Mutex<SkipCacheEntry>> =
LazyLock::new(|| Mutex::new(None));
/// Cache for AUR comments results (time-based skip).
/// Stores last fetch results and timestamp to avoid re-fetching within 5 minutes.
pub(super) static AUR_COMMENTS_CACHE: LazyLock<Mutex<SkipCacheEntry>> =
LazyLock::new(|| Mutex::new(None));
/// Skip cache TTL in seconds (5 minutes) - if last fetch was within this time, use cached results.
pub(super) const SKIP_CACHE_TTL_SECONDS: u64 = 300;
/// What: Get the disk cache TTL in seconds from settings.
///
/// Inputs: None
///
/// Output: TTL in seconds (defaults to 14 days = 1209600 seconds).
///
/// Details:
/// - Reads `news_cache_ttl_days` from settings and converts to seconds.
/// - Minimum is 1 day to prevent excessive network requests.
pub(super) fn disk_cache_ttl_seconds() -> i64 {
let days = crate::theme::settings().news_cache_ttl_days.max(1);
i64::from(days) * 86400 // days to seconds
}
/// What: Get the path to a disk cache file for a specific source.
///
/// Inputs:
/// - `source`: Cache source identifier (`"arch_news"` or `"advisories"`).
///
/// Output:
/// - `PathBuf` to the cache file.
pub(super) fn disk_cache_path(source: &str) -> std::path::PathBuf {
crate::theme::lists_dir().join(format!("{source}_cache.json"))
}
/// What: Load cached data from disk if available and not expired.
///
/// Inputs:
/// - `source`: Cache source identifier.
///
/// Output:
/// - `Some(Vec<NewsFeedItem>)` if valid cache exists, `None` otherwise.
///
/// Details:
/// - Returns `None` if file doesn't exist, is corrupted, or cache is older than configured TTL.
pub(super) fn load_from_disk_cache(source: &str) -> Option<Vec<NewsFeedItem>> {
let path = disk_cache_path(source);
let content = std::fs::read_to_string(&path).ok()?;
let entry: DiskCacheEntry = serde_json::from_str(&content).ok()?;
let now = chrono::Utc::now().timestamp();
let age = now - entry.saved_at;
let ttl = disk_cache_ttl_seconds();
if age < ttl {
info!(
source,
items = entry.data.len(),
age_hours = age / 3600,
ttl_days = ttl / 86400,
"loaded from disk cache"
);
Some(entry.data)
} else {
debug!(
source,
age_hours = age / 3600,
ttl_days = ttl / 86400,
"disk cache expired"
);
None
}
}
/// What: Save data to disk cache with current timestamp.
///
/// Inputs:
/// - `source`: Cache source identifier.
/// - `data`: News feed items to cache.
///
/// Details:
/// - Writes to disk asynchronously to avoid blocking.
/// - Logs errors but does not propagate them.
pub(super) fn save_to_disk_cache(source: &str, data: &[NewsFeedItem]) {
let entry = DiskCacheEntry {
data: data.to_vec(),
saved_at: chrono::Utc::now().timestamp(),
};
let path = disk_cache_path(source);
match serde_json::to_string_pretty(&entry) {
Ok(json) => {
if let Err(e) = std::fs::write(&path, json) {
warn!(error = %e, source, "failed to write disk cache");
} else {
debug!(source, items = data.len(), "saved to disk cache");
}
}
Err(e) => warn!(error = %e, source, "failed to serialize disk cache"),
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/sources/feeds/news_fetch.rs | src/sources/feeds/news_fetch.rs | //! News and advisories fetching with caching.
use std::collections::HashSet;
use std::hash::BuildHasher;
use std::time::{Duration, Instant};
use crate::state::types::{NewsFeedItem, NewsFeedSource};
use tracing::{info, warn};
use super::Result;
use super::cache::{
CACHE_TTL_SECONDS, CacheEntry, NEWS_CACHE, load_from_disk_cache, save_to_disk_cache,
};
use super::rate_limit::{
extract_retry_after_from_error, increase_archlinux_backoff, rate_limit, rate_limit_archlinux,
reset_archlinux_backoff, retry_with_backoff, set_network_error,
};
/// What: Fetch Arch news items with optional early date filtering and caching.
///
/// Inputs:
/// - `limit`: Maximum items to fetch.
/// - `cutoff_date`: Optional date string (YYYY-MM-DD) for early filtering.
///
/// Output: Vector of `NewsFeedItem` representing Arch news.
///
/// Details:
/// - If `cutoff_date` is provided, stops fetching when items exceed the date limit.
/// - Uses in-memory cache with 15-minute TTL to avoid redundant fetches.
/// - Falls back to disk cache (configurable TTL, default 14 days) if in-memory cache misses.
/// - Saves fetched data to both in-memory and disk caches.
pub(super) async fn append_arch_news(
limit: usize,
cutoff_date: Option<&str>,
) -> Result<Vec<NewsFeedItem>> {
const SOURCE: &str = "arch_news";
// 1. Check in-memory cache first (fastest, 15-minute TTL)
if cutoff_date.is_none()
&& let Ok(cache) = NEWS_CACHE.lock()
&& let Some(entry) = cache.get(SOURCE)
&& entry.timestamp.elapsed().as_secs() < CACHE_TTL_SECONDS
{
info!("using in-memory cached arch news");
return Ok(entry.data.clone());
}
// 2. Check disk cache (24-hour TTL) - useful after app restart
if cutoff_date.is_none()
&& let Some(disk_data) = load_from_disk_cache(SOURCE)
{
// Populate in-memory cache from disk
if let Ok(mut cache) = NEWS_CACHE.lock() {
cache.insert(
SOURCE.to_string(),
CacheEntry {
data: disk_data.clone(),
timestamp: Instant::now(),
},
);
}
return Ok(disk_data);
}
// 3. Fetch from network - NO retries for arch news to avoid long delays
// If archlinux.org is blocked/slow, we skip it rather than retrying
let fetch_result: std::result::Result<
Vec<crate::state::types::NewsItem>,
Box<dyn std::error::Error + Send + Sync>,
> = {
// Acquire semaphore permit and hold it during the request
// This ensures only one archlinux.org request is in flight at a time
let _permit = rate_limit_archlinux().await;
let result = crate::sources::fetch_arch_news(limit, cutoff_date).await;
// Check for HTTP 429/503 and update backoff for future requests
if let Err(ref e) = result {
let error_str = e.to_string();
let retry_after_seconds = extract_retry_after_from_error(&error_str);
if error_str.contains("429") || error_str.contains("503") {
if let Some(retry_after) = retry_after_seconds {
warn!(
retry_after_seconds = retry_after,
"HTTP {} detected, noting Retry-After for future requests",
if error_str.contains("429") {
"429"
} else {
"503"
}
);
// Use Retry-After value for backoff on future requests
increase_archlinux_backoff(Some(retry_after));
} else {
warn!(
"HTTP {} detected, increasing backoff for future requests",
if error_str.contains("429") {
"429"
} else {
"503"
}
);
// Increase backoff for future requests
increase_archlinux_backoff(None);
}
} else {
// For other errors (timeout, network), only mild backoff increase
increase_archlinux_backoff(None);
}
}
result
};
match fetch_result {
Ok(news) => {
// Reset backoff after successful request
reset_archlinux_backoff();
let items: Vec<NewsFeedItem> = news
.into_iter()
.map(|n| NewsFeedItem {
id: n.url.clone(),
date: n.date,
title: n.title,
summary: None,
url: Some(n.url),
source: NewsFeedSource::ArchNews,
severity: None,
packages: Vec::new(),
})
.collect();
// Cache the result (only if no cutoff_date)
if cutoff_date.is_none() {
// Save to in-memory cache
if let Ok(mut cache) = NEWS_CACHE.lock() {
cache.insert(
SOURCE.to_string(),
CacheEntry {
data: items.clone(),
timestamp: Instant::now(),
},
);
}
// Save to disk cache for persistence across restarts
save_to_disk_cache(SOURCE, &items);
}
Ok(items)
}
Err(e) => {
warn!(error = %e, "arch news fetch failed");
set_network_error();
// Increase backoff after failure
increase_archlinux_backoff(None);
// Graceful degradation: try in-memory cache first
if let Ok(cache) = NEWS_CACHE.lock()
&& let Some(entry) = cache.get(SOURCE)
{
info!(
cached_items = entry.data.len(),
age_secs = entry.timestamp.elapsed().as_secs(),
"using stale in-memory cached arch news due to fetch failure"
);
return Ok(entry.data.clone());
}
// Then try disk cache (ignores TTL for fallback)
if let Some(disk_data) = load_from_disk_cache(SOURCE) {
info!(
cached_items = disk_data.len(),
"using disk cached arch news due to fetch failure"
);
return Ok(disk_data);
}
Err(e)
}
}
}
/// What: Fetch security advisories with optional early date filtering and caching.
///
/// Inputs:
/// - `limit`: Maximum items to fetch.
/// - `installed_filter`: Optional installed set for filtering.
/// - `installed_only`: Whether to drop advisories unrelated to installed packages.
/// - `cutoff_date`: Optional date string (YYYY-MM-DD) for early filtering.
///
/// Output: Vector of `NewsFeedItem` representing security advisories.
///
/// Details:
/// - If `cutoff_date` is provided, stops fetching when items exceed the date limit.
/// - Uses in-memory cache with 15-minute TTL to avoid redundant fetches.
/// - Falls back to disk cache (configurable TTL, default 14 days) if in-memory cache misses.
/// - Note: Cache key includes `installed_only` flag to handle different filtering needs.
pub(super) async fn append_advisories<S>(
limit: usize,
installed_filter: Option<&HashSet<String, S>>,
installed_only: bool,
cutoff_date: Option<&str>,
) -> Result<Vec<NewsFeedItem>>
where
S: BuildHasher + Send + Sync + 'static,
{
const SOURCE: &str = "advisories";
// 1. Check in-memory cache first (fastest, 15-minute TTL)
if cutoff_date.is_none()
&& !installed_only
&& let Ok(cache) = NEWS_CACHE.lock()
&& let Some(entry) = cache.get(SOURCE)
&& entry.timestamp.elapsed().as_secs() < CACHE_TTL_SECONDS
{
info!("using in-memory cached advisories");
return Ok(entry.data.clone());
}
// 2. Check disk cache (24-hour TTL) - useful after app restart
if cutoff_date.is_none()
&& !installed_only
&& let Some(disk_data) = load_from_disk_cache(SOURCE)
{
// Populate in-memory cache from disk
if let Ok(mut cache) = NEWS_CACHE.lock() {
cache.insert(
SOURCE.to_string(),
CacheEntry {
data: disk_data.clone(),
timestamp: Instant::now(),
},
);
}
return Ok(disk_data);
}
// 3. Fetch from network with retry and exponential backoff
rate_limit().await;
let fetch_result = retry_with_backoff(
|| async {
rate_limit().await;
crate::sources::fetch_security_advisories(limit, cutoff_date).await
},
2, // Max 2 retries (3 total attempts)
)
.await;
match fetch_result {
Ok(advisories) => {
let mut filtered = Vec::new();
for adv in advisories {
if installed_only
&& let Some(set) = installed_filter
&& !adv.packages.iter().any(|p| set.contains(p))
{
continue;
}
filtered.push(adv);
}
// Cache the result (only if no cutoff_date and not installed_only)
if cutoff_date.is_none() && !installed_only {
// Save to in-memory cache
if let Ok(mut cache) = NEWS_CACHE.lock() {
cache.insert(
SOURCE.to_string(),
CacheEntry {
data: filtered.clone(),
timestamp: Instant::now(),
},
);
}
// Save to disk cache for persistence across restarts
save_to_disk_cache(SOURCE, &filtered);
}
Ok(filtered)
}
Err(e) => {
warn!(error = %e, "security advisories fetch failed");
set_network_error();
// Graceful degradation: try in-memory cache first
if let Ok(cache) = NEWS_CACHE.lock()
&& let Some(entry) = cache.get(SOURCE)
{
info!(
cached_items = entry.data.len(),
age_secs = entry.timestamp.elapsed().as_secs(),
"using stale in-memory cached advisories due to fetch failure"
);
return Ok(entry.data.clone());
}
// Then try disk cache (ignores TTL for fallback)
if let Some(disk_data) = load_from_disk_cache(SOURCE) {
info!(
cached_items = disk_data.len(),
"using disk cached advisories due to fetch failure"
);
return Ok(disk_data);
}
Err(e)
}
}
}
/// What: Fetch slow sources (Arch news and advisories) in parallel with timeout.
///
/// Inputs:
/// - `include_arch_news`: Whether to fetch Arch news.
/// - `include_advisories`: Whether to fetch advisories.
/// - `limit`: Maximum items per source.
/// - `installed_filter`: Optional set of installed package names.
/// - `installed_only`: Whether to restrict advisories to installed packages.
/// - `cutoff_date`: Optional date cutoff for filtering.
///
/// Output:
/// - Tuple of (`arch_result`, `advisories_result`).
///
/// Details:
/// - Applies 30-second timeout to match HTTP client timeout.
/// - Returns empty vectors on timeout or errors (graceful degradation).
pub(super) async fn fetch_slow_sources<HS>(
include_arch_news: bool,
include_advisories: bool,
limit: usize,
installed_filter: Option<&HashSet<String, HS>>,
installed_only: bool,
cutoff_date: Option<&str>,
) -> (
std::result::Result<Vec<NewsFeedItem>, Box<dyn std::error::Error + Send + Sync>>,
std::result::Result<Vec<NewsFeedItem>, Box<dyn std::error::Error + Send + Sync>>,
)
where
HS: BuildHasher + Send + Sync + 'static,
{
let arch_result: std::result::Result<
Vec<NewsFeedItem>,
Box<dyn std::error::Error + Send + Sync>,
> = if include_arch_news {
info!("fetching arch news...");
tokio::time::timeout(
Duration::from_secs(30),
append_arch_news(limit, cutoff_date),
)
.await
.map_or_else(
|_| {
warn!("arch news fetch timed out after 30s, continuing without arch news");
Err("Arch news fetch timeout".into())
},
|result| {
info!(
"arch news fetch completed: items={}",
result.as_ref().map(Vec::len).unwrap_or(0)
);
result
},
)
} else {
Ok(Vec::new())
};
let advisories_result: std::result::Result<
Vec<NewsFeedItem>,
Box<dyn std::error::Error + Send + Sync>,
> = if include_advisories {
info!("fetching advisories...");
tokio::time::timeout(
Duration::from_secs(30),
append_advisories(limit, installed_filter, installed_only, cutoff_date),
)
.await
.map_or_else(
|_| {
warn!("advisories fetch timed out after 30s, continuing without advisories");
Err("Advisories fetch timeout".into())
},
|result| {
info!(
"advisories fetch completed: items={}",
result.as_ref().map(Vec::len).unwrap_or(0)
);
result
},
)
} else {
Ok(Vec::new())
};
(arch_result, advisories_result)
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/app/persist.rs | src/app/persist.rs | use std::fs;
use super::deps_cache;
use super::files_cache;
use super::sandbox_cache;
use super::services_cache;
use crate::state::AppState;
/// What: Persist the details cache to disk if marked dirty.
///
/// Inputs:
/// - `app`: Application state whose `details_cache` and `cache_path` are used
///
/// Output:
/// - Writes `details_cache` JSON to `cache_path` and clears the dirty flag on success.
pub fn maybe_flush_cache(app: &mut AppState) {
if !app.cache_dirty {
return;
}
if let Ok(s) = serde_json::to_string(&app.details_cache) {
tracing::trace!(
path = %app.cache_path.display(),
bytes = s.len(),
"[Persist] Writing details cache to disk"
);
match fs::write(&app.cache_path, &s) {
Ok(()) => {
tracing::trace!(
path = %app.cache_path.display(),
"[Persist] Details cache persisted"
);
}
Err(e) => {
tracing::warn!(
path = %app.cache_path.display(),
error = %e,
"[Persist] Failed to write details cache"
);
}
}
// Preserve existing behaviour: clear dirty flag regardless to avoid repeated writes.
app.cache_dirty = false;
}
}
/// What: Persist the recent searches list to disk if marked dirty.
///
/// Inputs:
/// - `app`: Application state containing `recent` and `recent_path`
///
/// Output:
/// - Writes `recent` JSON to `recent_path` and clears the dirty flag on success.
pub fn maybe_flush_recent(app: &mut AppState) {
if !app.recent_dirty {
return;
}
let recent_values = app.recent_values();
if let Ok(s) = serde_json::to_string(&recent_values) {
tracing::debug!(
path = %app.recent_path.display(),
bytes = s.len(),
"[Persist] Writing recent searches to disk"
);
match fs::write(&app.recent_path, &s) {
Ok(()) => {
tracing::debug!(
path = %app.recent_path.display(),
"[Persist] Recent searches persisted"
);
}
Err(e) => {
tracing::warn!(
path = %app.recent_path.display(),
error = %e,
"[Persist] Failed to write recent searches"
);
}
}
app.recent_dirty = false;
}
}
/// What: Persist the news search history to disk if marked dirty.
///
/// Inputs:
/// - `app`: Application state containing `news_recent` and `news_recent_path`
pub fn maybe_flush_news_recent(app: &mut AppState) {
if !app.news_recent_dirty {
return;
}
let values: Vec<String> = app.news_recent.iter().map(|(_, v)| v.clone()).collect();
if let Ok(s) = serde_json::to_string(&values) {
tracing::debug!(
path = %app.news_recent_path.display(),
bytes = s.len(),
"[Persist] Writing news recent searches to disk"
);
match fs::write(&app.news_recent_path, &s) {
Ok(()) => {
tracing::debug!(
path = %app.news_recent_path.display(),
"[Persist] News recent searches persisted"
);
}
Err(e) => {
tracing::warn!(
path = %app.news_recent_path.display(),
error = %e,
"[Persist] Failed to write news recent searches"
);
}
}
app.news_recent_dirty = false;
}
}
/// What: Persist news bookmarks to disk if marked dirty.
///
/// Inputs:
/// - `app`: Application state containing `news_bookmarks` and `news_bookmarks_path`
pub fn maybe_flush_news_bookmarks(app: &mut AppState) {
if !app.news_bookmarks_dirty {
return;
}
if let Ok(s) = serde_json::to_string(&app.news_bookmarks) {
tracing::debug!(
path = %app.news_bookmarks_path.display(),
bytes = s.len(),
"[Persist] Writing news bookmarks to disk"
);
match fs::write(&app.news_bookmarks_path, &s) {
Ok(()) => {
tracing::debug!(
path = %app.news_bookmarks_path.display(),
"[Persist] News bookmarks persisted"
);
}
Err(e) => {
tracing::warn!(
path = %app.news_bookmarks_path.display(),
error = %e,
"[Persist] Failed to write news bookmarks"
);
}
}
app.news_bookmarks_dirty = false;
}
}
/// What: Persist the news article content cache to disk if marked dirty.
///
/// Inputs:
/// - `app`: Application state containing `news_content_cache` and `news_content_cache_path`
///
/// Output:
/// - Writes `news_content_cache` JSON to `news_content_cache_path` and clears the dirty flag on success.
///
/// Details:
/// - Caches article content (URL -> content string) to avoid re-fetching on restart.
pub fn maybe_flush_news_content_cache(app: &mut AppState) {
if !app.news_content_cache_dirty {
return;
}
if let Ok(s) = serde_json::to_string(&app.news_content_cache) {
tracing::debug!(
path = %app.news_content_cache_path.display(),
bytes = s.len(),
entries = app.news_content_cache.len(),
"[Persist] Writing news content cache to disk"
);
match fs::write(&app.news_content_cache_path, &s) {
Ok(()) => {
tracing::debug!(
path = %app.news_content_cache_path.display(),
"[Persist] News content cache persisted"
);
}
Err(e) => {
tracing::warn!(
path = %app.news_content_cache_path.display(),
error = %e,
"[Persist] Failed to write news content cache"
);
}
}
app.news_content_cache_dirty = false;
}
}
/// What: Persist the set of read Arch news URLs to disk if marked dirty.
///
/// Inputs:
/// - `app`: Application state containing `news_read_urls` and `news_read_path`
///
/// Output:
/// - Writes `news_read_urls` JSON to `news_read_path` and clears the dirty flag on success.
pub fn maybe_flush_news_read(app: &mut AppState) {
if !app.news_read_dirty {
return;
}
if let Ok(s) = serde_json::to_string(&app.news_read_urls) {
tracing::debug!(
path = %app.news_read_path.display(),
bytes = s.len(),
"[Persist] Writing news read URLs to disk"
);
match fs::write(&app.news_read_path, &s) {
Ok(()) => {
tracing::debug!(
path = %app.news_read_path.display(),
"[Persist] News read URLs persisted"
);
}
Err(e) => {
tracing::warn!(
path = %app.news_read_path.display(),
error = %e,
"[Persist] Failed to write news read URLs"
);
}
}
app.news_read_dirty = false;
}
}
/// What: Persist the set of read news IDs to disk if marked dirty.
///
/// Inputs:
/// - `app`: Application state containing `news_read_ids` and `news_read_ids_path`
///
/// Output:
/// - Writes `news_read_ids` JSON to `news_read_ids_path` and clears the dirty flag on success.
pub fn maybe_flush_news_read_ids(app: &mut AppState) {
if !app.news_read_ids_dirty {
return;
}
if let Ok(s) = serde_json::to_string(&app.news_read_ids) {
tracing::debug!(
path = %app.news_read_ids_path.display(),
bytes = s.len(),
"[Persist] Writing news read IDs to disk"
);
match fs::write(&app.news_read_ids_path, &s) {
Ok(()) => {
tracing::debug!(
path = %app.news_read_ids_path.display(),
"[Persist] News read IDs persisted"
);
}
Err(e) => {
tracing::warn!(
path = %app.news_read_ids_path.display(),
error = %e,
"[Persist] Failed to write news read IDs"
);
}
}
app.news_read_ids_dirty = false;
}
}
/// What: Persist last-seen package versions for news updates if marked dirty.
///
/// Inputs:
/// - `app`: Application state containing `news_seen_pkg_versions` and its path.
///
/// Output:
/// - Writes JSON file when dirty, clears the dirty flag on success.
///
/// Details:
/// - No-op when dirty flag is false; logs success/failure.
pub fn maybe_flush_news_seen_versions(app: &mut AppState) {
if !app.news_seen_pkg_versions_dirty {
return;
}
if let Ok(s) = serde_json::to_string(&app.news_seen_pkg_versions) {
tracing::debug!(
path = %app.news_seen_pkg_versions_path.display(),
bytes = s.len(),
"[Persist] Writing news seen package versions to disk"
);
match fs::write(&app.news_seen_pkg_versions_path, &s) {
Ok(()) => {
tracing::debug!(
path = %app.news_seen_pkg_versions_path.display(),
"[Persist] News seen package versions persisted"
);
}
Err(e) => {
tracing::warn!(
path = %app.news_seen_pkg_versions_path.display(),
error = %e,
"[Persist] Failed to write news seen package versions"
);
}
}
app.news_seen_pkg_versions_dirty = false;
}
}
/// What: Persist last-seen AUR comments if marked dirty.
///
/// Inputs:
/// - `app`: Application state containing `news_seen_aur_comments` and its path.
///
/// Output:
/// - Writes JSON file when dirty, clears the dirty flag on success.
///
/// Details:
/// - No-op when dirty flag is false; logs success/failure.
pub fn maybe_flush_news_seen_aur_comments(app: &mut AppState) {
if !app.news_seen_aur_comments_dirty {
return;
}
if let Ok(s) = serde_json::to_string(&app.news_seen_aur_comments) {
tracing::debug!(
path = %app.news_seen_aur_comments_path.display(),
bytes = s.len(),
"[Persist] Writing news seen AUR comments to disk"
);
match fs::write(&app.news_seen_aur_comments_path, &s) {
Ok(()) => {
tracing::debug!(
path = %app.news_seen_aur_comments_path.display(),
"[Persist] News seen AUR comments persisted"
);
}
Err(e) => {
tracing::warn!(
path = %app.news_seen_aur_comments_path.display(),
error = %e,
"[Persist] Failed to write news seen AUR comments"
);
}
}
app.news_seen_aur_comments_dirty = false;
}
}
/// What: Persist the announcement read IDs to disk if marked dirty.
///
/// Inputs:
/// - `app`: Application state containing `announcements_read_ids` and `announcement_read_path`
///
/// Output:
/// - Writes `announcements_read_ids` JSON to `announcement_read_path` and clears the dirty flag on success.
///
/// Details:
/// - Saves set of read announcement IDs as JSON array.
pub fn maybe_flush_announcement_read(app: &mut AppState) {
if !app.announcement_dirty {
return;
}
if let Ok(s) = serde_json::to_string(&app.announcements_read_ids) {
tracing::debug!(
path = %app.announcement_read_path.display(),
bytes = s.len(),
"[Persist] Writing announcement read IDs to disk"
);
match fs::write(&app.announcement_read_path, &s) {
Ok(()) => {
tracing::debug!(
path = %app.announcement_read_path.display(),
"[Persist] Announcement read IDs persisted"
);
}
Err(e) => {
tracing::warn!(
path = %app.announcement_read_path.display(),
error = %e,
"[Persist] Failed to write announcement read IDs"
);
}
}
app.announcement_dirty = false;
}
}
/// What: Persist the dependency cache to disk if marked dirty.
///
/// Inputs:
/// - `app`: Application state with `install_list_deps`, `deps_cache_path`, and `install_list`
///
/// Output:
/// - Writes dependency cache JSON to `deps_cache_path` and clears dirty flag on success.
/// - If install list is empty, ensures an empty cache file exists instead of deleting it.
pub fn maybe_flush_deps_cache(app: &mut AppState) {
if app.install_list.is_empty() {
// Write an empty cache file when nothing is queued to keep the path present.
if app.deps_cache_dirty || !app.deps_cache_path.exists() {
let empty_signature: Vec<String> = Vec::new();
tracing::debug!(
path = %app.deps_cache_path.display(),
"[Persist] Writing empty dependency cache because install list is empty"
);
deps_cache::save_cache(&app.deps_cache_path, &empty_signature, &[]);
}
app.deps_cache_dirty = false;
return;
}
if !app.deps_cache_dirty {
return;
}
let signature = deps_cache::compute_signature(&app.install_list);
tracing::debug!(
path = %app.deps_cache_path.display(),
signature_len = signature.len(),
deps_len = app.install_list_deps.len(),
"[Persist] Saving dependency cache"
);
deps_cache::save_cache(&app.deps_cache_path, &signature, &app.install_list_deps);
app.deps_cache_dirty = false;
tracing::debug!(
path = %app.deps_cache_path.display(),
deps_len = app.install_list_deps.len(),
"[Persist] Dependency cache save attempted"
);
}
/// What: Persist the file cache to disk if marked dirty.
///
/// Inputs:
/// - `app`: Application state with `install_list_files`, `files_cache_path`, and `install_list`
///
/// Output:
/// - Writes file cache JSON to `files_cache_path` and clears dirty flag on success.
/// - If install list is empty, ensures an empty cache file exists instead of deleting it.
pub fn maybe_flush_files_cache(app: &mut AppState) {
if app.install_list.is_empty() {
// Write an empty cache file when nothing is queued to keep the path present.
if app.files_cache_dirty || !app.files_cache_path.exists() {
let empty_signature: Vec<String> = Vec::new();
tracing::debug!(
path = %app.files_cache_path.display(),
"[Persist] Writing empty file cache because install list is empty"
);
files_cache::save_cache(&app.files_cache_path, &empty_signature, &[]);
}
app.files_cache_dirty = false;
return;
}
if !app.files_cache_dirty {
return;
}
let signature = files_cache::compute_signature(&app.install_list);
tracing::debug!(
"[Persist] Saving file cache: {} entries for packages: {:?}, signature: {:?}",
app.install_list_files.len(),
app.install_list_files
.iter()
.map(|f| &f.name)
.collect::<Vec<_>>(),
signature
);
files_cache::save_cache(&app.files_cache_path, &signature, &app.install_list_files);
app.files_cache_dirty = false;
tracing::debug!(
"[Persist] File cache saved successfully, install_list_files still has {} entries",
app.install_list_files.len()
);
}
/// What: Persist the service cache to disk if marked dirty.
///
/// Inputs:
/// - `app`: Application state with `install_list_services`, `services_cache_path`, and `install_list`
///
/// Output:
/// - Writes service cache JSON to `services_cache_path` and clears dirty flag on success.
/// - If install list is empty, ensures an empty cache file exists instead of deleting it.
pub fn maybe_flush_services_cache(app: &mut AppState) {
if app.install_list.is_empty() {
// Write an empty cache file when nothing is queued to keep the path present.
if app.services_cache_dirty || !app.services_cache_path.exists() {
let empty_signature: Vec<String> = Vec::new();
tracing::debug!(
path = %app.services_cache_path.display(),
"[Persist] Writing empty service cache because install list is empty"
);
services_cache::save_cache(&app.services_cache_path, &empty_signature, &[]);
}
app.services_cache_dirty = false;
return;
}
if !app.services_cache_dirty {
return;
}
let signature = services_cache::compute_signature(&app.install_list);
tracing::debug!(
path = %app.services_cache_path.display(),
signature_len = signature.len(),
services_len = app.install_list_services.len(),
"[Persist] Saving service cache"
);
services_cache::save_cache(
&app.services_cache_path,
&signature,
&app.install_list_services,
);
app.services_cache_dirty = false;
tracing::debug!(
path = %app.services_cache_path.display(),
services_len = app.install_list_services.len(),
"[Persist] Service cache save attempted"
);
}
/// What: Persist the sandbox cache to disk if marked dirty.
///
/// Inputs:
/// - `app`: Application state with `install_list_sandbox`, `sandbox_cache_path`, and `install_list`
///
/// Output:
/// - Writes sandbox cache JSON to `sandbox_cache_path` and clears dirty flag on success.
/// - If install list is empty, ensures an empty cache file exists instead of deleting it.
pub fn maybe_flush_sandbox_cache(app: &mut AppState) {
if app.install_list.is_empty() {
// Write an empty cache file when nothing is queued to keep the path present.
if app.sandbox_cache_dirty || !app.sandbox_cache_path.exists() {
let empty_signature: Vec<String> = Vec::new();
tracing::debug!(
path = %app.sandbox_cache_path.display(),
"[Persist] Writing empty sandbox cache because install list is empty"
);
sandbox_cache::save_cache(&app.sandbox_cache_path, &empty_signature, &[]);
}
app.sandbox_cache_dirty = false;
return;
}
if !app.sandbox_cache_dirty {
return;
}
let signature = sandbox_cache::compute_signature(&app.install_list);
tracing::debug!(
"[Persist] Saving sandbox cache: {} entries for packages: {:?}, signature: {:?}",
app.install_list_sandbox.len(),
app.install_list_sandbox
.iter()
.map(|s| &s.package_name)
.collect::<Vec<_>>(),
signature
);
sandbox_cache::save_cache(
&app.sandbox_cache_path,
&signature,
&app.install_list_sandbox,
);
app.sandbox_cache_dirty = false;
tracing::debug!(
"[Persist] Sandbox cache saved successfully, install_list_sandbox still has {} entries",
app.install_list_sandbox.len()
);
}
/// What: Persist the PKGBUILD parse cache if there are pending updates.
///
/// Inputs: None.
///
/// Output:
/// - Flushes the global PKGBUILD parse cache to disk best-effort.
///
/// Details:
/// - Safe to call frequently; returns immediately when cache is clean.
pub fn maybe_flush_pkgbuild_parse_cache() {
crate::logic::files::flush_pkgbuild_cache();
}
/// What: Persist the install list to disk if marked dirty, throttled to ~1s.
///
/// Inputs:
/// - `app`: Application state with `install_list`, `install_path`, and throttle timestamps
///
/// Output:
/// - Writes `install_list` JSON to `install_path` and clears dirty flags when written.
pub fn maybe_flush_install(app: &mut AppState) {
// Throttle disk writes: only flush if dirty and either never written
// before or the last change is at least 1s ago.
if !app.install_dirty {
return;
}
if let Some(when) = app.last_install_change
&& when.elapsed() < std::time::Duration::from_millis(1000)
{
return;
}
if let Ok(s) = serde_json::to_string(&app.install_list) {
tracing::debug!(
path = %app.install_path.display(),
bytes = s.len(),
"[Persist] Writing install list to disk"
);
match fs::write(&app.install_path, &s) {
Ok(()) => {
tracing::debug!(
path = %app.install_path.display(),
"[Persist] Install list persisted"
);
}
Err(e) => {
tracing::warn!(
path = %app.install_path.display(),
error = %e,
"[Persist] Failed to write install list"
);
}
}
app.install_dirty = false;
app.last_install_change = None;
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::state::modal::{
DependencyInfo, DependencySource, DependencyStatus, FileChange, FileChangeType,
PackageFileInfo,
};
use crate::state::{PackageItem, Source};
fn new_app() -> AppState {
AppState::default()
}
#[test]
/// What: Ensure `maybe_flush_cache` persists the details cache and clears the dirty flag.
///
/// Inputs:
/// - `AppState` with `cache_dirty = true` pointing to a temporary cache path.
///
/// Output:
/// - Writes JSON to disk, resets `cache_dirty`, and leaves audit strings in the file.
///
/// Details:
/// - Validates the helper cleans up after itself by removing the temp file at the end.
fn flush_cache_writes_and_clears_flag() {
let mut app = new_app();
let mut path = std::env::temp_dir();
path.push(format!(
"pacsea_cache_{}_{}.json",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.expect("System time is before UNIX epoch")
.as_nanos()
));
app.cache_path = path.clone();
app.details_cache.insert(
"ripgrep".into(),
crate::state::PackageDetails {
name: "ripgrep".into(),
..Default::default()
},
);
app.cache_dirty = true;
maybe_flush_cache(&mut app);
assert!(!app.cache_dirty);
let body =
std::fs::read_to_string(&app.cache_path).expect("Failed to read test cache file");
assert!(body.contains("ripgrep"));
let _ = std::fs::remove_file(&app.cache_path);
}
#[test]
/// What: Verify `maybe_flush_recent` serialises the recent list and resets the dirty flag.
///
/// Inputs:
/// - `AppState` seeded with recent entries, temp path, and `recent_dirty = true`.
///
/// Output:
/// - JSON file includes both entries and `recent_dirty` becomes `false`.
///
/// Details:
/// - Cleans up the generated file to avoid cluttering the system temp directory.
fn flush_recent_writes_and_clears_flag() {
let mut app = new_app();
let mut path = std::env::temp_dir();
path.push(format!(
"pacsea_recent_{}_{}.json",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.expect("System time is before UNIX epoch")
.as_nanos()
));
app.recent_path = path.clone();
app.load_recent_items(&["rg".to_string(), "fd".to_string()]);
app.recent_dirty = true;
maybe_flush_recent(&mut app);
assert!(!app.recent_dirty);
let body =
std::fs::read_to_string(&app.recent_path).expect("Failed to read test recent file");
assert!(body.contains("rg") && body.contains("fd"));
let _ = std::fs::remove_file(&app.recent_path);
}
#[test]
/// What: Check `maybe_flush_install` throttles writes then persists once the timer elapses.
///
/// Inputs:
/// - `AppState` with `install_dirty = true`, a fresh package entry, and `last_install_change` set to now.
///
/// Output:
/// - First invocation avoids writing; after clearing the timestamp, the file appears with the package name.
///
/// Details:
/// - Simulates the passage of time by resetting `last_install_change` before invoking the helper again.
fn flush_install_throttle_and_write() {
let mut app = new_app();
let mut path = std::env::temp_dir();
path.push(format!(
"pacsea_install_{}_{}.json",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.expect("System time is before UNIX epoch")
.as_nanos()
));
app.install_path = path.clone();
app.install_list = vec![crate::state::PackageItem {
name: "rg".into(),
version: "1".into(),
description: String::new(),
source: crate::state::Source::Aur,
popularity: None,
out_of_date: None,
orphaned: false,
}];
app.install_dirty = true;
app.last_install_change = Some(std::time::Instant::now());
// First call should be throttled -> no file
maybe_flush_install(&mut app);
assert!(std::fs::read_to_string(&app.install_path).is_err());
// Simulate time passing by clearing last_install_change
app.last_install_change = None;
maybe_flush_install(&mut app);
let body =
std::fs::read_to_string(&app.install_path).expect("Failed to read test install file");
assert!(body.contains("rg"));
let _ = std::fs::remove_file(&app.install_path);
}
#[test]
/// What: Ensure `maybe_flush_deps_cache` persists dependency cache entries and clears the dirty flag.
///
/// Inputs:
/// - `AppState` with a populated install list, dependency data, and `deps_cache_dirty = true`.
///
/// Output:
/// - Cache file contains dependency information and the dirty flag is reset.
///
/// Details:
/// - Cleans up the temporary file to keep runs idempotent.
fn flush_deps_cache_writes_and_clears_flag() {
let mut app = new_app();
let mut path = std::env::temp_dir();
path.push(format!(
"pacsea_deps_cache_{}_{}.json",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.expect("System time is before UNIX epoch")
.as_nanos()
));
app.deps_cache_path = path.clone();
app.install_list = vec![PackageItem {
name: "ripgrep".into(),
version: "14.0.0".into(),
description: String::new(),
source: Source::Official {
repo: "extra".into(),
arch: "x86_64".into(),
},
popularity: None,
out_of_date: None,
orphaned: false,
}];
app.install_list_deps = vec![DependencyInfo {
name: "gcc-libs".into(),
version: ">=13".into(),
status: DependencyStatus::ToInstall,
source: DependencySource::Official {
repo: "core".into(),
},
required_by: vec!["ripgrep".into()],
depends_on: Vec::new(),
is_core: true,
is_system: false,
}];
app.deps_cache_dirty = true;
maybe_flush_deps_cache(&mut app);
assert!(!app.deps_cache_dirty);
let body = std::fs::read_to_string(&app.deps_cache_path)
.expect("Failed to read test deps cache file");
assert!(body.contains("gcc-libs"));
let _ = std::fs::remove_file(&app.deps_cache_path);
}
#[test]
/// What: Ensure `maybe_flush_deps_cache` writes an empty cache file when the install list is empty.
///
/// Inputs:
/// - `AppState` with an empty install list, existing cache file, and `deps_cache_dirty = true`.
///
/// Output:
/// - Cache file is replaced with an empty payload and the dirty flag is cleared.
///
/// Details:
/// - Simulates clearing the install list so persistence helper should clean up stale cache content.
fn flush_deps_cache_writes_empty_when_install_list_empty() {
let mut app = new_app();
let mut path = std::env::temp_dir();
path.push(format!(
"pacsea_deps_cache_remove_{}_{}.json",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.expect("System time is before UNIX epoch")
.as_nanos()
));
app.deps_cache_path = path.clone();
std::fs::write(&app.deps_cache_path, "stale")
.expect("Failed to write test deps cache file");
app.deps_cache_dirty = true;
app.install_list.clear();
maybe_flush_deps_cache(&mut app);
assert!(!app.deps_cache_dirty);
let body = std::fs::read_to_string(&app.deps_cache_path)
.expect("Failed to read test deps cache file");
let cache: crate::app::deps_cache::DependencyCache =
serde_json::from_str(&body).expect("Failed to parse dependency cache");
assert!(cache.install_list_signature.is_empty());
assert!(cache.dependencies.is_empty());
let _ = std::fs::remove_file(&app.deps_cache_path);
}
#[test]
/// What: Ensure `maybe_flush_files_cache` persists file change metadata and clears the dirty flag.
///
/// Inputs:
/// - `AppState` with a populated install list, file change data, and `files_cache_dirty = true`.
///
/// Output:
/// - Cache file contains file metadata and the dirty flag is reset.
///
/// Details:
/// - Removes the temporary cache file after assertions complete.
fn flush_files_cache_writes_and_clears_flag() {
let mut app = new_app();
let mut path = std::env::temp_dir();
path.push(format!(
"pacsea_files_cache_{}_{}.json",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.expect("System time is before UNIX epoch")
.as_nanos()
));
app.files_cache_path = path.clone();
app.install_list = vec![PackageItem {
name: "ripgrep".into(),
version: "14.0.0".into(),
description: String::new(),
source: Source::Aur,
popularity: None,
out_of_date: None,
orphaned: false,
}];
app.install_list_files = vec![PackageFileInfo {
name: "ripgrep".into(),
files: vec![FileChange {
path: "/usr/bin/rg".into(),
change_type: FileChangeType::New,
package: "ripgrep".into(),
is_config: false,
predicted_pacnew: false,
predicted_pacsave: false,
}],
total_count: 1,
new_count: 1,
changed_count: 0,
removed_count: 0,
config_count: 0,
pacnew_candidates: 0,
pacsave_candidates: 0,
}];
app.files_cache_dirty = true;
maybe_flush_files_cache(&mut app);
assert!(!app.files_cache_dirty);
let body = std::fs::read_to_string(&app.files_cache_path)
.expect("Failed to read test files cache file");
assert!(body.contains("/usr/bin/rg"));
let _ = std::fs::remove_file(&app.files_cache_path);
}
#[test]
/// What: Ensure `maybe_flush_files_cache` writes an empty cache file when the install list is empty.
///
/// Inputs:
/// - `AppState` with an empty install list, an on-disk cache file, and `files_cache_dirty = true`.
///
/// Output:
/// - Cache file is replaced with an empty payload and the dirty flag resets.
///
/// Details:
/// - Mirrors the behaviour when the user clears the install list to keep disk cache in sync.
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | true |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/app/deps_cache.rs | src/app/deps_cache.rs | //! Dependency cache persistence for install list dependencies.
use crate::state::modal::DependencyInfo;
use serde::{Deserialize, Serialize};
use std::fs;
use std::io::ErrorKind;
use std::path::PathBuf;
/// What: Cache blob combining install list signature with resolved dependency graph.
///
/// Details:
/// - `install_list_signature` stores sorted package names so cache survives reordering.
/// - `dependencies` mirrors the resolved dependency payload persisted on disk.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DependencyCache {
/// Sorted list of package names from install list (used as signature).
pub install_list_signature: Vec<String>,
/// Cached resolved dependencies.
pub dependencies: Vec<DependencyInfo>,
}
/// What: Generate a deterministic signature for an install list that ignores ordering.
///
/// Inputs:
/// - `packages`: Slice of install list entries used to derive package names.
///
/// Output:
/// - Sorted vector of package names that can be compared between cache reads and writes.
///
/// Details:
/// - Clones the package names and sorts them alphabetically to create an order-agnostic key.
pub fn compute_signature(packages: &[crate::state::PackageItem]) -> Vec<String> {
let mut names: Vec<String> = packages.iter().map(|p| p.name.clone()).collect();
names.sort();
names
}
/// What: Load dependency cache from disk when the stored signature matches the current list.
///
/// Inputs:
/// - `path`: Filesystem location of the serialized `DependencyCache` JSON.
/// - `current_signature`: Signature derived from the current install list for validation.
///
/// Output:
/// - `Some(Vec<DependencyInfo>)` when the cache exists, deserializes, and signatures match;
/// `None` otherwise.
///
/// Details:
/// - Reads the JSON, deserializes, sorts both signatures, and compares for equality before
/// returning the cached dependencies.
pub fn load_cache(path: &PathBuf, current_signature: &[String]) -> Option<Vec<DependencyInfo>> {
let raw = match fs::read_to_string(path) {
Ok(contents) => contents,
Err(e) if e.kind() == ErrorKind::NotFound => {
tracing::debug!(path = %path.display(), "[Cache] Dependency cache not found");
return None;
}
Err(e) => {
tracing::warn!(
path = %path.display(),
error = %e,
"[Cache] Failed to read dependency cache"
);
return None;
}
};
let cache: DependencyCache = match serde_json::from_str(&raw) {
Ok(cache) => cache,
Err(e) => {
tracing::warn!(
path = %path.display(),
error = %e,
"[Cache] Failed to parse dependency cache"
);
return None;
}
};
// Check if signature matches
let mut cached_sig = cache.install_list_signature.clone();
cached_sig.sort();
let mut current_sig = current_signature.to_vec();
current_sig.sort();
if cached_sig == current_sig {
tracing::info!(path = %path.display(), count = cache.dependencies.len(), "loaded dependency cache");
return Some(cache.dependencies);
}
tracing::debug!(path = %path.display(), "dependency cache signature mismatch, ignoring");
None
}
/// What: Persist dependency cache payload and signature to disk as JSON.
///
/// Inputs:
/// - `path`: Destination file for the serialized cache contents.
/// - `signature`: Current install list signature to write alongside the payload.
/// - `dependencies`: Resolved dependency details being cached.
///
/// Output:
/// - No return value; writes to disk best-effort and logs on success.
///
/// Details:
/// - Serializes the data to JSON, writes it to `path`, and emits a debug log including count.
pub fn save_cache(path: &PathBuf, signature: &[String], dependencies: &[DependencyInfo]) {
let cache = DependencyCache {
install_list_signature: signature.to_vec(),
dependencies: dependencies.to_vec(),
};
if let Ok(s) = serde_json::to_string(&cache) {
let _ = fs::write(path, s);
tracing::debug!(path = %path.display(), count = dependencies.len(), "saved dependency cache");
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::state::modal::{DependencyInfo, DependencySource, DependencyStatus};
use crate::state::{PackageItem, Source};
use std::fs;
use std::time::{SystemTime, UNIX_EPOCH};
fn temp_path(label: &str) -> std::path::PathBuf {
let mut path = std::env::temp_dir();
path.push(format!(
"pacsea_deps_cache_{label}_{}_{}.json",
std::process::id(),
SystemTime::now()
.duration_since(UNIX_EPOCH)
.expect("System time is before UNIX epoch")
.as_nanos()
));
path
}
fn sample_packages() -> Vec<PackageItem> {
vec![
PackageItem {
name: "ripgrep".into(),
version: "14.0.0".into(),
description: String::new(),
source: Source::Official {
repo: "extra".into(),
arch: "x86_64".into(),
},
popularity: None,
out_of_date: None,
orphaned: false,
},
PackageItem {
name: "fd".into(),
version: "9.0.0".into(),
description: String::new(),
source: Source::Aur,
popularity: Some(42.0),
out_of_date: None,
orphaned: false,
},
]
}
fn sample_dependencies() -> Vec<DependencyInfo> {
vec![DependencyInfo {
name: "gcc-libs".into(),
version: ">=13".into(),
status: DependencyStatus::ToInstall,
source: DependencySource::Official {
repo: "core".into(),
},
required_by: vec!["ripgrep".into()],
depends_on: Vec::new(),
is_core: true,
is_system: false,
}]
}
#[test]
/// What: Ensure `compute_signature` normalizes package name ordering.
/// Inputs:
/// - Install list cloned from the sample data but iterated in reverse.
///
/// Output:
/// - Signature equals `["fd", "ripgrep"]`.
fn compute_signature_orders_package_names() {
let mut packages = sample_packages();
packages.reverse();
let signature = compute_signature(&packages);
assert_eq!(signature, vec![String::from("fd"), String::from("ripgrep")]);
}
#[test]
/// What: Confirm `load_cache` rejects persisted caches whose signature does not match.
/// Inputs:
/// - Cache saved for `["fd", "ripgrep"]` but reloaded with signature `["ripgrep", "zellij"]`.
///
/// Output:
/// - `None`.
fn load_cache_rejects_signature_mismatch() {
let path = temp_path("mismatch");
let packages = sample_packages();
let signature = compute_signature(&packages);
let deps = sample_dependencies();
save_cache(&path, &signature, &deps);
let mismatched_signature = vec!["ripgrep".into(), "zellij".into()];
assert!(load_cache(&path, &mismatched_signature).is_none());
let _ = fs::remove_file(&path);
}
#[test]
/// What: Verify dependency payloads persist and reload unchanged.
/// Inputs:
/// - Disk round-trip for the sample dependency list using a matching signature.
///
/// Output:
/// - Reloaded dependency list matches the original, including status, source, and metadata.
fn save_and_load_cache_roundtrip() {
let path = temp_path("roundtrip");
let packages = sample_packages();
let signature = compute_signature(&packages);
let deps = sample_dependencies();
let expected = deps.clone();
save_cache(&path, &signature, &deps);
let reloaded = load_cache(&path, &signature).expect("expected cache to load");
assert_eq!(reloaded.len(), expected.len());
let dep = &reloaded[0];
let expected_dep = &expected[0];
assert_eq!(dep.name, expected_dep.name);
assert_eq!(dep.version, expected_dep.version);
assert!(matches!(dep.status, DependencyStatus::ToInstall));
assert!(matches!(
dep.source,
DependencySource::Official { ref repo } if repo == "core"
));
assert_eq!(dep.required_by, expected_dep.required_by);
assert_eq!(dep.depends_on, expected_dep.depends_on);
assert_eq!(dep.is_core, expected_dep.is_core);
assert_eq!(dep.is_system, expected_dep.is_system);
let _ = fs::remove_file(&path);
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/app/files_cache.rs | src/app/files_cache.rs | //! File cache persistence for install list file changes.
use crate::state::modal::PackageFileInfo;
use serde::{Deserialize, Serialize};
use std::fs;
use std::io::ErrorKind;
use std::path::PathBuf;
/// What: Cache blob combining install list signature with resolved file change metadata.
///
/// Details:
/// - `install_list_signature` mirrors package names used for cache validation.
/// - `files` preserves the last known file change data for reuse.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FileCache {
/// Sorted list of package names from install list (used as signature).
pub install_list_signature: Vec<String>,
/// Cached resolved file changes.
pub files: Vec<PackageFileInfo>,
}
/// What: Generate a deterministic signature for file cache comparisons.
///
/// Inputs:
/// - `packages`: Slice of install list entries contributing their package names.
///
/// Output:
/// - Sorted vector of package names that can be compared for cache validity checks.
///
/// Details:
/// - Clones each package name and sorts the collection alphabetically.
pub fn compute_signature(packages: &[crate::state::PackageItem]) -> Vec<String> {
let mut names: Vec<String> = packages.iter().map(|p| p.name.clone()).collect();
names.sort();
names
}
/// What: Load cached file change data when the stored signature matches the current list.
///
/// Inputs:
/// - `path`: Filesystem location of the serialized `FileCache` JSON.
/// - `current_signature`: Signature derived from the current install list for validation.
///
/// Output:
/// - `Some(Vec<PackageFileInfo>)` when the cache exists, deserializes, and signatures agree;
/// `None` otherwise.
///
/// Details:
/// - Reads the JSON, deserializes it, sorts both signatures, and compares them before
/// returning the cached file change data.
pub fn load_cache(path: &PathBuf, current_signature: &[String]) -> Option<Vec<PackageFileInfo>> {
load_cache_partial(path, current_signature, true)
}
/// What: Load cached file change data with partial matching support.
///
/// Inputs:
/// - `path`: Filesystem location of the serialized `FileCache` JSON.
/// - `current_signature`: Signature derived from the current selection for validation.
/// - `exact_match_only`: If true, only match when signatures are identical. If false, allow subset matching.
///
/// Output:
/// - `Some(Vec<PackageFileInfo>)` when the cache exists and matches (exact or partial);
/// `None` otherwise.
///
/// Details:
/// - If `exact_match_only` is false and the current signature is a subset of the cached signature,
/// filters the cached results to match the current selection.
pub fn load_cache_partial(
path: &PathBuf,
current_signature: &[String],
exact_match_only: bool,
) -> Option<Vec<PackageFileInfo>> {
let raw = match fs::read_to_string(path) {
Ok(contents) => contents,
Err(e) if e.kind() == ErrorKind::NotFound => {
tracing::debug!(path = %path.display(), "[Cache] File cache not found");
return None;
}
Err(e) => {
tracing::warn!(
path = %path.display(),
error = %e,
"[Cache] Failed to read file cache"
);
return None;
}
};
let cache: FileCache = match serde_json::from_str(&raw) {
Ok(cache) => cache,
Err(e) => {
tracing::warn!(
path = %path.display(),
error = %e,
"[Cache] Failed to parse file cache"
);
return None;
}
};
// Check if signature matches
let mut cached_sig = cache.install_list_signature.clone();
cached_sig.sort();
let mut current_sig = current_signature.to_vec();
current_sig.sort();
if cached_sig == current_sig {
tracing::info!(path = %path.display(), count = cache.files.len(), "loaded file cache (exact match)");
return Some(cache.files);
} else if !exact_match_only {
// Check if current signature is a subset of cached signature
let cached_set: std::collections::HashSet<&String> = cached_sig.iter().collect();
let current_set: std::collections::HashSet<&String> = current_sig.iter().collect();
if current_set.is_subset(&cached_set) {
// Filter cached results to match current selection
let current_names: std::collections::HashSet<&str> = current_sig
.iter()
.map(std::string::String::as_str)
.collect();
let filtered: Vec<PackageFileInfo> = cache
.files
.iter()
.filter(|file_info| current_names.contains(file_info.name.as_str()))
.cloned()
.collect();
if !filtered.is_empty() {
tracing::info!(
path = %path.display(),
cached_count = cache.files.len(),
filtered_count = filtered.len(),
"loaded file cache (partial match)"
);
return Some(filtered);
}
}
}
tracing::debug!(path = %path.display(), "file cache signature mismatch, ignoring");
None
}
/// What: Persist file change cache payload and signature to disk as JSON.
///
/// Inputs:
/// - `path`: Destination file for the serialized cache contents.
/// - `signature`: Current install list signature to store alongside the payload.
/// - `files`: File change metadata being cached.
///
/// Output:
/// - No return value; writes to disk best-effort and logs a debug message when successful.
///
/// Details:
/// - Serializes the data to JSON, writes it to `path`, and includes the record count in logs.
pub fn save_cache(path: &PathBuf, signature: &[String], files: &[PackageFileInfo]) {
let cache = FileCache {
install_list_signature: signature.to_vec(),
files: files.to_vec(),
};
if let Ok(s) = serde_json::to_string(&cache) {
let _ = fs::write(path, s);
tracing::debug!(path = %path.display(), count = files.len(), "saved file cache");
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::state::modal::{FileChange, FileChangeType, PackageFileInfo};
use crate::state::{PackageItem, Source};
use std::fs;
use std::time::{SystemTime, UNIX_EPOCH};
fn temp_path(label: &str) -> std::path::PathBuf {
let mut path = std::env::temp_dir();
path.push(format!(
"pacsea_files_cache_{label}_{}_{}.json",
std::process::id(),
SystemTime::now()
.duration_since(UNIX_EPOCH)
.expect("System time is before UNIX epoch")
.as_nanos()
));
path
}
fn sample_packages() -> Vec<PackageItem> {
vec![
PackageItem {
name: "ripgrep".into(),
version: "14.0.0".into(),
description: String::new(),
source: Source::Official {
repo: "extra".into(),
arch: "x86_64".into(),
},
popularity: None,
out_of_date: None,
orphaned: false,
},
PackageItem {
name: "fd".into(),
version: "9.0.0".into(),
description: String::new(),
source: Source::Aur,
popularity: Some(42.0),
out_of_date: None,
orphaned: false,
},
]
}
fn sample_file_infos() -> Vec<PackageFileInfo> {
vec![PackageFileInfo {
name: "ripgrep".into(),
files: vec![FileChange {
path: "/usr/bin/rg".into(),
change_type: FileChangeType::New,
package: "ripgrep".into(),
is_config: false,
predicted_pacnew: false,
predicted_pacsave: false,
}],
total_count: 1,
new_count: 1,
changed_count: 0,
removed_count: 0,
config_count: 0,
pacnew_candidates: 0,
pacsave_candidates: 0,
}]
}
#[test]
/// What: Ensure `compute_signature` normalizes package name ordering.
/// Inputs:
/// - Install list cloned from the sample data but iterated in reverse.
///
/// Output:
/// - Signature equals `["fd", "ripgrep"]`.
fn compute_signature_orders_package_names() {
let mut packages = sample_packages();
packages.reverse();
let signature = compute_signature(&packages);
assert_eq!(signature, vec![String::from("fd"), String::from("ripgrep")]);
}
#[test]
/// What: Confirm `load_cache` rejects persisted caches whose signature does not match.
/// Inputs:
/// - Cache saved for `["fd", "ripgrep"]` but reloaded with signature `["ripgrep", "zellij"]`.
///
/// Output:
/// - `None`.
fn load_cache_rejects_signature_mismatch() {
let path = temp_path("mismatch");
let packages = sample_packages();
let signature = compute_signature(&packages);
let file_infos = sample_file_infos();
save_cache(&path, &signature, &file_infos);
let mismatched_signature = vec!["ripgrep".into(), "zellij".into()];
assert!(load_cache(&path, &mismatched_signature).is_none());
let _ = fs::remove_file(&path);
}
#[test]
/// What: Verify cached file metadata survives a save/load round trip.
/// Inputs:
/// - Sample `ripgrep` file info written to disk and reloaded with matching signature.
///
/// Output:
/// - Reloaded metadata matches the original counts and file entries.
fn save_and_load_cache_roundtrip() {
let path = temp_path("roundtrip");
let packages = sample_packages();
let signature = compute_signature(&packages);
let file_infos = sample_file_infos();
save_cache(&path, &signature, &file_infos);
let reloaded = load_cache(&path, &signature).expect("expected cache to load");
assert_eq!(reloaded.len(), file_infos.len());
assert_eq!(reloaded[0].name, file_infos[0].name);
assert_eq!(reloaded[0].files.len(), file_infos[0].files.len());
assert_eq!(reloaded[0].total_count, file_infos[0].total_count);
assert_eq!(reloaded[0].new_count, file_infos[0].new_count);
let _ = fs::remove_file(&path);
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/app/terminal.rs | src/app/terminal.rs | use crossterm::{
event::{DisableMouseCapture, EnableMouseCapture},
execute,
terminal::{EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode},
};
/// Result type alias for terminal operations.
type Result<T> = std::result::Result<T, Box<dyn std::error::Error + Send + Sync>>;
/// What: Enter raw mode and switch to the alternate screen with mouse capture enabled.
///
/// Inputs:
/// - None
///
/// Output:
/// - `Ok(())` if the terminal was prepared; `Err` on I/O or terminal backend failure.
pub fn setup_terminal() -> Result<()> {
if std::env::var("PACSEA_TEST_HEADLESS").ok().as_deref() == Some("1") {
// Skip raw TTY setup in headless/test mode
// Explicitly disable mouse reporting to prevent mouse position escape sequences
// from appearing in test output when mouse moves over terminal
let _ = execute!(std::io::stdout(), DisableMouseCapture);
return Ok(());
}
enable_raw_mode()?;
execute!(std::io::stdout(), EnterAlternateScreen, EnableMouseCapture)?;
Ok(())
}
/// What: Restore terminal to normal mode, leave the alternate screen, and disable mouse capture.
///
/// Inputs:
/// - None
///
/// Output:
/// - `Ok(())` when restoration succeeds; `Err` if underlying terminal operations fail.
pub fn restore_terminal() -> Result<()> {
if std::env::var("PACSEA_TEST_HEADLESS").ok().as_deref() == Some("1") {
// Skip terminal restore in headless/test mode
return Ok(());
}
disable_raw_mode()?;
execute!(std::io::stdout(), DisableMouseCapture, LeaveAlternateScreen)?;
Ok(())
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/app/mod.rs | src/app/mod.rs | //! Pacsea application module (split from a single large file into submodules).
//!
//! This module organizes the TUI runtime into smaller files to improve
//! maintainability and keep individual files under 500 lines.
/// Dependency cache for storing resolved dependency information.
mod deps_cache;
/// File cache for storing package file information.
mod files_cache;
/// Persistence layer for saving and loading application state.
mod persist;
/// Recent queries and history management.
mod recent;
/// Runtime event loop and background workers.
mod runtime;
pub mod sandbox_cache;
pub mod services_cache;
/// Terminal setup and restoration utilities.
mod terminal;
// Re-export the public entrypoint so callers keep using `app::run(...)`.
pub use runtime::run;
// Re-export functions needed by event handlers
pub use runtime::init::{apply_settings_to_app_state, initialize_locale_system};
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/app/sandbox_cache.rs | src/app/sandbox_cache.rs | //! Sandbox cache persistence for install list sandbox analysis.
use crate::logic::sandbox::SandboxInfo;
use serde::{Deserialize, Serialize};
use std::fs;
use std::io::ErrorKind;
use std::path::PathBuf;
/// What: Cache blob combining install list signature with resolved sandbox metadata.
///
/// Details:
/// - `install_list_signature` mirrors package names used for cache validation.
/// - `sandbox_info` preserves the last known sandbox analysis data for reuse.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SandboxCache {
/// Sorted list of package names from install list (used as signature).
pub install_list_signature: Vec<String>,
/// Cached resolved sandbox information.
pub sandbox_info: Vec<SandboxInfo>,
}
/// What: Generate a deterministic signature for sandbox cache comparisons.
///
/// Inputs:
/// - `packages`: Slice of install list entries contributing their package names.
///
/// Output:
/// - Sorted vector of package names that can be compared for cache validity checks.
///
/// Details:
/// - Clones each package name and sorts the collection alphabetically.
#[must_use]
pub fn compute_signature(packages: &[crate::state::PackageItem]) -> Vec<String> {
let mut names: Vec<String> = packages.iter().map(|p| p.name.clone()).collect();
names.sort();
names
}
/// What: Load cached sandbox data when the stored signature matches the current list.
///
/// Inputs:
/// - `path`: Filesystem location of the serialized `SandboxCache` JSON.
/// - `current_signature`: Signature derived from the current install list for validation.
///
/// Output:
/// - `Some(Vec<SandboxInfo>)` when the cache exists, deserializes, and signatures agree;
/// `None` otherwise.
///
/// Details:
/// - Reads the JSON, deserializes it, sorts both signatures, and compares them before
/// returning the cached sandbox data.
/// - Uses partial matching to load entries for packages that exist in both cache and current list.
#[must_use]
pub fn load_cache(path: &PathBuf, current_signature: &[String]) -> Option<Vec<SandboxInfo>> {
load_cache_partial(path, current_signature, false)
}
/// What: Load cached sandbox data with partial matching support.
///
/// Inputs:
/// - `path`: Filesystem location of the serialized `SandboxCache` JSON.
/// - `current_signature`: Signature derived from the current install list for validation.
/// - `exact_match_only`: If true, only match when signatures are identical. If false, allow partial matching.
///
/// Output:
/// - `Some(Vec<SandboxInfo>)` when the cache exists and matches (exact or partial);
/// `None` otherwise.
///
/// Details:
/// - If `exact_match_only` is false, loads entries for packages that exist in both
/// the cached signature and the current signature (intersection matching).
/// - This allows preserving sandbox data when packages are added to the install list.
pub fn load_cache_partial(
path: &PathBuf,
current_signature: &[String],
exact_match_only: bool,
) -> Option<Vec<SandboxInfo>> {
let raw = match fs::read_to_string(path) {
Ok(contents) => contents,
Err(e) if e.kind() == ErrorKind::NotFound => {
tracing::debug!(path = %path.display(), "[Cache] Sandbox cache not found");
return None;
}
Err(e) => {
tracing::warn!(
path = %path.display(),
error = %e,
"[Cache] Failed to read sandbox cache"
);
return None;
}
};
let cache: SandboxCache = match serde_json::from_str(&raw) {
Ok(cache) => cache,
Err(e) => {
tracing::warn!(
path = %path.display(),
error = %e,
"[Cache] Failed to parse sandbox cache"
);
return None;
}
};
// Check if signature matches exactly
let mut cached_sig = cache.install_list_signature.clone();
cached_sig.sort();
let mut current_sig = current_signature.to_vec();
current_sig.sort();
if cached_sig == current_sig {
tracing::info!(
path = %path.display(),
count = cache.sandbox_info.len(),
"loaded sandbox cache (exact match)"
);
return Some(cache.sandbox_info);
} else if !exact_match_only {
// Partial matching: load entries for packages that exist in both signatures
let cached_set: std::collections::HashSet<&String> = cached_sig.iter().collect();
let current_set: std::collections::HashSet<&String> = current_sig.iter().collect();
// Find intersection: packages that exist in both cache and current list
let intersection: std::collections::HashSet<&String> =
cached_set.intersection(¤t_set).copied().collect();
if !intersection.is_empty() {
// Filter cached results to match packages in intersection
let intersection_names: std::collections::HashSet<&str> =
intersection.iter().map(|s| s.as_str()).collect();
let filtered: Vec<SandboxInfo> = cache
.sandbox_info
.iter()
.filter(|sandbox_info| {
intersection_names.contains(sandbox_info.package_name.as_str())
})
.cloned()
.collect();
if !filtered.is_empty() {
tracing::info!(
path = %path.display(),
cached_count = cache.sandbox_info.len(),
filtered_count = filtered.len(),
intersection_packages = ?intersection.iter().map(|s| s.as_str()).collect::<Vec<_>>(),
"loaded sandbox cache (partial match)"
);
return Some(filtered);
}
}
}
tracing::debug!(
path = %path.display(),
"sandbox cache signature mismatch, ignoring"
);
None
}
/// What: Persist sandbox cache payload and signature to disk as JSON.
///
/// Inputs:
/// - `path`: Destination file for the serialized cache contents.
/// - `signature`: Current install list signature to store alongside the payload.
/// - `sandbox_info`: Sandbox analysis metadata being cached.
///
/// Output:
/// - No return value; writes to disk best-effort and logs a debug message when successful.
///
/// Details:
/// - Serializes the data to JSON, writes it to `path`, and includes the record count in logs.
pub fn save_cache(path: &PathBuf, signature: &[String], sandbox_info: &[SandboxInfo]) {
let cache = SandboxCache {
install_list_signature: signature.to_vec(),
sandbox_info: sandbox_info.to_vec(),
};
if let Ok(s) = serde_json::to_string(&cache) {
let _ = fs::write(path, s);
tracing::debug!(
path = %path.display(),
count = sandbox_info.len(),
"saved sandbox cache"
);
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::logic::sandbox::{DependencyDelta, SandboxInfo};
use crate::state::{PackageItem, Source};
use std::fs;
use std::time::{SystemTime, UNIX_EPOCH};
fn temp_path(label: &str) -> std::path::PathBuf {
let mut path = std::env::temp_dir();
path.push(format!(
"pacsea_sandbox_cache_{label}_{}_{}.json",
std::process::id(),
SystemTime::now()
.duration_since(UNIX_EPOCH)
.expect("System time is before UNIX epoch")
.as_nanos()
));
path
}
fn sample_packages() -> Vec<PackageItem> {
vec![PackageItem {
name: "yay".into(),
version: "12.0.0".into(),
description: String::new(),
source: Source::Aur,
popularity: None,
out_of_date: None,
orphaned: false,
}]
}
fn sample_sandbox_info() -> Vec<SandboxInfo> {
vec![SandboxInfo {
package_name: "yay".into(),
depends: vec![DependencyDelta {
name: "go".into(),
is_installed: true,
installed_version: Some("1.21.0".into()),
version_satisfied: true,
}],
makedepends: vec![],
checkdepends: vec![],
optdepends: vec![],
}]
}
#[test]
/// What: Ensure `compute_signature` normalizes package name ordering.
/// Inputs:
/// - Install list cloned from the sample data but iterated in reverse.
///
/// Output:
/// - Signature equals `["yay"]`.
fn compute_signature_orders_package_names() {
let mut packages = sample_packages();
packages.reverse();
let signature = compute_signature(&packages);
assert_eq!(signature, vec![String::from("yay")]);
}
#[test]
/// What: Confirm `load_cache` rejects persisted caches whose signature does not match.
/// Inputs:
/// - Cache saved for `["yay"]` but reloaded with signature `["paru"]`.
///
/// Output:
/// - `None`.
fn load_cache_rejects_signature_mismatch() {
let path = temp_path("mismatch");
let packages = sample_packages();
let signature = compute_signature(&packages);
let sandbox_info = sample_sandbox_info();
save_cache(&path, &signature, &sandbox_info);
let mismatched_signature = vec!["paru".into()];
assert!(load_cache(&path, &mismatched_signature).is_none());
let _ = fs::remove_file(&path);
}
#[test]
/// What: Verify cached sandbox metadata survives a save/load round trip.
/// Inputs:
/// - Sample `yay` sandbox info written to disk and reloaded with matching signature.
///
/// Output:
/// - Reloaded metadata matches the original package name and properties.
fn save_and_load_cache_roundtrip() {
let path = temp_path("roundtrip");
let packages = sample_packages();
let signature = compute_signature(&packages);
let sandbox_info = sample_sandbox_info();
save_cache(&path, &signature, &sandbox_info);
let reloaded = load_cache(&path, &signature).expect("expected cache to load");
assert_eq!(reloaded.len(), sandbox_info.len());
assert_eq!(reloaded[0].package_name, sandbox_info[0].package_name);
assert_eq!(reloaded[0].depends.len(), sandbox_info[0].depends.len());
let _ = fs::remove_file(&path);
}
#[test]
/// What: Verify partial cache loading preserves entries when new packages are added.
/// Inputs:
/// - Cache saved for `["jujutsu-git"]` but reloaded with signature `["jujutsu-git", "pacsea-bin"]`.
///
/// Output:
/// - Returns `Some(Vec<SandboxInfo>)` containing only `jujutsu-git` entry (partial match).
fn load_cache_partial_match() {
let path = temp_path("partial");
let jujutsu_sandbox = SandboxInfo {
package_name: "jujutsu-git".into(),
depends: vec![DependencyDelta {
name: "python".into(),
is_installed: true,
installed_version: Some("3.11.0".into()),
version_satisfied: true,
}],
makedepends: vec![],
checkdepends: vec![],
optdepends: vec![],
};
let signature = vec!["jujutsu-git".into()];
save_cache(&path, &signature, std::slice::from_ref(&jujutsu_sandbox));
// Try to load with expanded signature (new package added)
let expanded_signature = vec!["jujutsu-git".into(), "pacsea-bin".into()];
let reloaded =
load_cache(&path, &expanded_signature).expect("expected partial cache to load");
assert_eq!(reloaded.len(), 1);
assert_eq!(reloaded[0].package_name, "jujutsu-git");
assert_eq!(reloaded[0].depends.len(), 1);
assert_eq!(reloaded[0].depends[0].name, "python");
let _ = fs::remove_file(&path);
}
#[test]
/// What: Verify partial cache loading returns None when no packages overlap.
/// Inputs:
/// - Cache saved for `["jujutsu-git"]` but reloaded with signature `["pacsea-bin"]`.
///
/// Output:
/// - Returns `None` (no overlap).
fn load_cache_partial_no_overlap() {
let path = temp_path("no_overlap");
let jujutsu_sandbox = sample_sandbox_info();
let signature = vec!["jujutsu-git".into()];
save_cache(&path, &signature, &jujutsu_sandbox);
let different_signature = vec!["pacsea-bin".into()];
assert!(load_cache(&path, &different_signature).is_none());
let _ = fs::remove_file(&path);
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/app/recent.rs | src/app/recent.rs | use std::time::{Duration, Instant};
use crate::state::AppState;
use crate::state::app_state::recent_capacity;
/// What: Debounced persistence of the current search input into the Recent list.
///
/// Inputs:
/// - `app`: Mutable application state providing the input text and timing markers
///
/// Output:
/// - Updates `recent` (deduped, clamped to 20), sets `recent_dirty`, and records last-saved value
/// when conditions are met (non-empty, past debounce window, changed since last save).
pub fn maybe_save_recent(app: &mut AppState) {
let now = Instant::now();
if app.input.trim().is_empty() {
return;
}
if now.duration_since(app.last_input_change) < Duration::from_secs(2) {
return;
}
if app.last_saved_value.as_deref() == Some(app.input.trim()) {
return;
}
let value = app.input.trim().to_string();
let key = value.to_ascii_lowercase();
app.recent.resize(recent_capacity());
app.recent.put(key, value.clone());
app.last_saved_value = Some(value);
app.recent_dirty = true;
}
/// What: Debounced persistence of the current news search input into the news Recent list.
///
/// Inputs:
/// - `app`: Mutable application state providing news search text and timing markers
///
/// Output:
/// - Updates `news_recent` (deduped, clamped to capacity), sets `news_recent_dirty`, and records
/// last-saved value when conditions are met (non-empty, past debounce window, changed since last save).
pub fn maybe_save_news_recent(app: &mut AppState) {
if !matches!(app.app_mode, crate::state::types::AppMode::News) {
return;
}
let now = Instant::now();
let query = app.news_search_input.trim();
if query.is_empty() {
app.news_history_pending = None;
app.news_history_pending_at = None;
return;
}
// Track pending value and debounce start
app.news_history_pending = Some(query.to_string());
app.news_history_pending_at = Some(now);
// Enforce 2s debounce from the last input change
if now.duration_since(app.last_input_change) < Duration::from_secs(2) {
return;
}
// Avoid duplicate save of the same value
if app.news_history_last_saved.as_deref() == Some(query) {
return;
}
let value = query.to_string();
let key = value.to_ascii_lowercase();
app.news_recent.resize(recent_capacity());
app.news_recent.put(key, value.clone());
app.news_history_last_saved = Some(value);
app.news_recent_dirty = true;
}
#[cfg(test)]
mod tests {
use super::*;
fn new_app() -> AppState {
AppState::default()
}
fn recent_values(app: &AppState) -> Vec<String> {
app.recent.iter().map(|(_, v)| v.clone()).collect()
}
#[test]
/// What: Ensure recent-save logic respects emptiness, debounce timing, and change detection.
///
/// Inputs:
/// - Sequence of states: empty input, under-debounce input, unchanged value, and new value beyond debounce.
///
/// Output:
/// - First three scenarios avoid saving; final scenario inserts the new value at the front and marks the list dirty.
///
/// Details:
/// - Mimics user typing delays to guarantee the helper only persists meaningful changes.
fn maybe_save_recent_rules() {
let mut app = new_app();
// 1) Empty input -> no save
app.input.clear();
maybe_save_recent(&mut app);
assert!(app.recent.is_empty());
// 2) Under debounce window -> no save
app.input = "ripgrep".into();
app.last_input_change = std::time::Instant::now();
maybe_save_recent(&mut app);
assert!(app.recent.is_empty());
// 3) Same value as last_saved_value -> no save
app.last_input_change = std::time::Instant::now()
.checked_sub(std::time::Duration::from_secs(3))
.unwrap_or_else(std::time::Instant::now);
app.last_saved_value = Some("ripgrep".into());
maybe_save_recent(&mut app);
assert!(app.recent.is_empty());
// 4) New value beyond debounce -> saved at front, deduped, clamped
app.input = "fd".into();
app.last_saved_value = Some("ripgrep".into());
app.last_input_change = std::time::Instant::now()
.checked_sub(std::time::Duration::from_secs(3))
.unwrap_or_else(std::time::Instant::now);
maybe_save_recent(&mut app);
assert_eq!(recent_values(&app).first().map(String::as_str), Some("fd"));
assert!(app.recent_dirty);
}
#[test]
/// What: Confirm existing case-insensitive matches move to the front without duplication.
///
/// Inputs:
/// - Recent list containing `"RipGrep"` and input `"ripgrep"` beyond the debounce window.
///
/// Output:
/// - Recent list collapses to one entry `"ripgrep"`.
///
/// Details:
/// - Protects the dedupe branch that removes stale duplicates before inserting the new value.
fn recent_dedup_case_insensitive() {
let mut app = new_app();
app.recent.put("ripgrep".into(), "RipGrep".into());
app.input = "ripgrep".into();
app.last_input_change = std::time::Instant::now()
.checked_sub(std::time::Duration::from_secs(3))
.unwrap_or_else(std::time::Instant::now);
maybe_save_recent(&mut app);
let recents = recent_values(&app);
assert_eq!(recents.len(), 1);
assert_eq!(recents[0], "ripgrep");
}
#[test]
/// What: Confirm recent cache evicts least-recent entries while keeping newest first.
///
/// Inputs:
/// - Sequence of unique inputs exceeding the configured recent capacity.
///
/// Output:
/// - Cache length equals capacity; newest entry sits at the front; oldest entries are evicted.
///
/// Details:
/// - Advances the debounce timer for each iteration to permit saves.
fn recent_eviction_respects_capacity() {
let mut app = new_app();
let cap = recent_capacity().get();
for i in 0..(cap + 2) {
app.input = format!("pkg{i}");
app.last_input_change = std::time::Instant::now()
.checked_sub(std::time::Duration::from_secs(3))
.unwrap_or_else(std::time::Instant::now);
maybe_save_recent(&mut app);
}
let recents = recent_values(&app);
assert_eq!(recents.len(), cap);
let newest = format!("pkg{}", cap + 1);
assert_eq!(recents.first().map(String::as_str), Some(newest.as_str()));
assert!(
recents
.iter()
.all(|entry| entry != "pkg0" && entry != "pkg1")
);
}
#[test]
/// What: Ensure news recent save is debounced and uses news search input.
fn news_recent_respects_debounce_and_changes() {
let mut app = new_app();
app.app_mode = crate::state::types::AppMode::News;
app.news_recent.clear();
// Under debounce: should not save
app.news_search_input = "arch".into();
app.last_input_change = Instant::now();
maybe_save_news_recent(&mut app);
assert!(app.news_recent.is_empty());
// Beyond debounce: should save
app.last_input_change = Instant::now()
.checked_sub(Duration::from_secs(3))
.unwrap_or_else(Instant::now);
maybe_save_news_recent(&mut app);
let recents: Vec<String> = app.news_recent.iter().map(|(_, v)| v.clone()).collect();
assert_eq!(recents.first().map(String::as_str), Some("arch"));
assert_eq!(app.news_history_last_saved.as_deref(), Some("arch"));
assert!(app.news_recent_dirty);
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/app/services_cache.rs | src/app/services_cache.rs | //! Service cache persistence for install list service impacts.
use crate::state::modal::ServiceImpact;
use serde::{Deserialize, Serialize};
use std::fs;
use std::io::ErrorKind;
use std::path::PathBuf;
/// What: Cache blob combining install list signature with resolved service impact metadata.
///
/// Details:
/// - `install_list_signature` mirrors package names used for cache validation.
/// - `services` preserves the last known service impact data for reuse.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ServiceCache {
/// Sorted list of package names from install list (used as signature).
pub install_list_signature: Vec<String>,
/// Cached resolved service impacts.
pub services: Vec<ServiceImpact>,
}
/// What: Generate a deterministic signature for service cache comparisons.
///
/// Inputs:
/// - `packages`: Slice of install list entries contributing their package names.
///
/// Output:
/// - Sorted vector of package names that can be compared for cache validity checks.
///
/// Details:
/// - Clones each package name and sorts the collection alphabetically.
#[must_use]
pub fn compute_signature(packages: &[crate::state::PackageItem]) -> Vec<String> {
let mut names: Vec<String> = packages.iter().map(|p| p.name.clone()).collect();
names.sort();
names
}
/// What: Load cached service impact data when the stored signature matches the current list.
///
/// Inputs:
/// - `path`: Filesystem location of the serialized `ServiceCache` JSON.
/// - `current_signature`: Signature derived from the current install list for validation.
///
/// Output:
/// - `Some(Vec<ServiceImpact>)` when the cache exists, deserializes, and signatures agree;
/// `None` otherwise.
///
/// Details:
/// - Reads the JSON, deserializes it, sorts both signatures, and compares them before
/// returning the cached service impact data.
pub fn load_cache(path: &PathBuf, current_signature: &[String]) -> Option<Vec<ServiceImpact>> {
let raw = match fs::read_to_string(path) {
Ok(contents) => contents,
Err(e) if e.kind() == ErrorKind::NotFound => {
tracing::debug!(path = %path.display(), "[Cache] Service cache not found");
return None;
}
Err(e) => {
tracing::warn!(
path = %path.display(),
error = %e,
"[Cache] Failed to read service cache"
);
return None;
}
};
let cache: ServiceCache = match serde_json::from_str(&raw) {
Ok(cache) => cache,
Err(e) => {
tracing::warn!(
path = %path.display(),
error = %e,
"[Cache] Failed to parse service cache"
);
return None;
}
};
// Check if signature matches
let mut cached_sig = cache.install_list_signature.clone();
cached_sig.sort();
let mut current_sig = current_signature.to_vec();
current_sig.sort();
if cached_sig == current_sig {
tracing::info!(path = %path.display(), count = cache.services.len(), "loaded service cache");
return Some(cache.services);
}
tracing::debug!(path = %path.display(), "service cache signature mismatch, ignoring");
None
}
/// What: Persist service impact cache payload and signature to disk as JSON.
///
/// Inputs:
/// - `path`: Destination file for the serialized cache contents.
/// - `signature`: Current install list signature to store alongside the payload.
/// - `services`: Service impact metadata being cached.
///
/// Output:
/// - No return value; writes to disk best-effort and logs a debug message when successful.
///
/// Details:
/// - Serializes the data to JSON, writes it to `path`, and includes the record count in logs.
pub fn save_cache(path: &PathBuf, signature: &[String], services: &[ServiceImpact]) {
let cache = ServiceCache {
install_list_signature: signature.to_vec(),
services: services.to_vec(),
};
if let Ok(s) = serde_json::to_string(&cache) {
let _ = fs::write(path, s);
tracing::debug!(path = %path.display(), count = services.len(), "saved service cache");
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::state::modal::{ServiceImpact, ServiceRestartDecision};
use crate::state::{PackageItem, Source};
use std::fs;
use std::time::{SystemTime, UNIX_EPOCH};
fn temp_path(label: &str) -> std::path::PathBuf {
let mut path = std::env::temp_dir();
path.push(format!(
"pacsea_services_cache_{label}_{}_{}.json",
std::process::id(),
SystemTime::now()
.duration_since(UNIX_EPOCH)
.expect("System time is before UNIX epoch")
.as_nanos()
));
path
}
fn sample_packages() -> Vec<PackageItem> {
vec![
PackageItem {
name: "sshd".into(),
version: "9.0.0".into(),
description: String::new(),
source: Source::Official {
repo: "core".into(),
arch: "x86_64".into(),
},
popularity: None,
out_of_date: None,
orphaned: false,
},
PackageItem {
name: "nginx".into(),
version: "1.24.0".into(),
description: String::new(),
source: Source::Official {
repo: "extra".into(),
arch: "x86_64".into(),
},
popularity: None,
out_of_date: None,
orphaned: false,
},
]
}
fn sample_services() -> Vec<ServiceImpact> {
vec![ServiceImpact {
unit_name: "sshd.service".into(),
providers: vec!["sshd".into()],
is_active: true,
needs_restart: true,
recommended_decision: ServiceRestartDecision::Restart,
restart_decision: ServiceRestartDecision::Restart,
}]
}
#[test]
/// What: Ensure `compute_signature` normalizes package name ordering.
/// Inputs:
/// - Install list cloned from the sample data but iterated in reverse.
///
/// Output:
/// - Signature equals `["nginx", "sshd"]`.
fn compute_signature_orders_package_names() {
let mut packages = sample_packages();
packages.reverse();
let signature = compute_signature(&packages);
assert_eq!(signature, vec![String::from("nginx"), String::from("sshd")]);
}
#[test]
/// What: Confirm `load_cache` rejects persisted caches whose signature does not match.
/// Inputs:
/// - Cache saved for `["nginx", "sshd"]` but reloaded with signature `["sshd", "httpd"]`.
///
/// Output:
/// - `None`.
fn load_cache_rejects_signature_mismatch() {
let path = temp_path("mismatch");
let packages = sample_packages();
let signature = compute_signature(&packages);
let services = sample_services();
save_cache(&path, &signature, &services);
let mismatched_signature = vec!["sshd".into(), "httpd".into()];
assert!(load_cache(&path, &mismatched_signature).is_none());
let _ = fs::remove_file(&path);
}
#[test]
/// What: Verify cached service metadata survives a save/load round trip.
/// Inputs:
/// - Sample `sshd.service` impact written to disk and reloaded with matching signature.
///
/// Output:
/// - Reloaded metadata matches the original unit name and properties.
fn save_and_load_cache_roundtrip() {
let path = temp_path("roundtrip");
let packages = sample_packages();
let signature = compute_signature(&packages);
let services = sample_services();
save_cache(&path, &signature, &services);
let reloaded = load_cache(&path, &signature).expect("expected cache to load");
assert_eq!(reloaded.len(), services.len());
assert_eq!(reloaded[0].unit_name, services[0].unit_name);
assert_eq!(reloaded[0].providers, services[0].providers);
assert_eq!(reloaded[0].is_active, services[0].is_active);
assert_eq!(reloaded[0].needs_restart, services[0].needs_restart);
let _ = fs::remove_file(&path);
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/app/runtime/tick_handler.rs | src/app/runtime/tick_handler.rs | use std::fmt::Write;
use std::time::Instant;
use tokio::sync::mpsc;
use tokio::time::Duration;
use crate::logic::send_query;
use crate::state::{AppState, ArchStatusColor, PackageItem, QueryInput};
use super::super::persist::{
maybe_flush_announcement_read, maybe_flush_cache, maybe_flush_deps_cache,
maybe_flush_files_cache, maybe_flush_install, maybe_flush_news_bookmarks,
maybe_flush_news_content_cache, maybe_flush_news_read, maybe_flush_news_read_ids,
maybe_flush_news_recent, maybe_flush_news_seen_aur_comments, maybe_flush_news_seen_versions,
maybe_flush_pkgbuild_parse_cache, maybe_flush_recent, maybe_flush_sandbox_cache,
maybe_flush_services_cache,
};
use super::super::recent::{maybe_save_news_recent, maybe_save_recent};
/// What: Handle PKGBUILD result event.
///
/// Inputs:
/// - `app`: Application state
/// - `pkgname`: Package name
/// - `text`: PKGBUILD text
/// - `tick_tx`: Channel sender for tick events
///
/// Details:
/// - Updates PKGBUILD text if still focused on the same package
/// - Clears pending reload request
pub fn handle_pkgbuild_result(
app: &mut AppState,
pkgname: String,
text: String,
tick_tx: &mpsc::UnboundedSender<()>,
) {
if app.details_focus.as_deref() == Some(pkgname.as_str())
|| app.results.get(app.selected).map(|i| i.name.as_str()) == Some(pkgname.as_str())
{
app.pkgb_text = Some(text);
app.pkgb_package_name = Some(pkgname);
// Clear any pending debounce request since we've successfully loaded
app.pkgb_reload_requested_at = None;
app.pkgb_reload_requested_for = None;
}
let _ = tick_tx.send(());
}
/// What: Handle comments result event.
///
/// Inputs:
/// - `app`: Application state
/// - `pkgname`: Package name
/// - `result`: Comments result (Ok with comments or Err with error message)
/// - `tick_tx`: Channel sender for tick events
///
/// Details:
/// - Updates comments if still focused on the same package
/// - Sets loading state to false and error state if applicable
pub fn handle_comments_result(
app: &mut AppState,
pkgname: String,
result: Result<Vec<crate::state::types::AurComment>, String>,
tick_tx: &mpsc::UnboundedSender<()>,
) {
if app.details_focus.as_deref() == Some(pkgname.as_str())
|| app.results.get(app.selected).map(|i| i.name.as_str()) == Some(pkgname.as_str())
{
app.comments_loading = false;
match result {
Ok(comments) => {
app.comments = comments;
app.comments_package_name = Some(pkgname);
app.comments_fetched_at = Some(Instant::now());
app.comments_error = None;
}
Err(error) => {
app.comments.clear();
app.comments_package_name = None;
app.comments_fetched_at = None;
app.comments_error = Some(error);
}
}
}
let _ = tick_tx.send(());
}
/// What: Handle preflight summary result event.
///
/// Inputs:
/// - `app`: Application state
/// - `summary_outcome`: Preflight summary computation result
/// - `tick_tx`: Channel sender for tick events
///
/// Details:
/// - Updates preflight modal with computed summary
/// - Respects cancellation flag
pub fn handle_summary_result(
app: &mut AppState,
summary_outcome: crate::logic::preflight::PreflightSummaryOutcome,
tick_tx: &mpsc::UnboundedSender<()>,
) {
// Check if cancelled before updating modal
let cancelled = app
.preflight_cancelled
.load(std::sync::atomic::Ordering::Relaxed);
if cancelled {
tracing::debug!("[Runtime] Ignoring summary result (preflight cancelled)");
} else {
// Update preflight modal with computed summary
tracing::info!(
stage = "summary",
package_count = summary_outcome.summary.package_count,
"[Runtime] Preflight summary computation worker completed"
);
if let crate::state::Modal::Preflight {
summary,
header_chips,
cached_reverse_deps_report,
..
} = &mut app.modal
{
*summary = Some(Box::new(summary_outcome.summary));
*header_chips = summary_outcome.header;
*cached_reverse_deps_report = summary_outcome.reverse_deps_report;
}
}
app.preflight_summary_resolving = false;
// Clear preflight summary items
app.preflight_summary_items = None;
let _ = tick_tx.send(());
}
/// What: Check and trigger summary resolution if conditions are met.
fn check_and_trigger_summary_resolution(
app: &mut AppState,
summary_req_tx: &mpsc::UnboundedSender<(
Vec<PackageItem>,
crate::state::modal::PreflightAction,
)>,
) {
if let Some((items, action)) = app.preflight_summary_items.take()
&& !app.preflight_summary_resolving
{
tracing::debug!(
"[Runtime] Tick: Triggering summary computation for {} items, action={:?}",
items.len(),
action
);
app.preflight_summary_resolving = true;
let _ = summary_req_tx.send((items, action));
} else if app.preflight_summary_items.is_some() {
tracing::debug!(
"[Runtime] Tick: NOT triggering summary - items={}, preflight_summary_resolving={}",
app.preflight_summary_items
.as_ref()
.map_or(0, |(items, _)| items.len()),
app.preflight_summary_resolving
);
}
}
/// What: Check and trigger dependency resolution if conditions are met.
fn check_and_trigger_deps_resolution(
app: &mut AppState,
deps_req_tx: &mpsc::UnboundedSender<(Vec<PackageItem>, crate::state::modal::PreflightAction)>,
) {
let preflight_items_len = app
.preflight_deps_items
.as_ref()
.map_or(0, |(items, _)| items.len());
let should_log_state =
(app.preflight_deps_items.is_some() || app.preflight_deps_resolving || app.deps_resolving)
&& (app.last_logged_preflight_deps_state
!= Some((
preflight_items_len,
app.preflight_deps_resolving,
app.deps_resolving,
)));
if should_log_state {
tracing::info!(
"[Runtime] check_and_trigger_deps_resolution: preflight_deps_items={}, preflight_deps_resolving={}, deps_resolving={}",
preflight_items_len,
app.preflight_deps_resolving,
app.deps_resolving
);
app.last_logged_preflight_deps_state = Some((
preflight_items_len,
app.preflight_deps_resolving,
app.deps_resolving,
));
} else if app.preflight_deps_items.is_none()
&& !app.preflight_deps_resolving
&& !app.deps_resolving
{
// Reset snapshot once idle so future state transitions log again.
app.last_logged_preflight_deps_state = None;
}
if let Some((items, action)) = app.preflight_deps_items.take()
&& app.preflight_deps_resolving
&& !app.deps_resolving
{
tracing::info!(
"[Runtime] Tick: Triggering dependency resolution for {} preflight items (action={:?}, preflight_deps_resolving={}, deps_resolving={})",
items.len(),
action,
app.preflight_deps_resolving,
app.deps_resolving
);
app.deps_resolving = true;
let send_result = deps_req_tx.send((items, action));
tracing::info!(
"[Runtime] Tick: deps_req_tx.send result: {:?}",
send_result.is_ok()
);
} else if app.preflight_deps_items.is_some() {
tracing::warn!(
"[Runtime] Tick: NOT triggering deps - items={}, preflight_deps_resolving={}, deps_resolving={}",
app.preflight_deps_items
.as_ref()
.map_or(0, |(items, _)| items.len()),
app.preflight_deps_resolving,
app.deps_resolving
);
}
}
/// What: Check and trigger file resolution if conditions are met.
fn check_and_trigger_files_resolution(
app: &mut AppState,
files_req_tx: &mpsc::UnboundedSender<(Vec<PackageItem>, crate::state::modal::PreflightAction)>,
) {
if let Some(items) = app.preflight_files_items.take()
&& app.preflight_files_resolving
&& !app.files_resolving
{
// Get action from preflight modal state
let action = if let crate::state::Modal::Preflight { action, .. } = &app.modal {
*action
} else {
// Fallback to Install if modal state is unavailable
crate::state::modal::PreflightAction::Install
};
tracing::debug!(
"[Runtime] Tick: Triggering file resolution for {} preflight items with action={:?} (preflight_files_resolving={}, files_resolving={})",
items.len(),
action,
app.preflight_files_resolving,
app.files_resolving
);
app.files_resolving = true;
let _ = files_req_tx.send((items, action));
} else if app.preflight_files_items.is_some() {
tracing::debug!(
"[Runtime] Tick: NOT triggering files - items={}, preflight_files_resolving={}, files_resolving={}",
app.preflight_files_items.as_ref().map_or(0, Vec::len),
app.preflight_files_resolving,
app.files_resolving
);
}
}
/// What: Check and trigger service resolution if conditions are met.
fn check_and_trigger_services_resolution(
app: &mut AppState,
services_req_tx: &mpsc::UnboundedSender<(
Vec<PackageItem>,
crate::state::modal::PreflightAction,
)>,
) {
if let Some(ref items) = app.preflight_services_items
&& app.preflight_services_resolving
&& !app.services_resolving
{
// Get action from preflight modal state
let action = if let crate::state::Modal::Preflight { action, .. } = &app.modal {
*action
} else {
// Fallback to Install if modal state is unavailable
crate::state::modal::PreflightAction::Install
};
app.services_resolving = true;
let _ = services_req_tx.send((items.clone(), action));
}
}
/// What: Check and trigger sandbox resolution if conditions are met.
fn check_and_trigger_sandbox_resolution(
app: &mut AppState,
sandbox_req_tx: &mpsc::UnboundedSender<Vec<PackageItem>>,
) {
if let Some(items) = app.preflight_sandbox_items.take()
&& app.preflight_sandbox_resolving
&& !app.sandbox_resolving
{
tracing::debug!(
"[Runtime] Tick: Triggering sandbox resolution for {} preflight items (preflight_sandbox_resolving={}, sandbox_resolving={})",
items.len(),
app.preflight_sandbox_resolving,
app.sandbox_resolving
);
app.sandbox_resolving = true;
let _ = sandbox_req_tx.send(items);
} else if app.preflight_sandbox_items.is_some() {
tracing::debug!(
"[Runtime] Tick: NOT triggering sandbox - items={}, preflight_sandbox_resolving={}, sandbox_resolving={}",
app.preflight_sandbox_items.as_ref().map_or(0, Vec::len),
app.preflight_sandbox_resolving,
app.sandbox_resolving
);
}
}
/// What: Handle preflight resolution requests.
///
/// Inputs:
/// - `app`: Application state
/// - `deps_req_tx`: Channel sender for dependency resolution requests
/// - `files_req_tx`: Channel sender for file resolution requests
/// - `services_req_tx`: Channel sender for service resolution requests
/// - `sandbox_req_tx`: Channel sender for sandbox resolution requests
/// - `summary_req_tx`: Channel sender for summary computation requests
///
/// Output: None
///
/// Details:
/// - Clears queues if preflight is cancelled
/// - Otherwise triggers resolution requests for each preflight stage
fn handle_preflight_resolution(
app: &mut AppState,
deps_req_tx: &mpsc::UnboundedSender<(Vec<PackageItem>, crate::state::modal::PreflightAction)>,
files_req_tx: &mpsc::UnboundedSender<(Vec<PackageItem>, crate::state::modal::PreflightAction)>,
services_req_tx: &mpsc::UnboundedSender<(
Vec<PackageItem>,
crate::state::modal::PreflightAction,
)>,
sandbox_req_tx: &mpsc::UnboundedSender<Vec<PackageItem>>,
summary_req_tx: &mpsc::UnboundedSender<(
Vec<PackageItem>,
crate::state::modal::PreflightAction,
)>,
) {
let cancelled = app
.preflight_cancelled
.load(std::sync::atomic::Ordering::Relaxed);
if cancelled {
// Clear all queues if cancelled
app.preflight_summary_items = None;
app.preflight_deps_items = None;
app.preflight_files_items = None;
app.preflight_services_items = None;
app.preflight_sandbox_items = None;
return;
}
// Check for preflight resolution requests - each stage has its own queue
check_and_trigger_summary_resolution(app, summary_req_tx);
check_and_trigger_deps_resolution(app, deps_req_tx);
check_and_trigger_files_resolution(app, files_req_tx);
check_and_trigger_services_resolution(app, services_req_tx);
check_and_trigger_sandbox_resolution(app, sandbox_req_tx);
}
/// What: Handle PKGBUILD reload debouncing.
///
/// Inputs:
/// - `app`: Application state
/// - `pkgb_req_tx`: Channel sender for PKGBUILD requests
///
/// Output: None
///
/// Details:
/// - Checks if debounce delay has elapsed
/// - Sends reload request if still on the same package
/// - Clears pending request after processing
fn handle_pkgbuild_reload_debounce(
app: &mut AppState,
pkgb_req_tx: &mpsc::UnboundedSender<PackageItem>,
) {
const PKGBUILD_DEBOUNCE_MS: u64 = 100; // Reduced from 250ms for faster preview loading
let (Some(requested_at), Some(requested_for)) =
(app.pkgb_reload_requested_at, &app.pkgb_reload_requested_for)
else {
return;
};
let elapsed = requested_at.elapsed();
if elapsed.as_millis() < u128::from(PKGBUILD_DEBOUNCE_MS) {
return;
}
// Check if the requested package is still the currently selected one
if let Some(current_item) = app.results.get(app.selected)
&& current_item.name == *requested_for
{
// Still on the same package, actually send the request
let _ = pkgb_req_tx.send(current_item.clone());
}
// Clear the pending request
app.pkgb_reload_requested_at = None;
app.pkgb_reload_requested_for = None;
}
/// What: Handle installed cache polling logic.
///
/// Inputs:
/// - `app`: Application state
/// - `query_tx`: Channel sender for query input
///
/// Output: None
///
/// Details:
/// - Polls installed/explicit caches if within deadline
/// - Checks if pending installs/removals are complete
/// - Clears tracking when operations complete
fn handle_installed_cache_polling(
app: &mut AppState,
query_tx: &mpsc::UnboundedSender<QueryInput>,
) {
let Some(deadline) = app.refresh_installed_until else {
return;
};
let now = Instant::now();
if now >= deadline {
app.refresh_installed_until = None;
app.next_installed_refresh_at = None;
app.pending_install_names = None;
return;
}
let should_poll = app.next_installed_refresh_at.is_none_or(|t| now >= t);
if !should_poll {
return;
}
let maybe_pending_installs = app.pending_install_names.clone();
let maybe_pending_removes = app.pending_remove_names.clone();
let installed_mode = app.installed_packages_mode;
tokio::spawn(async move {
// Refresh caches in background; ignore errors
crate::index::refresh_installed_cache().await;
crate::index::refresh_explicit_cache(installed_mode).await;
});
// Schedule next poll ~1s later
app.next_installed_refresh_at = Some(now + Duration::from_millis(1000));
// If installed-only mode, results depend on explicit set; re-run query soon
send_query(app, query_tx);
// If we are tracking pending installs, check if all are installed now
if let Some(pending) = maybe_pending_installs {
let all_installed = pending.iter().all(|n| crate::index::is_installed(n));
if all_installed {
// Clear install list and stop tracking
app.install_list.clear();
app.install_list_names.clear();
app.install_dirty = true;
app.pending_install_names = None;
// Clear dependency cache when install list is cleared
app.install_list_deps.clear();
app.install_list_files.clear();
app.deps_resolving = false;
app.files_resolving = false;
// End polling soon to avoid extra work
app.refresh_installed_until = Some(now + Duration::from_secs(1));
}
}
// If tracking pending removals, log once all are uninstalled
if let Some(pending_rm) = maybe_pending_removes {
let all_removed = pending_rm.iter().all(|n| !crate::index::is_installed(n));
if all_removed {
if let Err(e) = crate::install::log_removed(&pending_rm) {
let _ = e; // ignore logging errors
}
// Check for config directories after successful removal
if let Ok(home) = std::env::var("HOME") {
let mut found_configs = Vec::new();
for pkg in &pending_rm {
let config_dirs = crate::install::check_config_directories(pkg, &home);
for dir in config_dirs {
found_configs.push((pkg.clone(), dir));
}
}
if !found_configs.is_empty() {
let mut message = String::from(
"Configuration directories were found in your home directory:\n\n",
);
for (pkg, dir) in &found_configs {
let _ = writeln!(message, " {pkg}: {}", dir.display());
}
message.push_str("\nYou may want to manually remove these directories if they are no longer needed.");
app.modal = crate::state::Modal::Alert { message };
}
}
app.pending_remove_names = None;
// End polling soon to avoid extra work
app.refresh_installed_until = Some(now + Duration::from_secs(1));
}
}
}
/// What: Handle tick event (periodic updates).
///
/// Inputs:
/// - `app`: Application state
/// - `query_tx`: Channel sender for query input
/// - `details_req_tx`: Channel sender for detail requests
/// - `pkgb_req_tx`: Channel sender for PKGBUILD requests
/// - `deps_req_tx`: Channel sender for dependency resolution requests
/// - `files_req_tx`: Channel sender for file resolution requests
/// - `services_req_tx`: Channel sender for service resolution requests
/// - `sandbox_req_tx`: Channel sender for sandbox resolution requests
/// - `summary_req_tx`: Channel sender for summary computation requests
///
/// Details:
/// - Flushes caches and persists data
/// - Handles preflight resolution requests
/// - Handles PKGBUILD reload debouncing
/// - Polls installed/explicit caches if needed
/// - Handles ring prefetch, sort menu auto-close, and toast expiration
#[allow(clippy::too_many_arguments)]
// Function is 151 lines, just 1 line over the threshold. Refactoring would require
// significant restructuring of the tick handling logic which would reduce readability.
#[allow(clippy::too_many_lines)] // Function has 205 lines - handles periodic tasks (cache flushing, faillock checks, news content timeouts, preflight resolution, executor requests) that require sequential processing
pub fn handle_tick(
app: &mut AppState,
query_tx: &mpsc::UnboundedSender<QueryInput>,
details_req_tx: &mpsc::UnboundedSender<PackageItem>,
pkgb_req_tx: &mpsc::UnboundedSender<PackageItem>,
deps_req_tx: &mpsc::UnboundedSender<(Vec<PackageItem>, crate::state::modal::PreflightAction)>,
files_req_tx: &mpsc::UnboundedSender<(Vec<PackageItem>, crate::state::modal::PreflightAction)>,
services_req_tx: &mpsc::UnboundedSender<(
Vec<PackageItem>,
crate::state::modal::PreflightAction,
)>,
sandbox_req_tx: &mpsc::UnboundedSender<Vec<PackageItem>>,
summary_req_tx: &mpsc::UnboundedSender<(
Vec<PackageItem>,
crate::state::modal::PreflightAction,
)>,
updates_tx: &mpsc::UnboundedSender<(usize, Vec<String>)>,
executor_req_tx: &mpsc::UnboundedSender<crate::install::ExecutorRequest>,
post_summary_req_tx: &mpsc::UnboundedSender<(Vec<PackageItem>, Option<bool>)>,
news_content_req_tx: &mpsc::UnboundedSender<String>,
) {
// Check faillock status periodically (every minute via worker, but also check here)
// We check every tick but only update if enough time has passed
static LAST_FAILLOCK_CHECK: std::sync::OnceLock<std::sync::Mutex<Instant>> =
std::sync::OnceLock::new();
maybe_save_recent(app);
maybe_save_news_recent(app);
maybe_flush_cache(app);
maybe_flush_recent(app);
maybe_flush_news_recent(app);
maybe_flush_news_bookmarks(app);
maybe_flush_news_content_cache(app);
maybe_flush_news_read(app);
maybe_flush_news_read_ids(app);
maybe_flush_news_seen_versions(app);
maybe_flush_news_seen_aur_comments(app);
maybe_flush_announcement_read(app);
maybe_flush_install(app);
maybe_flush_deps_cache(app);
maybe_flush_files_cache(app);
maybe_flush_services_cache(app);
maybe_flush_sandbox_cache(app);
maybe_flush_pkgbuild_parse_cache();
let last_check = LAST_FAILLOCK_CHECK.get_or_init(|| std::sync::Mutex::new(Instant::now()));
if let Ok(mut last_check_guard) = last_check.lock()
&& last_check_guard.elapsed().as_secs() >= 60
{
*last_check_guard = Instant::now();
drop(last_check_guard);
// Check faillock status
let username = std::env::var("USER").unwrap_or_else(|_| "user".to_string());
let (is_locked, lockout_until, remaining_minutes) =
crate::logic::faillock::get_lockout_info(&username);
// If user was locked but is now unlocked, close any lockout alert modal
if app.faillock_locked && !is_locked {
// User is no longer locked - close lockout alert if it's showing
if let crate::state::Modal::Alert { message } = &app.modal
&& (message.contains("locked") || message.contains("lockout"))
{
app.modal = crate::state::Modal::None;
}
}
app.faillock_locked = is_locked;
app.faillock_lockout_until = lockout_until;
app.faillock_remaining_minutes = remaining_minutes;
}
// Timeout guard for news content fetches to avoid stuck "Loading content..."
// Only check timeout if main news feed is not loading (to avoid showing timeout toast during initial load)
if app.news_content_loading && !app.news_loading {
if let Some(started) = app.news_content_loading_since {
if started.elapsed() > std::time::Duration::from_secs(10) {
let url = app
.news_results
.get(app.news_selected)
.and_then(|it| it.url.clone());
tracing::warn!(
selected = app.news_selected,
url = ?url,
elapsed_ms = started.elapsed().as_millis(),
"news_content: timed out waiting for response"
);
app.news_content_loading = false;
app.news_content_loading_since = None;
app.news_content = Some("Failed to load content: timed out after 10s".to_string());
app.toast_message = Some("News content timed out".to_string());
app.toast_expires_at = Some(Instant::now() + std::time::Duration::from_secs(3));
} else {
tracing::trace!(
selected = app.news_selected,
elapsed_ms = started.elapsed().as_millis(),
"news_content: still loading"
);
}
} else {
// Ensure we set a start time if missing for safety
app.news_content_loading_since = Some(Instant::now());
}
}
// Refresh updates list if flag is set (manual refresh via button click)
if app.refresh_updates {
app.refresh_updates = false;
app.updates_loading = true;
crate::app::runtime::workers::updates::spawn_updates_worker(updates_tx.clone());
}
// Request news content if in news mode and content not cached
crate::events::utils::maybe_request_news_content(app, news_content_req_tx);
handle_preflight_resolution(
app,
deps_req_tx,
files_req_tx,
services_req_tx,
sandbox_req_tx,
summary_req_tx,
);
// Send pending executor request if PreflightExec modal is active
if let Some(request) = app.pending_executor_request.take()
&& matches!(app.modal, crate::state::Modal::PreflightExec { .. })
&& let Err(e) = executor_req_tx.send(request)
{
tracing::error!("Failed to send executor request: {:?}", e);
}
// Send pending post-summary request if Loading modal is active
if let Some((items, success)) = app.pending_post_summary_items.take()
&& matches!(app.modal, crate::state::Modal::Loading { .. })
&& let Err(e) = post_summary_req_tx.send((items, success))
{
tracing::error!("Failed to send post-summary request: {:?}", e);
}
// Check file database sync result from background thread
if let Some(sync_result_arc) = app.pending_file_sync_result.take()
&& let Ok(mut sync_result) = sync_result_arc.lock()
&& let Some(result) = sync_result.take()
{
match result {
Ok(synced) => {
// Sync succeeded
if synced {
app.toast_message =
Some("File database sync completed successfully".to_string());
} else {
app.toast_message = Some("File database is already fresh".to_string());
}
app.toast_expires_at =
Some(std::time::Instant::now() + std::time::Duration::from_secs(3));
}
Err(_e) => {
// Sync failed, show password prompt
app.modal = crate::state::Modal::PasswordPrompt {
purpose: crate::state::modal::PasswordPurpose::FileSync,
items: Vec::new(), // No packages involved in file sync
input: String::new(),
cursor: 0,
error: None,
};
// Store the command to execute after password is provided
app.pending_custom_command = Some("sudo pacman -Fy".to_string());
app.pending_exec_header_chips =
Some(crate::state::modal::PreflightHeaderChips::default());
}
}
}
handle_pkgbuild_reload_debounce(app, pkgb_req_tx);
handle_installed_cache_polling(app, query_tx);
if app.need_ring_prefetch
&& app
.ring_resume_at
.is_some_and(|t| std::time::Instant::now() >= t)
{
crate::logic::set_allowed_ring(app, 30);
crate::logic::ring_prefetch_from_selected(app, details_req_tx);
app.need_ring_prefetch = false;
app.scroll_moves = 0;
app.ring_resume_at = None;
}
// Clear expired toast, but don't clear news loading toast while news are still loading
if let Some(deadline) = app.toast_expires_at
&& std::time::Instant::now() >= deadline
{
// Only prevent clearing if it's the actual news loading toast and news are still loading
let is_news_loading_toast = app.toast_message.as_ref().is_some_and(|msg| {
let loading_msg = crate::i18n::t(app, "app.news_button.loading");
msg == &loading_msg
});
if !is_news_loading_toast || !app.news_loading {
app.toast_message = None;
app.toast_expires_at = None;
}
}
}
/// What: Handle news update event.
///
/// Inputs:
/// - `app`: Application state
/// - `items`: List of news feed items
///
/// Details:
/// - Shows toast if no new news
/// - Opens news modal if there are unread items
/// - Clears `news_loading` flag only when news modal is actually shown
pub fn handle_news(app: &mut AppState, items: &[crate::state::types::NewsFeedItem]) {
tracing::info!(
items_count = items.len(),
current_modal = ?app.modal,
news_loading = app.news_loading,
"handle_news called"
);
// Don't clear news_loading or toast here - the main news feed pane may still be loading.
// The loading toast and flag will be cleared when handle_news_feed_items receives the aggregated feed.
if items.is_empty() {
// No news available - set ready flag to false
tracing::info!("no news items, marking as not ready");
app.news_ready = false;
} else {
// News are ready - set flag and store items for button click
tracing::info!("news items available, marking as ready");
app.news_ready = true;
// Store news items for later display when button is clicked
// Convert NewsFeedItem to NewsItem for pending_news (legacy format)
let legacy_items: Vec<crate::state::NewsItem> = items
.iter()
.filter_map(|item| {
item.url.as_ref().map(|url| crate::state::NewsItem {
date: item.date.clone(),
title: item.title.clone(),
url: url.clone(),
})
})
.collect();
app.pending_news = Some(legacy_items);
}
}
/// What: Handle status update event.
///
/// Inputs:
/// - `app`: Application state
/// - `txt`: Status text (in English, will be translated)
/// - `color`: Status color
///
/// Details:
/// - Translates status text to current locale
/// - Updates Arch status text and color
pub fn handle_status(app: &mut AppState, txt: &str, color: ArchStatusColor) {
use crate::sources::status::translate;
app.arch_status_text = translate::translate_status_text(app, txt);
app.arch_status_color = color;
}
#[cfg(test)]
mod tests {
use super::*;
/// What: Provide a baseline `AppState` for tick handler tests.
///
/// Inputs: None
/// Output: Fresh `AppState` with default values
fn new_app() -> AppState {
AppState::default()
}
#[test]
/// What: Verify that `handle_tick` flushes caches when called.
///
/// Inputs:
/// - `AppState` with `cache_dirty` = true
/// - Channel senders
///
/// Output:
/// - Cache dirty flags may be checked (actual flushing depends on debounce logic)
///
/// Details:
/// - Tests that tick handler processes cache flushing
fn handle_tick_processes_cache_flushing() {
let mut app = new_app();
app.cache_dirty = true;
app.deps_cache_dirty = true;
app.files_cache_dirty = true;
app.services_cache_dirty = true;
app.sandbox_cache_dirty = true;
let (query_tx, _query_rx) = mpsc::unbounded_channel();
let (details_tx, _details_rx) = mpsc::unbounded_channel();
let (pkgb_tx, _pkgb_rx) = mpsc::unbounded_channel();
let (deps_tx, _deps_rx) = mpsc::unbounded_channel();
let (files_tx, _files_rx) = mpsc::unbounded_channel();
let (services_tx, _services_rx) = mpsc::unbounded_channel();
let (sandbox_tx, _sandbox_rx) = mpsc::unbounded_channel();
let (summary_tx, _summary_rx) = mpsc::unbounded_channel();
let (updates_tx, _updates_rx) = mpsc::unbounded_channel();
let (executor_req_tx, _executor_req_rx) = mpsc::unbounded_channel();
let (post_summary_req_tx, _post_summary_req_rx) = mpsc::unbounded_channel();
let (news_content_req_tx, _news_content_req_rx) = mpsc::unbounded_channel();
// Should not panic
handle_tick(
&mut app,
&query_tx,
&details_tx,
&pkgb_tx,
&deps_tx,
&files_tx,
&services_tx,
&sandbox_tx,
&summary_tx,
&updates_tx,
&executor_req_tx,
&post_summary_req_tx,
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | true |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/app/runtime/channels.rs | src/app/runtime/channels.rs | use std::sync::Arc;
use std::sync::atomic::AtomicBool;
use crossterm::event::Event as CEvent;
use tokio::sync::mpsc;
use crate::state::types::NewsFeedPayload;
use crate::state::{ArchStatusColor, PackageDetails, PackageItem, QueryInput, SearchResults};
/// What: Channel definitions for runtime communication.
///
/// Details:
/// - Contains all channel senders and receivers used for communication
/// between the main event loop and background workers
#[allow(dead_code)]
pub struct Channels {
/// Sender for terminal events (keyboard/mouse) from the event reading thread.
pub event_tx: mpsc::UnboundedSender<CEvent>,
/// Receiver for terminal events in the main event loop.
pub event_rx: mpsc::UnboundedReceiver<CEvent>,
/// Atomic flag to signal cancellation of the event reading thread.
pub event_thread_cancelled: Arc<AtomicBool>,
/// Sender for search results from the search worker.
pub search_result_tx: mpsc::UnboundedSender<SearchResults>,
/// Receiver for search results in the main event loop.
pub results_rx: mpsc::UnboundedReceiver<SearchResults>,
/// Sender for package details requests to the details worker.
pub details_req_tx: mpsc::UnboundedSender<PackageItem>,
/// Sender for package details responses from the details worker.
pub details_res_tx: mpsc::UnboundedSender<PackageDetails>,
/// Receiver for package details responses in the main event loop.
pub details_res_rx: mpsc::UnboundedReceiver<PackageDetails>,
/// Sender for tick events to trigger periodic UI updates.
pub tick_tx: mpsc::UnboundedSender<()>,
/// Receiver for tick events in the main event loop.
pub tick_rx: mpsc::UnboundedReceiver<()>,
/// Sender for network error messages from background workers.
pub net_err_tx: mpsc::UnboundedSender<String>,
/// Receiver for network error messages in the main event loop.
pub net_err_rx: mpsc::UnboundedReceiver<String>,
/// Sender for preview requests (package details for Recent pane).
pub preview_tx: mpsc::UnboundedSender<PackageItem>,
/// Receiver for preview responses in the main event loop.
pub preview_rx: mpsc::UnboundedReceiver<PackageItem>,
/// Sender for adding packages to the install list.
pub add_tx: mpsc::UnboundedSender<PackageItem>,
/// Receiver for add requests in the install list handler.
pub add_rx: mpsc::UnboundedReceiver<PackageItem>,
/// Sender for index update notifications.
pub index_notify_tx: mpsc::UnboundedSender<()>,
/// Receiver for index update notifications in the main event loop.
pub index_notify_rx: mpsc::UnboundedReceiver<()>,
/// Sender for PKGBUILD content requests.
pub pkgb_req_tx: mpsc::UnboundedSender<PackageItem>,
/// Sender for PKGBUILD content responses (package name, PKGBUILD content).
pub pkgb_res_tx: mpsc::UnboundedSender<(String, String)>,
/// Receiver for PKGBUILD content responses in the main event loop.
pub pkgb_res_rx: mpsc::UnboundedReceiver<(String, String)>,
/// Sender for AUR comments requests (package name).
pub comments_req_tx: mpsc::UnboundedSender<String>,
/// Sender for AUR comments responses (package name, comments or error).
pub comments_res_tx:
mpsc::UnboundedSender<(String, Result<Vec<crate::state::types::AurComment>, String>)>,
/// Receiver for AUR comments responses in the main event loop.
pub comments_res_rx:
mpsc::UnboundedReceiver<(String, Result<Vec<crate::state::types::AurComment>, String>)>,
/// Sender for Arch Linux status updates (status text, color).
pub status_tx: mpsc::UnboundedSender<(String, ArchStatusColor)>,
/// Receiver for Arch Linux status updates in the main event loop.
pub status_rx: mpsc::UnboundedReceiver<(String, ArchStatusColor)>,
/// Sender for startup news popup items.
pub news_tx: mpsc::UnboundedSender<Vec<crate::state::types::NewsFeedItem>>,
/// Receiver for startup news popup items in the main event loop.
pub news_rx: mpsc::UnboundedReceiver<Vec<crate::state::types::NewsFeedItem>>,
/// Sender for news feed items plus last-seen state.
pub news_feed_tx: mpsc::UnboundedSender<NewsFeedPayload>,
/// Receiver for news feed payloads in the main event loop.
pub news_feed_rx: mpsc::UnboundedReceiver<NewsFeedPayload>,
/// Sender for incremental news items (background continuation).
pub news_incremental_tx: mpsc::UnboundedSender<crate::state::types::NewsFeedItem>,
/// Receiver for incremental news items in the main event loop.
pub news_incremental_rx: mpsc::UnboundedReceiver<crate::state::types::NewsFeedItem>,
/// Request channel for fetching news article content (URL).
pub news_content_req_tx: mpsc::UnboundedSender<String>,
/// Response channel for news article content (URL, content).
pub news_content_res_rx: mpsc::UnboundedReceiver<(String, String)>,
/// Sender for system updates information (count, package names).
pub updates_tx: mpsc::UnboundedSender<(usize, Vec<String>)>,
/// Receiver for system updates information in the main event loop.
pub updates_rx: mpsc::UnboundedReceiver<(usize, Vec<String>)>,
/// Sender for remote announcements.
pub announcement_tx: mpsc::UnboundedSender<crate::announcements::RemoteAnnouncement>,
/// Receiver for remote announcements in the main event loop.
pub announcement_rx: mpsc::UnboundedReceiver<crate::announcements::RemoteAnnouncement>,
/// Sender for dependency resolution requests (packages, action).
pub deps_req_tx:
mpsc::UnboundedSender<(Vec<PackageItem>, crate::state::modal::PreflightAction)>,
/// Sender for dependency resolution responses.
pub deps_res_tx: mpsc::UnboundedSender<Vec<crate::state::modal::DependencyInfo>>,
/// Receiver for dependency resolution responses in the main event loop.
pub deps_res_rx: mpsc::UnboundedReceiver<Vec<crate::state::modal::DependencyInfo>>,
/// Sender for file analysis requests (packages, action).
pub files_req_tx:
mpsc::UnboundedSender<(Vec<PackageItem>, crate::state::modal::PreflightAction)>,
/// Sender for file analysis responses.
pub files_res_tx: mpsc::UnboundedSender<Vec<crate::state::modal::PackageFileInfo>>,
/// Receiver for file analysis responses in the main event loop.
pub files_res_rx: mpsc::UnboundedReceiver<Vec<crate::state::modal::PackageFileInfo>>,
/// Sender for service impact analysis requests (packages, action).
pub services_req_tx:
mpsc::UnboundedSender<(Vec<PackageItem>, crate::state::modal::PreflightAction)>,
/// Sender for service impact analysis responses.
pub services_res_tx: mpsc::UnboundedSender<Vec<crate::state::modal::ServiceImpact>>,
/// Receiver for service impact analysis responses in the main event loop.
pub services_res_rx: mpsc::UnboundedReceiver<Vec<crate::state::modal::ServiceImpact>>,
/// Sender for sandbox analysis requests (packages).
pub sandbox_req_tx: mpsc::UnboundedSender<Vec<PackageItem>>,
/// Sender for sandbox analysis responses.
pub sandbox_res_tx: mpsc::UnboundedSender<Vec<crate::logic::sandbox::SandboxInfo>>,
/// Receiver for sandbox analysis responses in the main event loop.
pub sandbox_res_rx: mpsc::UnboundedReceiver<Vec<crate::logic::sandbox::SandboxInfo>>,
/// Sender for preflight summary requests (packages, action).
pub summary_req_tx:
mpsc::UnboundedSender<(Vec<PackageItem>, crate::state::modal::PreflightAction)>,
/// Sender for preflight summary responses.
pub summary_res_tx: mpsc::UnboundedSender<crate::logic::preflight::PreflightSummaryOutcome>,
/// Receiver for preflight summary responses in the main event loop.
pub summary_res_rx: mpsc::UnboundedReceiver<crate::logic::preflight::PreflightSummaryOutcome>,
/// Sender for executor requests (install/remove/downgrade operations).
pub executor_req_tx: mpsc::UnboundedSender<crate::install::ExecutorRequest>,
/// Receiver for executor responses in the main event loop.
pub executor_res_rx: mpsc::UnboundedReceiver<crate::install::ExecutorOutput>,
/// Sender for post-summary computation requests (packages, success flag).
pub post_summary_req_tx: mpsc::UnboundedSender<(Vec<PackageItem>, Option<bool>)>,
/// Receiver for post-summary computation results in the main event loop.
pub post_summary_res_rx: mpsc::UnboundedReceiver<crate::logic::summary::PostSummaryData>,
/// Sender for search queries to the search worker.
pub query_tx: mpsc::UnboundedSender<QueryInput>,
}
/// What: Event channel pair and cancellation flag.
struct EventChannels {
/// Sender for terminal events.
tx: mpsc::UnboundedSender<CEvent>,
/// Receiver for terminal events.
rx: mpsc::UnboundedReceiver<CEvent>,
/// Cancellation flag for event thread.
cancelled: Arc<AtomicBool>,
}
/// What: Search-related channels.
struct SearchChannels {
/// Sender for search results.
result_tx: mpsc::UnboundedSender<SearchResults>,
/// Receiver for search results.
results_rx: mpsc::UnboundedReceiver<SearchResults>,
/// Sender for search queries.
query_tx: mpsc::UnboundedSender<QueryInput>,
/// Receiver for search queries.
query_rx: mpsc::UnboundedReceiver<QueryInput>,
}
/// What: Package details channels.
struct DetailsChannels {
/// Sender for package details requests.
req_tx: mpsc::UnboundedSender<PackageItem>,
/// Receiver for package details requests.
req_rx: mpsc::UnboundedReceiver<PackageItem>,
/// Sender for package details responses.
res_tx: mpsc::UnboundedSender<PackageDetails>,
/// Receiver for package details responses.
res_rx: mpsc::UnboundedReceiver<PackageDetails>,
}
/// What: Preflight-related channels (dependencies, files, services, sandbox, summary).
struct PreflightChannels {
/// Sender for dependency resolution requests.
deps_req_tx: mpsc::UnboundedSender<(Vec<PackageItem>, crate::state::modal::PreflightAction)>,
/// Receiver for dependency resolution requests.
deps_req_rx: mpsc::UnboundedReceiver<(Vec<PackageItem>, crate::state::modal::PreflightAction)>,
/// Sender for dependency resolution responses.
deps_res_tx: mpsc::UnboundedSender<Vec<crate::state::modal::DependencyInfo>>,
/// Receiver for dependency resolution responses.
deps_res_rx: mpsc::UnboundedReceiver<Vec<crate::state::modal::DependencyInfo>>,
/// Sender for file analysis requests.
files_req_tx: mpsc::UnboundedSender<(Vec<PackageItem>, crate::state::modal::PreflightAction)>,
/// Receiver for file analysis requests.
files_req_rx: mpsc::UnboundedReceiver<(Vec<PackageItem>, crate::state::modal::PreflightAction)>,
/// Sender for file analysis responses.
files_res_tx: mpsc::UnboundedSender<Vec<crate::state::modal::PackageFileInfo>>,
/// Receiver for file analysis responses.
files_res_rx: mpsc::UnboundedReceiver<Vec<crate::state::modal::PackageFileInfo>>,
/// Sender for service impact analysis requests.
services_req_tx:
mpsc::UnboundedSender<(Vec<PackageItem>, crate::state::modal::PreflightAction)>,
/// Receiver for service impact analysis requests.
services_req_rx:
mpsc::UnboundedReceiver<(Vec<PackageItem>, crate::state::modal::PreflightAction)>,
/// Sender for service impact analysis responses.
services_res_tx: mpsc::UnboundedSender<Vec<crate::state::modal::ServiceImpact>>,
/// Receiver for service impact analysis responses.
services_res_rx: mpsc::UnboundedReceiver<Vec<crate::state::modal::ServiceImpact>>,
/// Sender for sandbox analysis requests.
sandbox_req_tx: mpsc::UnboundedSender<Vec<PackageItem>>,
/// Receiver for sandbox analysis requests.
sandbox_req_rx: mpsc::UnboundedReceiver<Vec<PackageItem>>,
/// Sender for sandbox analysis responses.
sandbox_res_tx: mpsc::UnboundedSender<Vec<crate::logic::sandbox::SandboxInfo>>,
/// Receiver for sandbox analysis responses.
sandbox_res_rx: mpsc::UnboundedReceiver<Vec<crate::logic::sandbox::SandboxInfo>>,
/// Sender for preflight summary requests.
summary_req_tx: mpsc::UnboundedSender<(Vec<PackageItem>, crate::state::modal::PreflightAction)>,
/// Receiver for preflight summary requests.
summary_req_rx:
mpsc::UnboundedReceiver<(Vec<PackageItem>, crate::state::modal::PreflightAction)>,
/// Sender for preflight summary responses.
summary_res_tx: mpsc::UnboundedSender<crate::logic::preflight::PreflightSummaryOutcome>,
/// Receiver for preflight summary responses.
summary_res_rx: mpsc::UnboundedReceiver<crate::logic::preflight::PreflightSummaryOutcome>,
}
/// What: Utility channels (tick, network errors, preview, add, index notify, PKGBUILD, status, news).
struct UtilityChannels {
/// Sender for tick events.
tick_tx: mpsc::UnboundedSender<()>,
/// Receiver for tick events.
tick_rx: mpsc::UnboundedReceiver<()>,
/// Sender for network error messages.
net_err_tx: mpsc::UnboundedSender<String>,
/// Receiver for network error messages.
net_err_rx: mpsc::UnboundedReceiver<String>,
/// Sender for preview requests.
preview_tx: mpsc::UnboundedSender<PackageItem>,
/// Receiver for preview requests.
preview_rx: mpsc::UnboundedReceiver<PackageItem>,
/// Sender for add to install list requests.
add_tx: mpsc::UnboundedSender<PackageItem>,
/// Receiver for add to install list requests.
add_rx: mpsc::UnboundedReceiver<PackageItem>,
/// Sender for index update notifications.
index_notify_tx: mpsc::UnboundedSender<()>,
/// Receiver for index update notifications.
index_notify_rx: mpsc::UnboundedReceiver<()>,
/// Sender for PKGBUILD requests.
pkgb_req_tx: mpsc::UnboundedSender<PackageItem>,
/// Receiver for PKGBUILD requests.
pkgb_req_rx: mpsc::UnboundedReceiver<PackageItem>,
/// Sender for PKGBUILD responses.
pkgb_res_tx: mpsc::UnboundedSender<(String, String)>,
/// Receiver for PKGBUILD responses.
pkgb_res_rx: mpsc::UnboundedReceiver<(String, String)>,
/// Sender for AUR comments requests.
comments_req_tx: mpsc::UnboundedSender<String>,
/// Receiver for AUR comments requests.
comments_req_rx: mpsc::UnboundedReceiver<String>,
/// Sender for AUR comments responses.
comments_res_tx:
mpsc::UnboundedSender<(String, Result<Vec<crate::state::types::AurComment>, String>)>,
/// Receiver for AUR comments responses.
comments_res_rx:
mpsc::UnboundedReceiver<(String, Result<Vec<crate::state::types::AurComment>, String>)>,
/// Sender for Arch Linux status updates.
status_tx: mpsc::UnboundedSender<(String, ArchStatusColor)>,
/// Receiver for Arch Linux status updates.
status_rx: mpsc::UnboundedReceiver<(String, ArchStatusColor)>,
/// Sender for startup news popup items.
news_tx: mpsc::UnboundedSender<Vec<crate::state::types::NewsFeedItem>>,
/// Receiver for startup news popup items.
news_rx: mpsc::UnboundedReceiver<Vec<crate::state::types::NewsFeedItem>>,
/// Sender for news feed payloads.
news_feed_tx: mpsc::UnboundedSender<NewsFeedPayload>,
/// Receiver for news feed payloads.
news_feed_rx: mpsc::UnboundedReceiver<NewsFeedPayload>,
/// Sender for incremental news items.
news_incremental_tx: mpsc::UnboundedSender<crate::state::types::NewsFeedItem>,
/// Receiver for incremental news items.
news_incremental_rx: mpsc::UnboundedReceiver<crate::state::types::NewsFeedItem>,
/// Sender for news article content requests.
news_content_req_tx: mpsc::UnboundedSender<String>,
/// Receiver for news article content requests.
news_content_req_rx: mpsc::UnboundedReceiver<String>,
/// Sender for news article content responses.
news_content_res_tx: mpsc::UnboundedSender<(String, String)>,
/// Receiver for news article content responses.
news_content_res_rx: mpsc::UnboundedReceiver<(String, String)>,
/// Sender for system updates information.
updates_tx: mpsc::UnboundedSender<(usize, Vec<String>)>,
/// Receiver for system updates information.
updates_rx: mpsc::UnboundedReceiver<(usize, Vec<String>)>,
/// Sender for remote announcements.
announcement_tx: mpsc::UnboundedSender<crate::announcements::RemoteAnnouncement>,
/// Receiver for remote announcements.
announcement_rx: mpsc::UnboundedReceiver<crate::announcements::RemoteAnnouncement>,
/// Sender for executor requests.
executor_req_tx: mpsc::UnboundedSender<crate::install::ExecutorRequest>,
/// Receiver for executor requests.
executor_req_rx: mpsc::UnboundedReceiver<crate::install::ExecutorRequest>,
/// Sender for executor responses.
executor_res_tx: mpsc::UnboundedSender<crate::install::ExecutorOutput>,
/// Receiver for executor responses.
executor_res_rx: mpsc::UnboundedReceiver<crate::install::ExecutorOutput>,
/// Sender for post-summary computation requests.
post_summary_req_tx: mpsc::UnboundedSender<(Vec<PackageItem>, Option<bool>)>,
/// Receiver for post-summary computation requests.
post_summary_req_rx: mpsc::UnboundedReceiver<(Vec<PackageItem>, Option<bool>)>,
/// Sender for post-summary computation results.
post_summary_res_tx: mpsc::UnboundedSender<crate::logic::summary::PostSummaryData>,
/// Receiver for post-summary computation results.
post_summary_res_rx: mpsc::UnboundedReceiver<crate::logic::summary::PostSummaryData>,
}
/// What: Create event channels.
///
/// Output:
/// - Returns event channels and cancellation flag
fn create_event_channels() -> EventChannels {
let (tx, rx) = mpsc::unbounded_channel::<CEvent>();
let cancelled = Arc::new(AtomicBool::new(false));
EventChannels { tx, rx, cancelled }
}
/// What: Create search-related channels.
///
/// Output:
/// - Returns search channels
fn create_search_channels() -> SearchChannels {
let (result_tx, results_rx) = mpsc::unbounded_channel::<SearchResults>();
let (query_tx, query_rx) = mpsc::unbounded_channel::<QueryInput>();
SearchChannels {
result_tx,
results_rx,
query_tx,
query_rx,
}
}
/// What: Create package details channels.
///
/// Output:
/// - Returns details channels
fn create_details_channels() -> DetailsChannels {
let (req_tx, req_rx) = mpsc::unbounded_channel::<PackageItem>();
let (res_tx, res_rx) = mpsc::unbounded_channel::<PackageDetails>();
DetailsChannels {
req_tx,
req_rx,
res_tx,
res_rx,
}
}
/// What: Create preflight-related channels.
///
/// Output:
/// - Returns preflight channels
fn create_preflight_channels() -> PreflightChannels {
let (deps_req_tx, deps_req_rx) =
mpsc::unbounded_channel::<(Vec<PackageItem>, crate::state::modal::PreflightAction)>();
let (deps_res_tx, deps_res_rx) =
mpsc::unbounded_channel::<Vec<crate::state::modal::DependencyInfo>>();
let (files_req_tx, files_req_rx) =
mpsc::unbounded_channel::<(Vec<PackageItem>, crate::state::modal::PreflightAction)>();
let (files_res_tx, files_res_rx) =
mpsc::unbounded_channel::<Vec<crate::state::modal::PackageFileInfo>>();
let (services_req_tx, services_req_rx) =
mpsc::unbounded_channel::<(Vec<PackageItem>, crate::state::modal::PreflightAction)>();
let (services_res_tx, services_res_rx) =
mpsc::unbounded_channel::<Vec<crate::state::modal::ServiceImpact>>();
let (sandbox_req_tx, sandbox_req_rx) = mpsc::unbounded_channel::<Vec<PackageItem>>();
let (sandbox_res_tx, sandbox_res_rx) =
mpsc::unbounded_channel::<Vec<crate::logic::sandbox::SandboxInfo>>();
let (summary_req_tx, summary_req_rx) =
mpsc::unbounded_channel::<(Vec<PackageItem>, crate::state::modal::PreflightAction)>();
let (summary_res_tx, summary_res_rx) =
mpsc::unbounded_channel::<crate::logic::preflight::PreflightSummaryOutcome>();
PreflightChannels {
deps_req_tx,
deps_req_rx,
deps_res_tx,
deps_res_rx,
files_req_tx,
files_req_rx,
files_res_tx,
files_res_rx,
services_req_tx,
services_req_rx,
services_res_tx,
services_res_rx,
sandbox_req_tx,
sandbox_req_rx,
sandbox_res_tx,
sandbox_res_rx,
summary_req_tx,
summary_req_rx,
summary_res_tx,
summary_res_rx,
}
}
/// What: Create utility channels.
///
/// Output:
/// - Returns utility channels
fn create_utility_channels() -> UtilityChannels {
let (tick_tx, tick_rx) = mpsc::unbounded_channel::<()>();
let (net_err_tx, net_err_rx) = mpsc::unbounded_channel::<String>();
let (preview_tx, preview_rx) = mpsc::unbounded_channel::<PackageItem>();
let (add_tx, add_rx) = mpsc::unbounded_channel::<PackageItem>();
let (index_notify_tx, index_notify_rx) = mpsc::unbounded_channel::<()>();
let (pkgb_req_tx, pkgb_req_rx) = mpsc::unbounded_channel::<PackageItem>();
let (pkgb_res_tx, pkgb_res_rx) = mpsc::unbounded_channel::<(String, String)>();
let (comments_req_tx, comments_req_rx) = mpsc::unbounded_channel::<String>();
let (comments_res_tx, comments_res_rx) =
mpsc::unbounded_channel::<(String, Result<Vec<crate::state::types::AurComment>, String>)>();
let (status_tx, status_rx) = mpsc::unbounded_channel::<(String, ArchStatusColor)>();
let (news_tx, news_rx) = mpsc::unbounded_channel::<Vec<crate::state::types::NewsFeedItem>>();
let (news_feed_tx, news_feed_rx) = mpsc::unbounded_channel::<NewsFeedPayload>();
let (news_incremental_tx, news_incremental_rx) =
mpsc::unbounded_channel::<crate::state::types::NewsFeedItem>();
let (news_content_req_tx, news_content_req_rx) = mpsc::unbounded_channel::<String>();
let (news_content_res_tx, news_content_res_rx) = mpsc::unbounded_channel::<(String, String)>();
let (updates_tx, updates_rx) = mpsc::unbounded_channel::<(usize, Vec<String>)>();
let (announcement_tx, announcement_rx) =
mpsc::unbounded_channel::<crate::announcements::RemoteAnnouncement>();
let (executor_req_tx, executor_req_rx) =
mpsc::unbounded_channel::<crate::install::ExecutorRequest>();
let (executor_res_tx, executor_res_rx) =
mpsc::unbounded_channel::<crate::install::ExecutorOutput>();
let (post_summary_req_tx, post_summary_req_rx) =
mpsc::unbounded_channel::<(Vec<PackageItem>, Option<bool>)>();
let (post_summary_res_tx, post_summary_res_rx) =
mpsc::unbounded_channel::<crate::logic::summary::PostSummaryData>();
UtilityChannels {
tick_tx,
tick_rx,
net_err_tx,
net_err_rx,
preview_tx,
preview_rx,
add_tx,
add_rx,
index_notify_tx,
index_notify_rx,
pkgb_req_tx,
pkgb_req_rx,
pkgb_res_tx,
pkgb_res_rx,
comments_req_tx,
comments_req_rx,
comments_res_tx,
comments_res_rx,
status_tx,
status_rx,
news_tx,
news_rx,
news_feed_tx,
news_feed_rx,
news_incremental_tx,
news_incremental_rx,
news_content_req_tx,
news_content_req_rx,
news_content_res_tx,
news_content_res_rx,
updates_tx,
updates_rx,
announcement_tx,
announcement_rx,
executor_req_tx,
executor_req_rx,
executor_res_tx,
executor_res_rx,
post_summary_req_tx,
post_summary_req_rx,
post_summary_res_tx,
post_summary_res_rx,
}
}
impl Channels {
/// What: Create all channels used for runtime communication.
///
/// Inputs:
/// - `index_path`: Path to official package index (for search worker)
///
/// Output:
/// - Returns a `Channels` struct with all senders and receivers initialized
pub fn new(index_path: std::path::PathBuf) -> Self {
let event_channels = create_event_channels();
let search_channels = create_search_channels();
let details_channels = create_details_channels();
let preflight_channels = create_preflight_channels();
let utility_channels = create_utility_channels();
// Spawn background workers
crate::app::runtime::workers::details::spawn_details_worker(
&utility_channels.net_err_tx,
details_channels.req_rx,
details_channels.res_tx.clone(),
);
crate::app::runtime::workers::details::spawn_pkgbuild_worker(
utility_channels.pkgb_req_rx,
utility_channels.pkgb_res_tx.clone(),
);
crate::app::runtime::workers::comments::spawn_comments_worker(
utility_channels.comments_req_rx,
utility_channels.comments_res_tx.clone(),
);
crate::app::runtime::workers::news_content::spawn_news_content_worker(
utility_channels.news_content_req_rx,
utility_channels.news_content_res_tx.clone(),
);
crate::app::runtime::workers::preflight::spawn_dependency_worker(
preflight_channels.deps_req_rx,
preflight_channels.deps_res_tx.clone(),
);
crate::app::runtime::workers::preflight::spawn_file_worker(
preflight_channels.files_req_rx,
preflight_channels.files_res_tx.clone(),
);
crate::app::runtime::workers::preflight::spawn_service_worker(
preflight_channels.services_req_rx,
preflight_channels.services_res_tx.clone(),
);
crate::app::runtime::workers::preflight::spawn_sandbox_worker(
preflight_channels.sandbox_req_rx,
preflight_channels.sandbox_res_tx.clone(),
);
crate::app::runtime::workers::preflight::spawn_summary_worker(
preflight_channels.summary_req_rx,
preflight_channels.summary_res_tx.clone(),
);
crate::app::runtime::workers::search::spawn_search_worker(
search_channels.query_rx,
search_channels.result_tx.clone(),
&utility_channels.net_err_tx,
index_path,
);
crate::app::runtime::workers::executor::spawn_executor_worker(
utility_channels.executor_req_rx,
utility_channels.executor_res_tx.clone(),
);
spawn_post_summary_worker(
utility_channels.post_summary_req_rx,
utility_channels.post_summary_res_tx.clone(),
);
Self {
event_tx: event_channels.tx,
event_rx: event_channels.rx,
event_thread_cancelled: event_channels.cancelled,
search_result_tx: search_channels.result_tx,
results_rx: search_channels.results_rx,
details_req_tx: details_channels.req_tx,
details_res_tx: details_channels.res_tx,
details_res_rx: details_channels.res_rx,
tick_tx: utility_channels.tick_tx,
tick_rx: utility_channels.tick_rx,
net_err_tx: utility_channels.net_err_tx,
net_err_rx: utility_channels.net_err_rx,
preview_tx: utility_channels.preview_tx,
preview_rx: utility_channels.preview_rx,
add_tx: utility_channels.add_tx,
add_rx: utility_channels.add_rx,
index_notify_tx: utility_channels.index_notify_tx,
index_notify_rx: utility_channels.index_notify_rx,
pkgb_req_tx: utility_channels.pkgb_req_tx,
pkgb_res_tx: utility_channels.pkgb_res_tx,
pkgb_res_rx: utility_channels.pkgb_res_rx,
comments_req_tx: utility_channels.comments_req_tx,
comments_res_tx: utility_channels.comments_res_tx,
comments_res_rx: utility_channels.comments_res_rx,
status_tx: utility_channels.status_tx,
status_rx: utility_channels.status_rx,
news_tx: utility_channels.news_tx,
news_rx: utility_channels.news_rx,
news_feed_tx: utility_channels.news_feed_tx,
news_feed_rx: utility_channels.news_feed_rx,
news_incremental_tx: utility_channels.news_incremental_tx,
news_incremental_rx: utility_channels.news_incremental_rx,
news_content_req_tx: utility_channels.news_content_req_tx,
news_content_res_rx: utility_channels.news_content_res_rx,
updates_tx: utility_channels.updates_tx,
updates_rx: utility_channels.updates_rx,
announcement_tx: utility_channels.announcement_tx,
announcement_rx: utility_channels.announcement_rx,
deps_req_tx: preflight_channels.deps_req_tx,
deps_res_tx: preflight_channels.deps_res_tx,
deps_res_rx: preflight_channels.deps_res_rx,
files_req_tx: preflight_channels.files_req_tx,
files_res_tx: preflight_channels.files_res_tx,
files_res_rx: preflight_channels.files_res_rx,
services_req_tx: preflight_channels.services_req_tx,
services_res_tx: preflight_channels.services_res_tx,
services_res_rx: preflight_channels.services_res_rx,
sandbox_req_tx: preflight_channels.sandbox_req_tx,
sandbox_res_tx: preflight_channels.sandbox_res_tx,
sandbox_res_rx: preflight_channels.sandbox_res_rx,
summary_req_tx: preflight_channels.summary_req_tx,
summary_res_tx: preflight_channels.summary_res_tx,
summary_res_rx: preflight_channels.summary_res_rx,
executor_req_tx: utility_channels.executor_req_tx,
executor_res_rx: utility_channels.executor_res_rx,
post_summary_req_tx: utility_channels.post_summary_req_tx,
post_summary_res_rx: utility_channels.post_summary_res_rx,
query_tx: search_channels.query_tx,
}
}
}
/// What: Spawn background worker for post-summary computation.
///
/// Inputs:
/// - `req_rx`: Channel receiver for post-summary requests (package items)
/// - `res_tx`: Channel sender for post-summary results
///
/// Details:
/// - Runs `compute_post_summary` in a blocking task to avoid blocking the UI
fn spawn_post_summary_worker(
mut req_rx: mpsc::UnboundedReceiver<(Vec<PackageItem>, Option<bool>)>,
res_tx: mpsc::UnboundedSender<crate::logic::summary::PostSummaryData>,
) {
tokio::spawn(async move {
while let Some((items, success)) = req_rx.recv().await {
let res_tx = res_tx.clone();
tokio::task::spawn_blocking(move || {
let data = crate::logic::compute_post_summary(&items, success);
let _ = res_tx.send(data);
});
}
});
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/app/runtime/mod.rs | src/app/runtime/mod.rs | use ratatui::{Terminal, backend::CrosstermBackend};
use crate::logic::send_query;
use crate::state::AppState;
use super::terminal::{restore_terminal, setup_terminal};
/// Background worker management and spawning.
mod background;
/// Channel definitions for runtime communication.
mod channels;
/// Cleanup operations on application exit.
mod cleanup;
/// Main event loop implementation.
mod event_loop;
/// Event handlers for different event types.
mod handlers;
/// Application state initialization module.
pub mod init;
/// Tick handler for periodic UI updates.
mod tick_handler;
/// Background worker implementations.
mod workers;
use background::{Channels, spawn_auxiliary_workers, spawn_event_thread};
use cleanup::cleanup_on_exit;
use event_loop::run_event_loop;
use init::{initialize_app_state, trigger_initial_resolutions};
/// Result type alias for runtime operations.
type Result<T> = std::result::Result<T, Box<dyn std::error::Error + Send + Sync>>;
/// What: Run the Pacsea TUI application end-to-end.
///
/// This function initializes terminal and state, spawns background workers
/// (index, search, details, status/news), drives the event loop, persists
/// caches, and restores the terminal on exit.
///
/// Inputs:
/// - `dry_run_flag`: When `true`, install/remove/downgrade actions are displayed but not executed
/// (overrides the config default for the session).
///
/// Output:
/// - `Ok(())` when the UI exits cleanly; `Err` on unrecoverable terminal or runtime errors.
///
/// # Errors
/// - Returns `Err` when terminal setup fails (e.g., unable to initialize terminal backend)
/// - Returns `Err` when terminal restoration fails on exit
/// - Returns `Err` when critical runtime errors occur during initialization or event loop execution
///
/// Details:
/// - Config/state: Migrates legacy configs, loads settings (layout, keymap, sort), and reads
/// persisted files (details cache, recent queries, install list, on-disk official index).
/// - Background tasks: Spawns channels and tasks for batched details fetch, AUR/official search,
/// PKGBUILD retrieval, official index refresh/enrichment, Arch status text, and Arch news.
/// - Event loop: Renders UI frames and handles keyboard, mouse, tick, and channel messages to
/// update results, details, ring-prefetch, PKGBUILD viewer, installed-only mode, and modals.
/// - Persistence: Debounces and periodically writes recent, details cache, and install list.
/// - Cleanup: Flushes pending writes and restores terminal modes before returning.
pub async fn run(dry_run_flag: bool) -> Result<()> {
let headless = std::env::var("PACSEA_TEST_HEADLESS").ok().as_deref() == Some("1");
if !headless {
setup_terminal()?;
}
let mut terminal = if headless {
None
} else {
Some(Terminal::new(CrosstermBackend::new(std::io::stdout()))?)
};
let mut app = AppState::default();
// Initialize application state (loads settings, caches, etc.)
let init_flags = initialize_app_state(&mut app, dry_run_flag, headless);
// Create channels and spawn background workers
let mut channels = Channels::new(app.official_index_path.clone());
// Get updates refresh interval from settings (minimum 60s per requirement)
let updates_refresh_interval = crate::theme::settings().updates_refresh_interval.max(60);
// Spawn auxiliary workers (status, news, tick, index updates)
spawn_auxiliary_workers(
headless,
&channels.status_tx,
&channels.news_tx,
&channels.news_feed_tx,
&channels.news_incremental_tx,
&channels.announcement_tx,
&channels.tick_tx,
&app.news_read_ids,
&app.news_read_urls,
&app.news_seen_pkg_versions,
&app.news_seen_aur_comments,
&app.official_index_path,
&channels.net_err_tx,
&channels.index_notify_tx,
&channels.updates_tx,
updates_refresh_interval,
app.installed_packages_mode,
crate::theme::settings().get_announcement,
app.last_startup_timestamp.as_deref(),
);
// Spawn event reading thread
spawn_event_thread(
headless,
channels.event_tx.clone(),
channels.event_thread_cancelled.clone(),
);
// Trigger initial background resolutions if caches were missing/invalid
trigger_initial_resolutions(
&mut app,
&init_flags,
&channels.deps_req_tx,
&channels.files_req_tx,
&channels.services_req_tx,
&channels.sandbox_req_tx,
);
// Send initial query
send_query(&mut app, &channels.query_tx);
// Main event loop
run_event_loop(&mut terminal, &mut app, &mut channels).await;
// Cleanup on exit - this resets flags and flushes caches
cleanup_on_exit(&mut app, &channels);
// Drop channels to close request channels and stop workers from accepting new work
drop(channels);
// Restore terminal so user sees prompt
if !headless {
restore_terminal()?;
}
// Force immediate process exit to avoid waiting for background blocking tasks
// This is necessary because spawn_blocking tasks cannot be cancelled and would
// otherwise keep the tokio runtime alive until they complete
std::process::exit(0);
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/app/runtime/init.rs | src/app/runtime/init.rs | use std::{collections::HashMap, fs, path::Path, time::Instant};
use crate::index as pkgindex;
use crate::state::{AppState, PackageDetails, PackageItem};
use super::super::deps_cache;
use super::super::files_cache;
use super::super::sandbox_cache;
use super::super::services_cache;
/// What: Initialize the locale system: resolve locale, load translations, set up fallbacks.
///
/// Inputs:
/// - `app`: Application state to populate with locale and translations
/// - `locale_pref`: Locale preference from `settings.conf` (empty = auto-detect)
/// - `_prefs`: Settings struct (unused but kept for future use)
///
/// Output:
/// - Populates `app.locale`, `app.translations`, and `app.translations_fallback`
///
/// Details:
/// - Resolves locale using fallback chain (settings -> system -> default)
/// - Loads English fallback translations first (required)
/// - Loads primary locale translations if different from English
/// - Handles errors gracefully: falls back to English if locale file missing/invalid
/// - Logs warnings for missing files but continues execution
pub fn initialize_locale_system(
app: &mut AppState,
locale_pref: &str,
_prefs: &crate::theme::Settings,
) {
// Get paths - try both development and installed locations
let locales_dir = crate::i18n::find_locales_dir().unwrap_or_else(|| {
std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("config")
.join("locales")
});
let Some(i18n_config_path) = crate::i18n::find_config_file("i18n.yml") else {
tracing::error!(
"i18n config file not found in development or installed locations. Using default locale 'en-US'."
);
app.locale = "en-US".to_string();
app.translations = std::collections::HashMap::new();
app.translations_fallback = std::collections::HashMap::new();
return;
};
// Resolve locale
let resolver = crate::i18n::LocaleResolver::new(&i18n_config_path);
let resolved_locale = resolver.resolve(locale_pref);
tracing::info!(
"Resolved locale: '{}' (from settings: '{}')",
&resolved_locale,
if locale_pref.trim().is_empty() {
"<auto-detect>"
} else {
locale_pref
}
);
app.locale.clone_from(&resolved_locale);
// Load translations
let mut loader = crate::i18n::LocaleLoader::new(locales_dir);
// Load fallback (English) translations first - this is required
match loader.load("en-US") {
Ok(fallback) => {
let key_count = fallback.len();
app.translations_fallback = fallback;
tracing::debug!("Loaded English fallback translations ({} keys)", key_count);
}
Err(e) => {
tracing::error!(
"Failed to load English fallback translations: {}. Application may show untranslated keys.",
e
);
app.translations_fallback = std::collections::HashMap::new();
}
}
// Load primary locale translations
if resolved_locale == "en-US" {
// Already loaded English as fallback, use it as primary too
app.translations = app.translations_fallback.clone();
tracing::debug!("Using English as primary locale");
} else {
match loader.load(&resolved_locale) {
Ok(translations) => {
let key_count = translations.len();
app.translations = translations;
tracing::info!(
"Loaded translations for locale '{}' ({} keys)",
resolved_locale,
key_count
);
// Debug: Check if specific keys exist
let test_keys = [
"app.details.footer.search_hint",
"app.details.footer.confirm_installation",
];
for key in &test_keys {
if app.translations.contains_key(*key) {
tracing::debug!(" β Key '{}' found in translations", key);
} else {
tracing::debug!(" β Key '{}' NOT found in translations", key);
}
}
}
Err(e) => {
tracing::warn!(
"Failed to load translations for locale '{}': {}. Using English fallback.",
resolved_locale,
e
);
// Use empty map - translate_with_fallback will use English fallback
app.translations = std::collections::HashMap::new();
}
}
}
}
/// What: Initialize application state: load settings, caches, and persisted data.
///
/// Inputs:
/// - `app`: Application state to initialize
/// - `dry_run_flag`: When `true`, install/remove/downgrade actions are displayed but not executed
/// - `headless`: When `true`, skip terminal-dependent operations
///
/// Output:
/// - Returns flags indicating which caches need background resolution
///
/// Details:
/// - Migrates legacy configs and loads settings
/// - Loads persisted caches (details, recent, install list, dependencies, files, services, sandbox)
/// - Initializes locale system
/// - Checks for GNOME terminal if on GNOME desktop
#[allow(clippy::struct_excessive_bools)]
pub struct InitFlags {
/// Whether dependency resolution is needed (cache missing or invalid).
pub needs_deps_resolution: bool,
/// Whether file analysis is needed (cache missing or invalid).
pub needs_files_resolution: bool,
/// Whether service analysis is needed (cache missing or invalid).
pub needs_services_resolution: bool,
/// Whether sandbox analysis is needed (cache missing or invalid).
pub needs_sandbox_resolution: bool,
}
/// What: Load a cache with signature validation, returning whether resolution is needed.
///
/// Inputs:
/// - `install_list`: Current install list to compute signature from
/// - `cache_path`: Path to the cache file
/// - `compute_signature`: Function to compute signature from install list
/// - `load_cache`: Function to load cache from path and signature
/// - `cache_name`: Name of the cache for logging
///
/// Output:
/// - `(Option<T>, bool)` where first is the loaded cache (if valid) and second indicates if resolution is needed
///
/// Details:
/// - Returns `(None, true)` if install list is empty or cache is missing/invalid
/// - Returns `(Some(cache), false)` if cache is valid
fn load_cache_with_signature<T>(
install_list: &[crate::state::PackageItem],
cache_path: &std::path::PathBuf,
compute_signature: impl Fn(&[crate::state::PackageItem]) -> Vec<String>,
load_cache: impl Fn(&std::path::PathBuf, &[String]) -> Option<T>,
cache_name: &str,
) -> (Option<T>, bool) {
if install_list.is_empty() {
return (None, false);
}
let signature = compute_signature(install_list);
load_cache(cache_path, &signature).map_or_else(
|| {
tracing::info!(
"{} cache missing or invalid, will trigger background resolution",
cache_name
);
(None, true)
},
|cached| (Some(cached), false),
)
}
/// What: Ensure cache directories exist before writing placeholder files.
///
/// Inputs:
/// - `path`: Target cache file path whose parent directory should exist.
///
/// Output:
/// - Parent directory is created if missing; logs a warning on failure.
///
/// Details:
/// - No-op when the path has no parent.
fn ensure_cache_parent_dir(path: &Path) {
if let Some(parent) = path.parent()
&& let Err(error) = fs::create_dir_all(parent)
{
tracing::warn!(
path = %parent.display(),
%error,
"[Init] Failed to create cache directory"
);
}
}
/// What: Create empty cache files at startup so they always exist on disk.
///
/// Inputs:
/// - `app`: Application state providing cache paths.
///
/// Output:
/// - Writes empty dependency, file, service, and sandbox caches if the files are missing.
///
/// Details:
/// - Uses empty signatures and payloads; leaves existing files untouched.
/// - Ensures parent directories exist before writing.
fn initialize_cache_files(app: &AppState) {
let empty_signature: Vec<String> = Vec::new();
if !app.deps_cache_path.exists() {
ensure_cache_parent_dir(&app.deps_cache_path);
deps_cache::save_cache(&app.deps_cache_path, &empty_signature, &[]);
tracing::debug!(
path = %app.deps_cache_path.display(),
"[Init] Created empty dependency cache"
);
}
if !app.files_cache_path.exists() {
ensure_cache_parent_dir(&app.files_cache_path);
files_cache::save_cache(&app.files_cache_path, &empty_signature, &[]);
tracing::debug!(
path = %app.files_cache_path.display(),
"[Init] Created empty file cache"
);
}
if !app.services_cache_path.exists() {
ensure_cache_parent_dir(&app.services_cache_path);
services_cache::save_cache(&app.services_cache_path, &empty_signature, &[]);
tracing::debug!(
path = %app.services_cache_path.display(),
"[Init] Created empty service cache"
);
}
if !app.sandbox_cache_path.exists() {
ensure_cache_parent_dir(&app.sandbox_cache_path);
sandbox_cache::save_cache(&app.sandbox_cache_path, &empty_signature, &[]);
tracing::debug!(
path = %app.sandbox_cache_path.display(),
"[Init] Created empty sandbox cache"
);
}
}
/// What: Apply settings from configuration to application state.
///
/// Inputs:
/// - `app`: Application state to update
/// - `prefs`: Settings to apply
///
/// Output: None (modifies app state in place)
///
/// Details:
/// - Applies layout percentages, keymap, sort mode, package marker, and pane visibility
pub fn apply_settings_to_app_state(app: &mut AppState, prefs: &crate::theme::Settings) {
app.layout_left_pct = prefs.layout_left_pct;
app.layout_center_pct = prefs.layout_center_pct;
app.layout_right_pct = prefs.layout_right_pct;
app.keymap = prefs.keymap.clone();
app.sort_mode = prefs.sort_mode;
app.package_marker = prefs.package_marker;
app.show_recent_pane = prefs.show_recent_pane;
app.show_install_pane = prefs.show_install_pane;
app.show_keybinds_footer = prefs.show_keybinds_footer;
app.search_normal_mode = prefs.search_startup_mode;
app.fuzzy_search_enabled = prefs.fuzzy_search;
app.installed_packages_mode = prefs.installed_packages_mode;
app.app_mode = if prefs.start_in_news {
crate::state::types::AppMode::News
} else {
crate::state::types::AppMode::Package
};
app.news_filter_show_arch_news = prefs.news_filter_show_arch_news;
app.news_filter_show_advisories = prefs.news_filter_show_advisories;
app.news_filter_show_pkg_updates = prefs.news_filter_show_pkg_updates;
app.news_filter_show_aur_updates = prefs.news_filter_show_aur_updates;
app.news_filter_show_aur_comments = prefs.news_filter_show_aur_comments;
app.news_filter_installed_only = prefs.news_filter_installed_only;
app.news_max_age_days = prefs.news_max_age_days;
// Recompute news results with loaded filters/age
app.refresh_news_results();
}
/// What: Check if GNOME terminal is needed and set modal if required.
///
/// Inputs:
/// - `app`: Application state to update
/// - `headless`: When `true`, skip the check
///
/// Output: None (modifies app state in place)
///
/// Details:
/// - Checks if running on GNOME desktop without `gnome-terminal` or `gnome-console`/`kgx`
/// - Sets modal to `GnomeTerminalPrompt` if terminal is missing
fn check_gnome_terminal(app: &mut AppState, headless: bool) {
if headless {
return;
}
let is_gnome = std::env::var("XDG_CURRENT_DESKTOP")
.ok()
.is_some_and(|v| v.to_uppercase().contains("GNOME"));
if !is_gnome {
return;
}
let has_gterm = crate::install::command_on_path("gnome-terminal");
let has_gconsole =
crate::install::command_on_path("gnome-console") || crate::install::command_on_path("kgx");
if !(has_gterm || has_gconsole) {
app.modal = crate::state::Modal::GnomeTerminalPrompt;
}
}
/// What: Load details cache from disk.
///
/// Inputs:
/// - `app`: Application state to update
///
/// Output: None (modifies app state in place)
///
/// Details:
/// - Attempts to deserialize details cache from JSON file
fn load_details_cache(app: &mut AppState) {
if let Ok(s) = std::fs::read_to_string(&app.cache_path)
&& let Ok(map) = serde_json::from_str::<HashMap<String, PackageDetails>>(&s)
{
app.details_cache = map;
tracing::info!(path = %app.cache_path.display(), "loaded details cache");
}
}
/// What: Load recent searches from disk.
///
/// Inputs:
/// - `app`: Application state to update
///
/// Output: None (modifies app state in place)
///
/// Details:
/// - Attempts to deserialize recent searches list from JSON file
/// - Selects first item if list is not empty
fn load_recent_searches(app: &mut AppState) {
if let Ok(s) = std::fs::read_to_string(&app.recent_path)
&& let Ok(list) = serde_json::from_str::<Vec<String>>(&s)
{
let count = list.len();
app.load_recent_items(&list);
if count > 0 {
app.history_state.select(Some(0));
}
tracing::info!(
path = %app.recent_path.display(),
count = count,
"loaded recent searches"
);
}
}
/// What: Load install list from disk.
///
/// Inputs:
/// - `app`: Application state to update
///
/// Output: None (modifies app state in place)
///
/// Details:
/// - Attempts to deserialize install list from JSON file
/// - Selects first item if list is not empty
fn load_install_list(app: &mut AppState) {
if let Ok(s) = std::fs::read_to_string(&app.install_path)
&& let Ok(list) = serde_json::from_str::<Vec<PackageItem>>(&s)
{
app.install_list = list;
if !app.install_list.is_empty() {
app.install_state.select(Some(0));
}
tracing::info!(
path = %app.install_path.display(),
count = app.install_list.len(),
"loaded install list"
);
}
}
/// What: Load news read URLs from disk.
///
/// Inputs:
/// - `app`: Application state to update
///
/// Output: None (modifies app state in place)
///
/// Details:
/// - Attempts to deserialize news read URLs set from JSON file
fn load_news_read_urls(app: &mut AppState) {
if let Ok(s) = std::fs::read_to_string(&app.news_read_path)
&& let Ok(set) = serde_json::from_str::<std::collections::HashSet<String>>(&s)
{
app.news_read_urls = set;
tracing::info!(
path = %app.news_read_path.display(),
count = app.news_read_urls.len(),
"loaded read news urls"
);
}
}
/// What: Load news read IDs from disk (feed-level tracking).
///
/// Inputs:
/// - `app`: Application state to update
///
/// Output: None (modifies app state in place)
///
/// Details:
/// - Attempts to deserialize news read IDs set from JSON file.
/// - If no IDs file is found, falls back to populated `news_read_urls` for migration.
fn load_news_read_ids(app: &mut AppState) {
if let Ok(s) = std::fs::read_to_string(&app.news_read_ids_path)
&& let Ok(set) = serde_json::from_str::<std::collections::HashSet<String>>(&s)
{
app.news_read_ids = set;
tracing::info!(
path = %app.news_read_ids_path.display(),
count = app.news_read_ids.len(),
"loaded read news ids"
);
return;
}
if app.news_read_ids.is_empty() && !app.news_read_urls.is_empty() {
app.news_read_ids.extend(app.news_read_urls.iter().cloned());
tracing::info!(
copied = app.news_read_ids.len(),
"seeded news read ids from legacy URL set"
);
app.news_read_ids_dirty = true;
}
}
/// What: Load announcement read IDs from disk.
///
/// Inputs:
/// - `app`: Application state to update
///
/// Output: None (modifies app state in place)
///
/// Details:
/// - Attempts to deserialize announcement read IDs set from JSON file
/// - Handles both old format (single hash) and new format (set of IDs) for migration
fn load_announcement_state(app: &mut AppState) {
// Try old format for migration ({ "hash": "..." })
/// What: Legacy announcement read state structure.
///
/// Inputs: Deserialized from old announcement read file.
///
/// Output: Old state structure for migration.
///
/// Details: Used for migrating from old announcement read state format.
#[derive(serde::Deserialize)]
struct OldAnnouncementReadState {
/// Announcement hash if read.
hash: Option<String>,
}
if let Ok(s) = std::fs::read_to_string(&app.announcement_read_path) {
// Try new format first (HashSet<String>)
if let Ok(ids) = serde_json::from_str::<std::collections::HashSet<String>>(&s) {
app.announcements_read_ids = ids;
tracing::info!(
path = %app.announcement_read_path.display(),
count = app.announcements_read_ids.len(),
"loaded announcement read IDs"
);
return;
}
if let Ok(old_state) = serde_json::from_str::<OldAnnouncementReadState>(&s)
&& let Some(hash) = old_state.hash
{
app.announcements_read_ids.insert(format!("hash:{hash}"));
app.announcement_dirty = true; // Mark dirty to migrate to new format
tracing::info!(
path = %app.announcement_read_path.display(),
"migrated old announcement read state"
);
}
}
}
/// What: Check for version-embedded announcement and show modal if not read.
///
/// Inputs:
/// - `app`: Application state to update
///
/// Output: None (modifies app state in place)
///
/// Details:
/// - Checks embedded announcements for current app version
/// - If version announcement exists and hasn't been marked as read, shows modal
fn check_version_announcement(app: &mut AppState) {
const CURRENT_VERSION: &str = env!("CARGO_PKG_VERSION");
// Extract base version (X.X.X) from current version, ignoring suffixes
let current_base_version = crate::announcements::extract_base_version(CURRENT_VERSION);
// Find announcement matching the base version (compares only X.X.X part)
if let Some(announcement) = crate::announcements::VERSION_ANNOUNCEMENTS
.iter()
.find(|a| {
let announcement_base_version = crate::announcements::extract_base_version(a.version);
announcement_base_version == current_base_version
})
{
// Use full current version (including suffix) for the ID
// This ensures announcements show again when suffix changes (e.g., 0.6.0-pr#85 -> 0.6.0-pr#86)
let version_id = format!("v{CURRENT_VERSION}");
// Check if this version announcement has been marked as read
if app.announcements_read_ids.contains(&version_id) {
tracing::info!(
current_version = CURRENT_VERSION,
base_version = %current_base_version,
"version announcement already marked as read"
);
return;
}
// Show version announcement modal
app.modal = crate::state::Modal::Announcement {
title: announcement.title.to_string(),
content: announcement.content.to_string(),
id: version_id,
scroll: 0,
};
tracing::info!(
current_version = CURRENT_VERSION,
base_version = %current_base_version,
announcement_version = announcement.version,
"showing version announcement modal"
);
}
// Note: Remote announcements will be queued if they arrive while embedded is showing
// and will be shown when embedded is dismissed via show_next_pending_announcement()
}
/// What: Initialize application state by loading settings, caches, and persisted data.
///
/// Inputs:
/// - `app`: Mutable application state to initialize
/// - `dry_run_flag`: Whether to enable dry-run mode for this session
/// - `headless`: Whether running in headless/test mode
///
/// Output:
/// - Returns `InitFlags` indicating which caches need background resolution
///
/// Details:
/// - Loads and migrates configuration files
/// - Initializes locale system and translations
/// - Loads persisted data: recent searches, install list, details cache, dependency/file/service/sandbox caches
/// - Loads news read URLs and announcement state
/// - Loads official package index from disk
/// - Checks for version-embedded announcements
pub fn initialize_app_state(app: &mut AppState, dry_run_flag: bool, headless: bool) -> InitFlags {
app.dry_run = if dry_run_flag {
true
} else {
crate::theme::settings().app_dry_run_default
};
app.last_input_change = Instant::now();
// Log resolved configuration/state file locations at startup
tracing::info!(
recent = %app.recent_path.display(),
install = %app.install_path.display(),
details_cache = %app.cache_path.display(),
index = %app.official_index_path.display(),
news_read = %app.news_read_path.display(),
news_read_ids = %app.news_read_ids_path.display(),
announcement_read = %app.announcement_read_path.display(),
"resolved state file paths"
);
// Migrate legacy single-file config to split files before reading settings
crate::theme::maybe_migrate_legacy_confs();
let prefs = crate::theme::settings();
// Ensure config has all known settings keys (non-destructive append)
crate::theme::ensure_settings_keys_present(&prefs);
apply_settings_to_app_state(app, &prefs);
// Initialize locale system
initialize_locale_system(app, &prefs.locale, &prefs);
check_gnome_terminal(app, headless);
// Show NewsSetup modal on first launch if not configured
if !headless && !prefs.startup_news_configured {
// Only show if no other modal is already set (e.g., GnomeTerminalPrompt)
if matches!(app.modal, crate::state::Modal::None) {
app.modal = crate::state::Modal::NewsSetup {
show_arch_news: prefs.startup_news_show_arch_news,
show_advisories: prefs.startup_news_show_advisories,
show_aur_updates: prefs.startup_news_show_aur_updates,
show_aur_comments: prefs.startup_news_show_aur_comments,
show_pkg_updates: prefs.startup_news_show_pkg_updates,
max_age_days: prefs.startup_news_max_age_days,
cursor: 0,
};
}
} else if !headless && prefs.startup_news_configured {
// Always fetch fresh news in background (using last startup timestamp for incremental updates)
// Show loading toast while fetching, but cached items will be displayed immediately
app.news_loading = true;
app.toast_message = Some(crate::i18n::t(app, "app.news_button.loading"));
app.toast_expires_at = None; // No expiration - toast stays until news loading completes
}
// Check faillock status at startup
if !headless {
let username = std::env::var("USER").unwrap_or_else(|_| "user".to_string());
let (is_locked, lockout_until, remaining_minutes) =
crate::logic::faillock::get_lockout_info(&username);
app.faillock_locked = is_locked;
app.faillock_lockout_until = lockout_until;
app.faillock_remaining_minutes = remaining_minutes;
}
load_details_cache(app);
load_recent_searches(app);
load_install_list(app);
initialize_cache_files(app);
// Load dependency cache after install list is loaded (but before channels are created)
let (deps_cache, needs_deps_resolution) = load_cache_with_signature(
&app.install_list,
&app.deps_cache_path,
deps_cache::compute_signature,
deps_cache::load_cache,
"dependency",
);
if let Some(cached_deps) = deps_cache {
app.install_list_deps = cached_deps;
tracing::info!(
path = %app.deps_cache_path.display(),
count = app.install_list_deps.len(),
"loaded dependency cache"
);
}
// Load file cache after install list is loaded (but before channels are created)
let (files_cache, needs_files_resolution) = load_cache_with_signature(
&app.install_list,
&app.files_cache_path,
files_cache::compute_signature,
files_cache::load_cache,
"file",
);
if let Some(cached_files) = files_cache {
app.install_list_files = cached_files;
tracing::info!(
path = %app.files_cache_path.display(),
count = app.install_list_files.len(),
"loaded file cache"
);
}
// Load service cache after install list is loaded (but before channels are created)
let (services_cache, needs_services_resolution) = load_cache_with_signature(
&app.install_list,
&app.services_cache_path,
services_cache::compute_signature,
services_cache::load_cache,
"service",
);
if let Some(cached_services) = services_cache {
app.install_list_services = cached_services;
tracing::info!(
path = %app.services_cache_path.display(),
count = app.install_list_services.len(),
"loaded service cache"
);
}
// Load sandbox cache after install list is loaded (but before channels are created)
let (sandbox_cache, needs_sandbox_resolution) = load_cache_with_signature(
&app.install_list,
&app.sandbox_cache_path,
sandbox_cache::compute_signature,
sandbox_cache::load_cache,
"sandbox",
);
if let Some(cached_sandbox) = sandbox_cache {
app.install_list_sandbox = cached_sandbox;
tracing::info!(
path = %app.sandbox_cache_path.display(),
count = app.install_list_sandbox.len(),
"loaded sandbox cache"
);
}
load_news_read_urls(app);
load_news_read_ids(app);
load_announcement_state(app);
pkgindex::load_from_disk(&app.official_index_path);
// Check for version-embedded announcement after loading state
check_version_announcement(app);
tracing::info!(
path = %app.official_index_path.display(),
"attempted to load official index from disk"
);
InitFlags {
needs_deps_resolution,
needs_files_resolution,
needs_services_resolution,
needs_sandbox_resolution,
}
}
/// What: Trigger initial background resolution for caches that were missing or invalid.
///
/// Inputs:
/// - `app`: Application state
/// - `flags`: Initialization flags indicating which caches need resolution
/// - `deps_req_tx`: Channel sender for dependency resolution requests
/// - `files_req_tx`: Channel sender for file resolution requests (with action)
/// - `services_req_tx`: Channel sender for service resolution requests
/// - `sandbox_req_tx`: Channel sender for sandbox resolution requests
///
/// Output:
/// - Sets resolution flags and sends requests to background workers
///
/// Details:
/// - Only triggers resolution if cache was missing/invalid and install list is not empty
pub fn trigger_initial_resolutions(
app: &mut AppState,
flags: &InitFlags,
deps_req_tx: &tokio::sync::mpsc::UnboundedSender<(
Vec<PackageItem>,
crate::state::modal::PreflightAction,
)>,
files_req_tx: &tokio::sync::mpsc::UnboundedSender<(
Vec<PackageItem>,
crate::state::modal::PreflightAction,
)>,
services_req_tx: &tokio::sync::mpsc::UnboundedSender<(
Vec<PackageItem>,
crate::state::modal::PreflightAction,
)>,
sandbox_req_tx: &tokio::sync::mpsc::UnboundedSender<Vec<PackageItem>>,
) {
if flags.needs_deps_resolution && !app.install_list.is_empty() {
app.deps_resolving = true;
// Initial resolution is always for Install action (install_list)
let _ = deps_req_tx.send((
app.install_list.clone(),
crate::state::modal::PreflightAction::Install,
));
}
if flags.needs_files_resolution && !app.install_list.is_empty() {
app.files_resolving = true;
// Initial resolution is always for Install action (install_list)
let _ = files_req_tx.send((
app.install_list.clone(),
crate::state::modal::PreflightAction::Install,
));
}
if flags.needs_services_resolution && !app.install_list.is_empty() {
app.services_resolving = true;
let _ = services_req_tx.send((
app.install_list.clone(),
crate::state::modal::PreflightAction::Install,
));
}
if flags.needs_sandbox_resolution && !app.install_list.is_empty() {
app.sandbox_resolving = true;
let _ = sandbox_req_tx.send(app.install_list.clone());
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::app::runtime::background::Channels;
/// What: Provide a baseline `AppState` for initialization tests.
///
/// Inputs: None
/// Output: Fresh `AppState` with default values
fn new_app() -> AppState {
AppState::default()
}
#[test]
/// What: Verify that `initialize_locale_system` sets default locale when config file is missing.
///
/// Inputs:
/// - App state with default locale
/// - Empty locale preference
///
/// Output:
/// - Locale is set to "en-US" when config file is missing
/// - Translations maps are initialized (may be empty)
///
/// Details:
/// - Tests graceful fallback when i18n config is not found
fn initialize_locale_system_fallback_when_config_missing() {
let mut app = new_app();
let prefs = crate::theme::Settings::default();
// This will fall back to en-US if config file is missing
initialize_locale_system(&mut app, "", &prefs);
// Locale should be set (either resolved or default)
assert!(!app.locale.is_empty());
// Translations maps should be initialized
assert!(app.translations.is_empty() || !app.translations.is_empty());
assert!(app.translations_fallback.is_empty() || !app.translations_fallback.is_empty());
}
#[test]
/// What: Verify that `initialize_app_state` sets `dry_run` flag correctly.
///
/// Inputs:
/// - `AppState`
/// - `dry_run_flag` = true
/// - headless = false
///
/// Output:
/// - `app.dry_run` is set to true
/// - `InitFlags` are returned
///
/// Details:
/// - Tests that `dry_run` flag is properly initialized
fn initialize_app_state_sets_dry_run_flag() {
let mut app = new_app();
let flags = initialize_app_state(&mut app, true, false);
assert!(app.dry_run);
// Flags should be returned (InitFlags struct is created)
// The actual values depend on cache state, so we just verify flags exist
let _ = flags;
}
#[test]
/// What: Verify that `initialize_app_state` loads settings correctly.
///
/// Inputs:
/// - `AppState`
/// - `dry_run_flag` = false
/// - headless = false
///
/// Output:
/// - `AppState` has layout percentages set
/// - Keymap is set
/// - Sort mode is set
///
/// Details:
/// - Tests that settings are properly applied to app state
fn initialize_app_state_loads_settings() {
let mut app = new_app();
let _flags = initialize_app_state(&mut app, false, false);
// Settings should be loaded (values depend on config, but should be set)
assert!(app.layout_left_pct > 0);
assert!(app.layout_center_pct > 0);
assert!(app.layout_right_pct > 0);
// Keymap should be initialized (it's a struct, not a string)
// Just verify it's not the default empty state by checking a field
// (KeyMap has many fields, we just verify it's been set)
}
#[test]
/// What: Verify that `initialize_cache_files` creates placeholder cache files when missing.
///
/// Inputs:
/// - `AppState` with cache paths pointed to temporary locations that do not yet exist.
///
/// Output:
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | true |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/app/runtime/cleanup.rs | src/app/runtime/cleanup.rs | use crate::state::AppState;
use super::super::persist::{
maybe_flush_announcement_read, maybe_flush_cache, maybe_flush_deps_cache,
maybe_flush_files_cache, maybe_flush_install, maybe_flush_news_bookmarks,
maybe_flush_news_content_cache, maybe_flush_news_read, maybe_flush_news_read_ids,
maybe_flush_news_recent, maybe_flush_news_seen_aur_comments, maybe_flush_news_seen_versions,
maybe_flush_pkgbuild_parse_cache, maybe_flush_recent, maybe_flush_sandbox_cache,
maybe_flush_services_cache,
};
use super::background::Channels;
/// What: Clean up application state and flush caches on exit.
///
/// Inputs:
/// - `app`: Application state
/// - `channels`: Communication channels (will be dropped after this function returns)
///
/// Output: None
///
/// Details:
/// - Resets resolution flags to prevent background tasks from blocking
/// - Cancels preflight operations and clears preflight queues
/// - Signals event reading thread to exit
/// - Flushes all pending cache writes (details, recent, news, install, preflight data)
/// - Note: Request channel senders will be dropped when channels is dropped,
/// causing workers to stop accepting new work. Already-running blocking tasks
/// will complete in the background but won't block app exit.
pub fn cleanup_on_exit(app: &mut AppState, channels: &Channels) {
// Reset resolution flags on exit to ensure clean shutdown
// This prevents background tasks from blocking if they're still running
tracing::debug!("[Runtime] Main loop exited, resetting resolution flags");
app.deps_resolving = false;
app.files_resolving = false;
app.services_resolving = false;
app.sandbox_resolving = false;
// Cancel preflight operations and reset preflight flags
// This ensures clean shutdown when app closes during preflight data loading
tracing::debug!("[Runtime] Cancelling preflight operations and resetting flags");
app.preflight_cancelled
.store(true, std::sync::atomic::Ordering::Relaxed);
app.preflight_summary_resolving = false;
app.preflight_deps_resolving = false;
app.preflight_files_resolving = false;
app.preflight_services_resolving = false;
app.preflight_sandbox_resolving = false;
// Clear preflight queues to prevent background workers from processing
app.preflight_summary_items = None;
app.preflight_deps_items = None;
app.preflight_files_items = None;
app.preflight_services_items = None;
app.preflight_sandbox_items = None;
// Signal event reading thread to exit immediately
channels
.event_thread_cancelled
.store(true, std::sync::atomic::Ordering::Relaxed);
maybe_flush_cache(app);
maybe_flush_recent(app);
maybe_flush_news_recent(app);
maybe_flush_news_bookmarks(app);
maybe_flush_news_content_cache(app);
maybe_flush_news_read(app);
maybe_flush_news_read_ids(app);
maybe_flush_news_seen_versions(app);
maybe_flush_news_seen_aur_comments(app);
maybe_flush_announcement_read(app);
maybe_flush_install(app);
maybe_flush_deps_cache(app);
maybe_flush_files_cache(app);
maybe_flush_services_cache(app);
maybe_flush_sandbox_cache(app);
maybe_flush_pkgbuild_parse_cache();
}
#[cfg(test)]
mod tests {
use super::*;
use crate::state::{PackageItem, Source, modal::PreflightAction};
/// What: Test that `cleanup_on_exit` properly cancels preflight operations.
///
/// Inputs:
/// - App state with packages in install list and preflight operations active
///
/// Output:
/// - All preflight flags are reset
/// - `preflight_cancelled` is set to true
/// - Preflight queues are cleared
///
/// Details:
/// - Simulates the scenario where app closes during preflight data loading
/// - Verifies that cleanup properly handles preflight cancellation
#[tokio::test]
async fn cleanup_on_exit_cancels_preflight_operations() {
let mut app = AppState::default();
let channels = Channels::new(std::path::PathBuf::from("/tmp/test"));
// Set up install list with packages
let test_package = PackageItem {
name: "test-package".to_string(),
version: "1.0.0".to_string(),
description: "Test package".to_string(),
source: Source::Official {
repo: "core".to_string(),
arch: "x86_64".to_string(),
},
popularity: None,
out_of_date: None,
orphaned: false,
};
app.install_list.push(test_package.clone());
// Set preflight operations as active (simulating loading state)
app.preflight_summary_resolving = true;
app.preflight_deps_resolving = true;
app.preflight_files_resolving = true;
app.preflight_services_resolving = true;
app.preflight_sandbox_resolving = true;
// Set up preflight queues
app.preflight_summary_items = Some((vec![test_package.clone()], PreflightAction::Install));
app.preflight_deps_items = Some((vec![test_package.clone()], PreflightAction::Install));
app.preflight_files_items = Some(vec![test_package.clone()]);
app.preflight_services_items = Some(vec![test_package.clone()]);
app.preflight_sandbox_items = Some(vec![test_package]);
// Verify initial state
assert!(app.preflight_summary_resolving);
assert!(app.preflight_deps_resolving);
assert!(app.preflight_files_resolving);
assert!(app.preflight_services_resolving);
assert!(app.preflight_sandbox_resolving);
assert!(
!app.preflight_cancelled
.load(std::sync::atomic::Ordering::Relaxed)
);
assert!(app.preflight_summary_items.is_some());
assert!(app.preflight_deps_items.is_some());
assert!(app.preflight_files_items.is_some());
assert!(app.preflight_services_items.is_some());
assert!(app.preflight_sandbox_items.is_some());
// Call cleanup
cleanup_on_exit(&mut app, &channels);
// Verify all preflight flags are reset
assert!(!app.preflight_summary_resolving);
assert!(!app.preflight_deps_resolving);
assert!(!app.preflight_files_resolving);
assert!(!app.preflight_services_resolving);
assert!(!app.preflight_sandbox_resolving);
// Verify preflight_cancelled is set
assert!(
app.preflight_cancelled
.load(std::sync::atomic::Ordering::Relaxed)
);
// Verify preflight queues are cleared
assert!(app.preflight_summary_items.is_none());
assert!(app.preflight_deps_items.is_none());
assert!(app.preflight_files_items.is_none());
assert!(app.preflight_services_items.is_none());
assert!(app.preflight_sandbox_items.is_none());
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/app/runtime/event_loop.rs | src/app/runtime/event_loop.rs | use ratatui::Terminal;
use tokio::select;
use crate::i18n;
use crate::state::types::NewsFeedPayload;
use crate::state::{AppState, PackageItem};
use crate::ui::ui;
use crate::util::parse_update_entry;
use tracing::info;
use super::background::Channels;
use super::handlers::{
handle_add_to_install_list, handle_dependency_result, handle_details_update,
handle_file_result, handle_preview, handle_sandbox_result, handle_search_results,
handle_service_result,
};
use super::tick_handler::{
handle_comments_result, handle_news, handle_pkgbuild_result, handle_status,
handle_summary_result, handle_tick,
};
/// What: Parse updates entries from the `available_updates.txt` file.
///
/// Inputs:
/// - `updates_file`: Path to the updates file
///
/// Output:
/// - Vector of (name, `old_version`, `new_version`) tuples
///
/// Details:
/// - Parses format: "name - `old_version` -> name - `new_version`"
/// - Uses `parse_update_entry` helper function for parsing individual lines
fn parse_updates_file(updates_file: &std::path::Path) -> Vec<(String, String, String)> {
if updates_file.exists() {
std::fs::read_to_string(updates_file)
.ok()
.map(|content| {
content
.lines()
.filter_map(parse_update_entry)
.collect::<Vec<(String, String, String)>>()
})
.unwrap_or_default()
} else {
Vec::new()
}
}
/// What: Handle batch of items added to install list.
///
/// Inputs:
/// - `app`: Application state
/// - `channels`: Communication channels
/// - `first`: First item in the batch
///
/// Output: None (side effect: processes items)
///
/// Details:
/// - Batch-drains imported items arriving close together to avoid repeated redraws
fn handle_add_batch(app: &mut AppState, channels: &mut Channels, first: PackageItem) {
let mut batch = vec![first];
while let Ok(it) = channels.add_rx.try_recv() {
batch.push(it);
}
for it in batch {
handle_add_to_install_list(
app,
it,
&channels.deps_req_tx,
&channels.files_req_tx,
&channels.services_req_tx,
&channels.sandbox_req_tx,
);
}
}
/// What: Handle file result with logging.
///
/// Inputs:
/// - `app`: Application state
/// - `channels`: Communication channels
/// - `files`: File resolution results
///
/// Output: None (side effect: processes files)
fn handle_file_result_with_logging(
app: &mut AppState,
channels: &Channels,
files: &[crate::state::modal::PackageFileInfo],
) {
tracing::debug!(
"[Runtime] Received file result: {} entries for packages: {:?}",
files.len(),
files.iter().map(|f| &f.name).collect::<Vec<_>>()
);
for file_info in files {
tracing::debug!(
"[Runtime] Package '{}' - total={}, new={}, changed={}, removed={}, config={}",
file_info.name,
file_info.total_count,
file_info.new_count,
file_info.changed_count,
file_info.removed_count,
file_info.config_count
);
}
handle_file_result(app, files, &channels.tick_tx);
}
/// What: Handle remote announcement received from async fetch.
///
/// Inputs:
/// - `app`: Application state to update
/// - `announcement`: Remote announcement fetched from configured URL
///
/// Output: None (modifies app state in place)
///
/// Details:
fn handle_remote_announcement(
app: &mut AppState,
announcement: crate::announcements::RemoteAnnouncement,
) {
const CURRENT_VERSION: &str = env!("CARGO_PKG_VERSION");
// Check version range
if !crate::announcements::version_matches(
CURRENT_VERSION,
announcement.min_version.as_deref(),
announcement.max_version.as_deref(),
) {
tracing::debug!(
id = %announcement.id,
current_version = CURRENT_VERSION,
min_version = ?announcement.min_version,
max_version = ?announcement.max_version,
"announcement version range mismatch"
);
return;
}
// Check expiration
if crate::announcements::is_expired(announcement.expires.as_deref()) {
tracing::debug!(
id = %announcement.id,
expires = ?announcement.expires,
"announcement expired"
);
return;
}
// Check if already read
if app.announcements_read_ids.contains(&announcement.id) {
tracing::info!(
id = %announcement.id,
"remote announcement already marked as read"
);
return;
}
// Only show if no modal is currently displayed
if matches!(app.modal, crate::state::Modal::None) {
app.modal = crate::state::Modal::Announcement {
title: announcement.title,
content: announcement.content,
id: announcement.id,
scroll: 0,
};
tracing::info!("showing remote announcement modal");
} else {
// Queue announcement to show after current modal closes
let announcement_id = announcement.id.clone();
app.pending_announcements.push(announcement);
tracing::info!(
id = %announcement_id,
queue_size = app.pending_announcements.len(),
"queued remote announcement (modal already open)"
);
}
}
/// What: Handle index notification message.
///
/// Inputs:
/// - `app`: Application state
/// - `channels`: Communication channels
///
/// Output: `false` (continue event loop)
///
/// Details:
/// - Marks index loading as complete and triggers a tick
fn handle_index_notification(app: &mut AppState, channels: &Channels) -> bool {
app.loading_index = false;
let _ = channels.tick_tx.send(());
false
}
/// What: Handle updates list received from background worker.
///
/// Inputs:
/// - `app`: Application state
/// - `count`: Number of available updates
/// - `list`: List of update package names
///
/// Output: None (modifies app state in place)
///
/// Details:
/// - Updates app state with update count and list
/// - If pending updates modal is set, opens the updates modal
fn handle_updates_list(app: &mut AppState, count: usize, list: Vec<String>) {
app.updates_count = Some(count);
app.updates_list = list;
app.updates_loading = false;
if app.pending_updates_modal {
app.pending_updates_modal = false;
let updates_file = crate::theme::lists_dir().join("available_updates.txt");
let entries = parse_updates_file(&updates_file);
app.modal = crate::state::Modal::Updates {
entries,
scroll: 0,
selected: 0,
};
}
}
/// What: Apply filters and sorting to news feed items.
///
/// Inputs:
/// - `app`: Application state containing news feed data and filter flags.
/// - `payload`: News feed payload containing items and metadata.
///
/// Details:
/// - Does not clear `news_loading` flag here - it will be cleared when news modal is shown.
fn handle_news_feed_items(app: &mut AppState, payload: NewsFeedPayload) {
tracing::info!(
items_count = payload.items.len(),
"received aggregated news feed payload in event loop"
);
app.news_items = payload.items;
app.news_seen_pkg_versions = payload.seen_pkg_versions;
app.news_seen_pkg_versions_dirty = true;
app.news_seen_aur_comments = payload.seen_aur_comments;
app.news_seen_aur_comments_dirty = true;
match serde_json::to_string_pretty(&app.news_items) {
Ok(serialized) => {
if let Err(e) = std::fs::write(&app.news_feed_path, serialized) {
tracing::warn!(error = %e, path = ?app.news_feed_path, "failed to persist news feed cache");
}
}
Err(e) => tracing::warn!(error = %e, "failed to serialize news feed cache"),
}
app.refresh_news_results();
// News feed is now loaded - clear loading flag and toast
app.news_loading = false;
app.toast_message = None;
app.toast_expires_at = None;
info!(
fetched = app.news_items.len(),
visible = app.news_results.len(),
max_age_days = app.news_max_age_days.map(i64::from),
installed_only = app.news_filter_installed_only,
arch_on = app.news_filter_show_arch_news,
advisories_on = app.news_filter_show_advisories,
"news feed updated"
);
// Check for network errors and show a small toast
if crate::sources::take_network_error() {
app.toast_message = Some("Network error: some news sources unreachable".to_string());
app.toast_expires_at = Some(std::time::Instant::now() + std::time::Duration::from_secs(5));
}
}
/// What: Handle a single incremental news item from background continuation.
///
/// Inputs:
/// - `app`: Application state
/// - `item`: The news feed item to add
///
/// Details:
/// - Appends the item to `news_items` if not already present (by id).
/// - Refreshes filtered/sorted results.
/// - Persists the updated feed cache to disk.
fn handle_incremental_news_item(app: &mut AppState, item: crate::state::types::NewsFeedItem) {
// Check if item already exists (by id)
if app.news_items.iter().any(|existing| existing.id == item.id) {
tracing::debug!(
item_id = %item.id,
"incremental news item already exists, skipping"
);
return;
}
tracing::info!(
item_id = %item.id,
source = ?item.source,
title = %item.title,
"received incremental news item"
);
// Add the new item
app.news_items.push(item);
// Refresh filtered/sorted results
app.refresh_news_results();
// Persist to disk
if let Ok(serialized) = serde_json::to_string_pretty(&app.news_items)
&& let Err(e) = std::fs::write(&app.news_feed_path, serialized)
{
tracing::warn!(error = %e, path = ?app.news_feed_path, "failed to persist incremental news feed cache");
}
}
/// What: Handle news article content response.
///
/// Inputs:
/// - `app`: Application state
/// - `url`: The URL that was fetched
/// - `content`: The article content
fn handle_news_content(app: &mut AppState, url: &str, content: String) {
// Only cache successful content, not error messages
// Error messages start with "Failed to load content:" and should not be persisted
let is_error = content.starts_with("Failed to load content:");
if is_error {
tracing::debug!(
url,
"news_content: not caching error response to allow retry"
);
} else {
app.news_content_cache
.insert(url.to_string(), content.clone());
app.news_content_cache_dirty = true;
}
// Update displayed content if this is for the currently selected item
if let Some(selected_url) = app
.news_results
.get(app.news_selected)
.and_then(|selected| selected.url.as_deref())
&& selected_url == url
{
tracing::debug!(
url,
len = content.len(),
selected = app.news_selected,
"news_content: response matches selection"
);
app.news_content_loading = false;
app.news_content = if content.is_empty() {
None
} else {
Some(content)
};
} else {
// Clear loading flag even if selection changed; a new request will be issued on next tick.
tracing::debug!(
url,
len = content.len(),
selected = app.news_selected,
selected_url = ?app
.news_results
.get(app.news_selected)
.and_then(|selected| selected.url.as_deref()),
"news_content: response does not match current selection"
);
app.news_content_loading = false;
}
app.news_content_loading_since = None;
}
/// What: Process one iteration of channel message handling.
///
/// Inputs:
/// - `app`: Application state
/// - `channels`: Communication channels for background workers
///
/// Output: `true` if the event loop should exit, `false` to continue
///
/// Details:
/// - Waits for and processes a single message from any channel
/// - Returns `true` when an event handler indicates exit (e.g., quit command)
/// - Uses select! to wait on multiple channels concurrently
#[allow(clippy::cognitive_complexity)]
async fn process_channel_messages(app: &mut AppState, channels: &mut Channels) -> bool {
select! {
Some(ev) = channels.event_rx.recv() => {
crate::events::handle_event(
&ev,
app,
&channels.query_tx,
&channels.details_req_tx,
&channels.preview_tx,
&channels.add_tx,
&channels.pkgb_req_tx,
&channels.comments_req_tx,
)
}
Some(()) = channels.index_notify_rx.recv() => {
handle_index_notification(app, channels)
}
Some(new_results) = channels.results_rx.recv() => {
handle_search_results(
app,
new_results,
&channels.details_req_tx,
&channels.index_notify_tx,
);
false
}
Some(details) = channels.details_res_rx.recv() => {
handle_details_update(app, &details, &channels.tick_tx);
false
}
Some(item) = channels.preview_rx.recv() => {
handle_preview(app, item, &channels.details_req_tx);
false
}
Some(first) = channels.add_rx.recv() => {
handle_add_batch(app, channels, first);
false
}
Some(deps) = channels.deps_res_rx.recv() => {
handle_dependency_result(app, &deps, &channels.tick_tx);
false
}
Some(files) = channels.files_res_rx.recv() => {
handle_file_result_with_logging(app, channels, &files);
false
}
Some(services) = channels.services_res_rx.recv() => {
handle_service_result(app, &services, &channels.tick_tx);
false
}
Some(sandbox_info) = channels.sandbox_res_rx.recv() => {
handle_sandbox_result(app, &sandbox_info, &channels.tick_tx);
false
}
Some(summary_outcome) = channels.summary_res_rx.recv() => {
handle_summary_result(app, summary_outcome, &channels.tick_tx);
false
}
Some((pkgname, text)) = channels.pkgb_res_rx.recv() => {
handle_pkgbuild_result(app, pkgname, text, &channels.tick_tx);
false
}
Some((pkgname, result)) = channels.comments_res_rx.recv() => {
handle_comments_result(app, pkgname, result, &channels.tick_tx);
false
}
Some(feed) = channels.news_feed_rx.recv() => {
handle_news_feed_items(app, feed);
false
}
Some(item) = channels.news_incremental_rx.recv() => {
handle_incremental_news_item(app, item);
false
}
Some((url, content)) = channels.news_content_res_rx.recv() => {
handle_news_content(app, &url, content);
false
}
Some(msg) = channels.net_err_rx.recv() => {
tracing::warn!(error = %msg, "Network error received");
#[cfg(not(windows))]
{
// On Linux, show error to user via Alert modal
app.modal = crate::state::Modal::Alert {
message: msg,
};
}
// On Windows, only log (no popup)
false
}
Some(()) = channels.tick_rx.recv() => {
handle_tick(
app,
&channels.query_tx,
&channels.details_req_tx,
&channels.pkgb_req_tx,
&channels.deps_req_tx,
&channels.files_req_tx,
&channels.services_req_tx,
&channels.sandbox_req_tx,
&channels.summary_req_tx,
&channels.updates_tx,
&channels.executor_req_tx,
&channels.post_summary_req_tx,
&channels.news_content_req_tx,
);
false
}
Some(items) = channels.news_rx.recv() => {
tracing::info!(
items_count = items.len(),
news_loading_before = app.news_loading,
"received news items from channel"
);
handle_news(app, &items);
tracing::info!(
news_loading_after = app.news_loading,
modal = ?app.modal,
"handle_news completed"
);
false
}
Some(announcement) = channels.announcement_rx.recv() => {
handle_remote_announcement(app, announcement);
false
}
Some((txt, color)) = channels.status_rx.recv() => {
handle_status(app, &txt, color);
false
}
Some((count, list)) = channels.updates_rx.recv() => {
handle_updates_list(app, count, list);
false
}
Some(executor_output) = channels.executor_res_rx.recv() => {
handle_executor_output(app, executor_output);
false
}
Some(post_summary_data) = channels.post_summary_res_rx.recv() => {
handle_post_summary_result(app, post_summary_data);
false
}
else => false
}
}
/// What: Handle post-summary computation result.
///
/// Inputs:
/// - `app`: Application state
/// - `data`: Computed post-summary data
///
/// Details:
/// - Transitions from Loading modal to `PostSummary` modal
fn handle_post_summary_result(app: &mut AppState, data: crate::logic::summary::PostSummaryData) {
// Only transition if we're in Loading state
if matches!(app.modal, crate::state::Modal::Loading { .. }) {
tracing::debug!(
success = data.success,
changed_files = data.changed_files,
pacnew_count = data.pacnew_count,
pacsave_count = data.pacsave_count,
services_pending = data.services_pending.len(),
snapshot_label = ?data.snapshot_label,
"[EventLoop] Transitioning modal: Loading -> PostSummary"
);
app.modal = crate::state::Modal::PostSummary {
success: data.success,
changed_files: data.changed_files,
pacnew_count: data.pacnew_count,
pacsave_count: data.pacsave_count,
services_pending: data.services_pending,
snapshot_label: data.snapshot_label,
};
}
}
/// What: Handle successful executor completion for Install action.
///
/// Inputs:
/// - `app`: Mutable application state
/// - `items`: Package items that were installed
///
/// Output:
/// - None (modifies app state in place)
///
/// Details:
/// - Tracks installed packages and triggers refresh of installed packages pane
/// - Only tracks pending install names if items is non-empty (system updates use empty items)
fn handle_install_success(app: &mut AppState, items: &[crate::state::PackageItem]) {
// Only track pending install names if items is non-empty.
// System updates use empty items, and setting pending_install_names
// to empty would cause install_list to be cleared in tick handler
// due to vacuously true check (all elements of empty set satisfy any predicate).
if !items.is_empty() {
let installed_names: Vec<String> = items.iter().map(|p| p.name.clone()).collect();
// Set pending install names to track installation completion
app.pending_install_names = Some(installed_names);
}
// Trigger refresh of installed packages
app.refresh_installed_until =
Some(std::time::Instant::now() + std::time::Duration::from_secs(8));
// Refresh updates count after installation completes
app.refresh_updates = true;
tracing::info!(
"Install operation completed: triggered refresh of installed packages and updates"
);
}
/// What: Handle successful executor completion for Remove action.
///
/// Inputs:
/// - `app`: Mutable application state
/// - `items`: Package items that were removed
///
/// Output:
/// - None (modifies app state in place)
///
/// Details:
/// - Clears remove list and triggers refresh of installed packages pane
fn handle_remove_success(app: &mut AppState, items: &[crate::state::PackageItem]) {
let removed_names: Vec<String> = items.iter().map(|p| p.name.clone()).collect();
// Clear remove list
app.remove_list.clear();
app.remove_list_names.clear();
app.remove_state.select(None);
// Set pending remove names to track removal completion
app.pending_remove_names = Some(removed_names);
// Trigger refresh of installed packages
app.refresh_installed_until =
Some(std::time::Instant::now() + std::time::Duration::from_secs(8));
// Refresh updates count after removal completes
app.refresh_updates = true;
// Keep PreflightExec modal open so user can see completion message
// User can close it with Esc/q, and refresh happens in background
tracing::info!("Remove operation completed: cleared remove list and triggered refresh");
}
/// What: Handle successful executor completion for Downgrade action.
///
/// Inputs:
/// - `app`: Mutable application state
/// - `items`: Package items that were downgraded
///
/// Output:
/// - None (modifies app state in place)
///
/// Details:
/// - Clears downgrade list and triggers refresh of installed packages pane
fn handle_downgrade_success(app: &mut AppState, items: &[crate::state::PackageItem]) {
let downgraded_names: Vec<String> = items.iter().map(|p| p.name.clone()).collect();
// Clear downgrade list
app.downgrade_list.clear();
app.downgrade_list_names.clear();
app.downgrade_state.select(None);
// Set pending downgrade names to track downgrade completion
app.pending_remove_names = Some(downgraded_names);
// Trigger refresh of installed packages
app.refresh_installed_until =
Some(std::time::Instant::now() + std::time::Duration::from_secs(8));
// Refresh updates count after downgrade completes
app.refresh_updates = true;
// Keep PreflightExec modal open so user can see completion message
// User can close it with Esc/q, and refresh happens in background
tracing::info!("Downgrade operation completed: cleared downgrade list and triggered refresh");
}
/// What: Handle executor output and update UI state accordingly.
///
/// Inputs:
/// - `app`: Mutable application state
/// - `output`: Executor output to process
///
/// Output:
/// - None (modifies app state in place)
///
/// Details:
/// - Updates `PreflightExec` modal with log lines or completion status
/// - Processes `Line`, `ReplaceLastLine`, `Finished`, and `Error` outputs
/// - Handles success/failure cases for Install, Remove, and Downgrade actions
/// - Shows confirmation popup for AUR update when pacman fails
#[allow(clippy::too_many_lines)] // Function handles multiple executor output types and modal transitions (function has 187 lines)
fn handle_executor_output(app: &mut AppState, output: crate::install::ExecutorOutput) {
// Log what we received (at trace level to avoid spam)
match &output {
crate::install::ExecutorOutput::Line(line) => {
tracing::trace!(
"[EventLoop] Received executor line: {}...",
&line[..line.len().min(50)]
);
}
crate::install::ExecutorOutput::ReplaceLastLine(line) => {
tracing::trace!(
"[EventLoop] Received executor replace line: {}...",
&line[..line.len().min(50)]
);
}
crate::install::ExecutorOutput::Finished {
success,
exit_code,
failed_command: _,
} => {
tracing::debug!(
"[EventLoop] Received executor Finished: success={}, exit_code={:?}",
success,
exit_code
);
}
crate::install::ExecutorOutput::Error(err) => {
tracing::warn!("[EventLoop] Received executor Error: {}", err);
}
}
if let crate::state::Modal::PreflightExec {
ref mut log_lines,
ref mut abortable,
ref mut success,
ref items,
ref action,
..
} = app.modal
{
match output {
crate::install::ExecutorOutput::Line(line) => {
log_lines.push(line);
// Keep only last 1000 lines to avoid memory issues
if log_lines.len() > 1000 {
log_lines.remove(0);
}
tracing::debug!(
"[EventLoop] PreflightExec log_lines count: {}",
log_lines.len()
);
}
crate::install::ExecutorOutput::ReplaceLastLine(line) => {
// Replace the last line (for progress bar updates via \r)
if log_lines.is_empty() {
log_lines.push(line);
} else {
let last_idx = log_lines.len() - 1;
log_lines[last_idx] = line;
}
}
crate::install::ExecutorOutput::Finished {
success: exec_success,
exit_code,
failed_command: _,
} => {
tracing::info!(
"Received Finished: success={exec_success}, exit_code={exit_code:?}"
);
*abortable = false;
// Store the execution result in the modal
*success = Some(exec_success);
log_lines.push(String::new()); // Empty line before completion message
if exec_success {
let completion_msg = match action {
crate::state::PreflightAction::Install => {
"Installation successfully completed!".to_string()
}
crate::state::PreflightAction::Remove => {
"Removal successfully completed!".to_string()
}
crate::state::PreflightAction::Downgrade => {
"Downgrade successfully completed!".to_string()
}
};
log_lines.push(completion_msg);
tracing::info!(
"Added completion message, log_lines.len()={}",
log_lines.len()
);
// Clone items to avoid borrow checker issues when calling handlers
let items_clone = items.clone();
let action_clone = *action;
// Handle successful operations: refresh installed packages and update UI
match action_clone {
crate::state::PreflightAction::Install => {
handle_install_success(app, &items_clone);
}
crate::state::PreflightAction::Remove => {
handle_remove_success(app, &items_clone);
}
crate::state::PreflightAction::Downgrade => {
handle_downgrade_success(app, &items_clone);
}
}
} else {
log_lines.push(format!("Execution failed (exit code: {exit_code:?})"));
// If this was a system update (empty items) and AUR update is pending, show confirmation
if items.is_empty() && app.pending_aur_update_command.is_some() {
tracing::info!(
"[EventLoop] System update failed (exit_code: {:?}), AUR update pending - showing confirmation popup",
exit_code
);
// Preserve password and header_chips for AUR update if user confirms
// (they're already stored in app state, so we just need to show the modal)
// Determine which command failed by checking the command list
let failed_command_name = app
.pending_update_commands
.as_ref()
.and_then(|cmds| {
// Extract command name from the first command (since commands are chained with &&,
// the first command that fails stops execution)
cmds.first().map(|cmd| {
// Extract command name: "sudo pacman -Syu" -> "pacman", "paru -Sua" -> "paru"
if cmd.contains("pacman") {
"pacman"
} else if cmd.contains("paru") {
"paru"
} else if cmd.contains("yay") {
"yay"
} else if cmd.contains("reflector") {
"reflector"
} else if cmd.contains("pacman-mirrors") {
"pacman-mirrors"
} else if cmd.contains("eos-rankmirrors") {
"eos-rankmirrors"
} else if cmd.contains("cachyos-rate-mirrors") {
"cachyos-rate-mirrors"
} else {
"update command"
}
})
})
.unwrap_or("update command");
// Close PreflightExec and show confirmation modal
let exit_code_str =
exit_code.map_or_else(|| "unknown".to_string(), |c| c.to_string());
app.modal = crate::state::Modal::ConfirmAurUpdate {
message: format!(
"{}\n\n{}\n{}\n\n{}",
i18n::t_fmt2(
app,
"app.modals.confirm_aur_update.command_failed",
failed_command_name,
&exit_code_str
),
i18n::t(app, "app.modals.confirm_aur_update.continue_prompt"),
i18n::t(app, "app.modals.confirm_aur_update.warning"),
i18n::t(app, "app.modals.confirm_aur_update.hint")
),
};
} else {
tracing::debug!(
"[EventLoop] System update failed but no confirmation popup - items.is_empty(): {}, pending_aur_update_command.is_some(): {}",
items.is_empty(),
app.pending_aur_update_command.is_some()
);
}
}
}
crate::install::ExecutorOutput::Error(err) => {
*abortable = false;
log_lines.push(format!("Error: {err}"));
}
}
} else {
tracing::warn!(
"[EventLoop] Received executor output but modal is not PreflightExec, modal={:?}",
std::mem::discriminant(&app.modal)
);
}
}
/// What: Trigger startup news fetch using current startup news settings.
///
/// Inputs:
/// - `channels`: Communication channels for background workers
/// - `app`: Application state for read sets
///
/// Output: None
///
/// Details:
/// - Fetches news feed using startup news settings and sends to `news_tx` channel
/// - Called when `trigger_startup_news_fetch` flag is set after `NewsSetup` completion
/// - Sets `news_loading` flag to show loading modal
fn trigger_startup_news_fetch(channels: &Channels, app: &mut AppState) {
use crate::sources;
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | true |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/app/runtime/background.rs | src/app/runtime/background.rs | pub use crate::app::runtime::channels::Channels;
pub use crate::app::runtime::workers::auxiliary::{spawn_auxiliary_workers, spawn_event_thread};
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/app/runtime/workers/comments.rs | src/app/runtime/workers/comments.rs | //! Background worker for fetching AUR package comments.
use tokio::sync::mpsc;
use crate::sources;
use crate::state::types::AurComment;
/// What: Spawn background worker for AUR comments fetching.
///
/// Inputs:
/// - `comments_req_rx`: Channel receiver for comments requests (package name as String)
/// - `comments_res_tx`: Channel sender for comments responses
///
/// Output:
/// - None (spawns async task)
///
/// Details:
/// - Listens for package name requests on the channel
/// - Fetches comments asynchronously using `fetch_aur_comments`
/// - Sends results as `(String, Result<Vec<AurComment>, String>)` matching PKGBUILD pattern
/// - Handles errors gracefully (sends error message instead of panicking)
pub fn spawn_comments_worker(
mut comments_req_rx: mpsc::UnboundedReceiver<String>,
comments_res_tx: mpsc::UnboundedSender<(String, Result<Vec<AurComment>, String>)>,
) {
tokio::spawn(async move {
while let Some(pkgname) = comments_req_rx.recv().await {
let name = pkgname.clone();
match sources::fetch_aur_comments(pkgname).await {
Ok(comments) => {
let _ = comments_res_tx.send((name, Ok(comments)));
}
Err(e) => {
let _ =
comments_res_tx.send((name, Err(format!("Failed to fetch comments: {e}"))));
}
}
}
});
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/app/runtime/workers/preflight.rs | src/app/runtime/workers/preflight.rs | use tokio::sync::mpsc;
use crate::state::PackageItem;
/// What: Spawn background worker for dependency resolution.
///
/// Inputs:
/// - `deps_req_rx`: Channel receiver for dependency resolution requests (with action)
/// - `deps_res_tx`: Channel sender for dependency resolution responses
///
/// Details:
/// - Runs blocking dependency resolution in a thread pool
/// - For Install action: calls `resolve_dependencies` for forward dependencies
/// - For Remove action: calls `resolve_reverse_dependencies` for reverse dependencies
/// - Always sends a result, even if the task panics, to ensure flags are reset
pub fn spawn_dependency_worker(
mut deps_req_rx: mpsc::UnboundedReceiver<(
Vec<PackageItem>,
crate::state::modal::PreflightAction,
)>,
deps_res_tx: mpsc::UnboundedSender<Vec<crate::state::modal::DependencyInfo>>,
) {
let deps_res_tx_bg = deps_res_tx;
tokio::spawn(async move {
tracing::info!("[Runtime] Dependency worker started, waiting for requests...");
while let Some((items, action)) = deps_req_rx.recv().await {
tracing::info!(
"[Runtime] Dependency worker received request: {} items, action={:?}",
items.len(),
action
);
// Run blocking dependency resolution in a thread pool
let items_clone = items.clone();
let res_tx = deps_res_tx_bg.clone();
let res_tx_error = deps_res_tx_bg.clone(); // Clone for error handling
let handle = tokio::task::spawn_blocking(move || {
let deps = match action {
crate::state::modal::PreflightAction::Install => {
tracing::info!(
"[Runtime] Resolving forward dependencies for {} packages",
items_clone.len()
);
crate::logic::deps::resolve_dependencies(&items_clone)
}
crate::state::modal::PreflightAction::Remove => {
tracing::info!(
"[Runtime] Resolving reverse dependencies for {} packages",
items_clone.len()
);
let report = crate::logic::deps::resolve_reverse_dependencies(&items_clone);
tracing::info!(
"[Runtime] Reverse dependency resolution completed: {} deps found",
report.dependencies.len()
);
report.dependencies
}
crate::state::modal::PreflightAction::Downgrade => {
// For downgrade, we don't need to resolve dependencies
// Downgrade is similar to remove in that we might want to check reverse deps
// but for now, return empty since downgrade tool handles its own logic
tracing::info!(
"[Runtime] Downgrade action: skipping dependency resolution"
);
Vec::new()
}
};
tracing::info!(
"[Runtime] Dependency resolution done, sending {} deps to result channel",
deps.len()
);
let send_result = res_tx.send(deps);
tracing::info!(
"[Runtime] deps_res_tx.send result: {:?}",
send_result.is_ok()
);
});
// CRITICAL: Always await and send a result, even if task panics
// This ensures deps_resolving flag is always reset
tokio::spawn(async move {
match handle.await {
Ok(()) => {
// Task completed successfully, result already sent
tracing::debug!("[Runtime] Dependency resolution task completed");
}
Err(e) => {
// Task panicked - send empty result to reset flag
tracing::error!("[Runtime] Dependency resolution task panicked: {:?}", e);
let _ = res_tx_error.send(Vec::new());
}
}
});
}
tracing::debug!("[Runtime] Dependency resolution worker exiting (channel closed)");
});
}
/// What: Spawn background worker for file resolution.
///
/// Inputs:
/// - `files_req_rx`: Channel receiver for file resolution requests (with action)
/// - `files_res_tx`: Channel sender for file resolution responses
pub fn spawn_file_worker(
mut files_req_rx: mpsc::UnboundedReceiver<(
Vec<PackageItem>,
crate::state::modal::PreflightAction,
)>,
files_res_tx: mpsc::UnboundedSender<Vec<crate::state::modal::PackageFileInfo>>,
) {
let files_res_tx_bg = files_res_tx;
tokio::spawn(async move {
while let Some((items, action)) = files_req_rx.recv().await {
tracing::info!(
"[Runtime] File worker received request: {} items, action={:?}",
items.len(),
action
);
// Run blocking file resolution in a thread pool
let items_clone = items.clone();
let action_clone = action;
let res_tx = files_res_tx_bg.clone();
tokio::task::spawn_blocking(move || {
let files = crate::logic::files::resolve_file_changes(&items_clone, action_clone);
tracing::debug!(
"[Background] Sending file result: {} entries for packages: {:?}",
files.len(),
files.iter().map(|f| &f.name).collect::<Vec<_>>()
);
for file_info in &files {
tracing::debug!(
"[Background] Package '{}' - total={}, new={}, changed={}, removed={}, config={}",
file_info.name,
file_info.total_count,
file_info.new_count,
file_info.changed_count,
file_info.removed_count,
file_info.config_count
);
}
if let Err(e) = res_tx.send(files) {
// Channel closed is expected during shutdown, log at debug level
tracing::debug!(
"[Background] Failed to send file result (channel closed): {}",
e
);
} else {
tracing::debug!("[Background] Successfully sent file result");
}
});
}
});
}
/// What: Spawn background worker for service impact resolution.
///
/// Inputs:
/// - `services_req_rx`: Channel receiver for service resolution requests (with action)
/// - `services_res_tx`: Channel sender for service resolution responses
pub fn spawn_service_worker(
mut services_req_rx: mpsc::UnboundedReceiver<(
Vec<PackageItem>,
crate::state::modal::PreflightAction,
)>,
services_res_tx: mpsc::UnboundedSender<Vec<crate::state::modal::ServiceImpact>>,
) {
let services_res_tx_bg = services_res_tx;
tokio::spawn(async move {
while let Some((items, action)) = services_req_rx.recv().await {
tracing::info!(
"[Runtime] Service worker received request: {} items, action={:?}",
items.len(),
action
);
// Run blocking service resolution in a thread pool
let items_clone = items.clone();
let action_clone = action;
let res_tx = services_res_tx_bg.clone();
tokio::task::spawn_blocking(move || {
let services =
crate::logic::services::resolve_service_impacts(&items_clone, action_clone);
tracing::debug!(
"[Background] Sending service result: {} entries",
services.len()
);
if let Err(e) = res_tx.send(services) {
// Channel closed is expected during shutdown, log at debug level
tracing::debug!(
"[Background] Failed to send service result (channel closed): {}",
e
);
} else {
tracing::debug!("[Background] Successfully sent service result");
}
});
}
});
}
/// What: Spawn background worker for sandbox resolution.
///
/// Inputs:
/// - `sandbox_req_rx`: Channel receiver for sandbox resolution requests
/// - `sandbox_res_tx`: Channel sender for sandbox resolution responses
///
/// Details:
/// - Uses async version for parallel HTTP fetches
pub fn spawn_sandbox_worker(
mut sandbox_req_rx: mpsc::UnboundedReceiver<Vec<PackageItem>>,
sandbox_res_tx: mpsc::UnboundedSender<Vec<crate::logic::sandbox::SandboxInfo>>,
) {
let sandbox_res_tx_bg = sandbox_res_tx;
tokio::spawn(async move {
while let Some(items) = sandbox_req_rx.recv().await {
// Use async version for parallel HTTP fetches
let items_clone = items.clone();
let res_tx = sandbox_res_tx_bg.clone();
tokio::spawn(async move {
let sandbox_info =
crate::logic::sandbox::resolve_sandbox_info_async(&items_clone).await;
tracing::debug!(
"[Background] Sending sandbox result: {} entries for packages: {:?}",
sandbox_info.len(),
sandbox_info
.iter()
.map(|s| &s.package_name)
.collect::<Vec<_>>()
);
if let Err(e) = res_tx.send(sandbox_info) {
// Channel closed is expected during shutdown, log at debug level
tracing::debug!(
"[Background] Failed to send sandbox result (channel closed): {}",
e
);
} else {
tracing::debug!("[Background] Successfully sent sandbox result");
}
});
}
});
}
/// What: Spawn background worker for preflight summary computation.
///
/// Inputs:
/// - `summary_req_rx`: Channel receiver for summary computation requests
/// - `summary_res_tx`: Channel sender for summary computation responses
///
/// Details:
/// - Runs blocking summary computation in a thread pool
/// - Always sends a result, even if the task panics, to avoid breaking the UI
pub fn spawn_summary_worker(
mut summary_req_rx: mpsc::UnboundedReceiver<(
Vec<PackageItem>,
crate::state::modal::PreflightAction,
)>,
summary_res_tx: mpsc::UnboundedSender<crate::logic::preflight::PreflightSummaryOutcome>,
) {
let summary_res_tx_bg = summary_res_tx;
tokio::spawn(async move {
while let Some((items, action)) = summary_req_rx.recv().await {
// Run blocking summary computation in a thread pool
let items_clone = items.clone();
let res_tx = summary_res_tx_bg.clone();
let res_tx_error = summary_res_tx_bg.clone();
let handle = tokio::task::spawn_blocking(move || {
let summary =
crate::logic::preflight::compute_preflight_summary(&items_clone, action);
let _ = res_tx.send(summary);
});
// CRITICAL: Always await and send a result, even if task panics
tokio::spawn(async move {
match handle.await {
Ok(()) => {
// Task completed successfully, result already sent
tracing::debug!("[Runtime] Preflight summary computation task completed");
}
Err(e) => {
// Task panicked - send minimal result to reset flag
tracing::error!(
"[Runtime] Preflight summary computation task panicked: {:?}",
e
);
// Create a minimal summary to avoid breaking the UI
let minimal_summary = crate::logic::preflight::PreflightSummaryOutcome {
summary: crate::state::modal::PreflightSummaryData {
packages: Vec::new(),
package_count: 0,
aur_count: 0,
download_bytes: 0,
install_delta_bytes: 0,
risk_score: 0,
risk_level: crate::state::modal::RiskLevel::Low,
risk_reasons: Vec::new(),
major_bump_packages: Vec::new(),
core_system_updates: Vec::new(),
pacnew_candidates: 0,
pacsave_candidates: 0,
config_warning_packages: Vec::new(),
service_restart_units: Vec::new(),
summary_warnings: vec!["Summary computation failed".to_string()],
summary_notes: Vec::new(),
},
header: crate::state::modal::PreflightHeaderChips {
package_count: 0,
download_bytes: 0,
install_delta_bytes: 0,
aur_count: 0,
risk_score: 0,
risk_level: crate::state::modal::RiskLevel::Low,
},
reverse_deps_report: None,
};
let _ = res_tx_error.send(minimal_summary);
}
}
});
}
tracing::debug!("[Runtime] Preflight summary computation worker exiting (channel closed)");
});
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/app/runtime/workers/search.rs | src/app/runtime/workers/search.rs | use std::collections::HashSet;
use std::path::Path;
use std::time::Instant;
use tokio::{
select,
sync::mpsc,
time::{Duration, sleep},
};
use crate::index as pkgindex;
use crate::sources;
use crate::state::{PackageItem, QueryInput, SearchResults};
use crate::util::{fuzzy_match_rank_with_matcher, match_rank, repo_order};
/// What: Spawn background worker for search queries.
///
/// Inputs:
/// - `query_rx`: Channel receiver for search queries
/// - `search_result_tx`: Channel sender for search results
/// - `net_err_tx`: Channel sender for network errors
/// - `index_path`: Path to official package index
///
/// Details:
/// - Debounces queries with 250ms window
/// - Enforces minimum 300ms interval between searches
/// - Handles empty queries by returning all official packages
/// - Searches both official and AUR repositories
pub fn spawn_search_worker(
mut query_rx: mpsc::UnboundedReceiver<QueryInput>,
search_result_tx: mpsc::UnboundedSender<SearchResults>,
net_err_tx: &mpsc::UnboundedSender<String>,
index_path: std::path::PathBuf,
) {
let net_err_tx_search = net_err_tx.clone();
tokio::spawn(async move {
const DEBOUNCE_MS: u64 = 250;
const MIN_INTERVAL_MS: u64 = 300;
let mut last_sent = Instant::now()
.checked_sub(Duration::from_millis(MIN_INTERVAL_MS))
.unwrap_or_else(Instant::now);
loop {
let Some(mut latest) = query_rx.recv().await else {
break;
};
loop {
select! { Some(new_q) = query_rx.recv() => { latest = new_q; } () = sleep(Duration::from_millis(DEBOUNCE_MS)) => { break; } }
}
if latest.text.trim().is_empty() {
let items = handle_empty_query(&index_path);
let _ = search_result_tx.send(SearchResults {
id: latest.id,
items,
});
continue;
}
let elapsed = last_sent.elapsed();
if elapsed < Duration::from_millis(MIN_INTERVAL_MS) {
sleep(
Duration::from_millis(MIN_INTERVAL_MS)
.checked_sub(elapsed)
.expect("elapsed should be less than MIN_INTERVAL_MS"),
)
.await;
}
last_sent = Instant::now();
let query = latest;
let tx = search_result_tx.clone();
let err_tx = net_err_tx_search.clone();
let ipath = index_path.clone();
tokio::spawn(async move {
let (items, errors) = process_search_query(&query.text, query.fuzzy, &ipath).await;
for e in errors {
let _ = err_tx.send(e);
}
let _ = tx.send(SearchResults {
id: query.id,
items,
});
});
}
});
}
/// What: Handle empty query by returning all official packages.
///
/// Inputs:
/// - `index_path`: Path to official package index
///
/// Output:
/// - Sorted and deduplicated list of all official packages
///
/// Details:
/// - Fetches all official packages
/// - Sorts by repo order (core > extra > others), then by name
/// - Deduplicates by package name, preferring earlier entries
fn handle_empty_query(index_path: &Path) -> Vec<PackageItem> {
let mut items = pkgindex::all_official_or_fetch(index_path);
sort_by_repo_and_name(&mut items);
deduplicate_items(&mut items);
items
}
/// What: Process a search query and return sorted results.
///
/// Inputs:
/// - `query_text`: Search query text
/// - `fuzzy_mode`: Whether to use fuzzy matching
/// - `index_path`: Path to official package index
///
/// Output:
/// - Tuple of (sorted and deduplicated list of matching packages, network errors)
///
/// Details:
/// - Ensures official index is loaded
/// - Searches official packages
/// - Fetches and filters AUR packages
/// - Combines, scores, and sorts results
async fn process_search_query(
query_text: &str,
fuzzy_mode: bool,
index_path: &Path,
) -> (Vec<PackageItem>, Vec<String>) {
if crate::index::all_official().is_empty() {
let _ = crate::index::all_official_or_fetch(index_path);
}
let official_results = pkgindex::search_official(query_text, fuzzy_mode);
let (aur_items, errors) = sources::fetch_all_with_errors(query_text.to_string()).await;
let mut items_with_scores = official_results;
score_aur_items(&mut items_with_scores, aur_items, query_text, fuzzy_mode);
sort_scored_items(&mut items_with_scores, query_text, fuzzy_mode);
let mut items: Vec<PackageItem> = items_with_scores
.into_iter()
.map(|(item, _)| item)
.collect();
deduplicate_items(&mut items);
(items, errors)
}
/// What: Score and add AUR items to the results list.
///
/// Inputs:
/// - `items_with_scores`: Mutable vector of (item, score) tuples to extend
/// - `aur_items`: List of AUR package items
/// - `query_text`: Search query text
/// - `fuzzy_mode`: Whether to use fuzzy matching
///
/// Details:
/// - In fuzzy mode: filters and scores AUR items using fuzzy matching
/// - In normal mode: adds all AUR items with placeholder score
#[allow(clippy::ptr_arg)] // Need &mut Vec to extend the vector
fn score_aur_items(
items_with_scores: &mut Vec<(PackageItem, Option<i64>)>,
aur_items: Vec<PackageItem>,
query_text: &str,
fuzzy_mode: bool,
) {
if fuzzy_mode {
let matcher = fuzzy_matcher::skim::SkimMatcherV2::default();
let aur_scored: Vec<(PackageItem, Option<i64>)> = aur_items
.into_iter()
.filter_map(|item| {
fuzzy_match_rank_with_matcher(&item.name, query_text, &matcher)
.map(|score| (item, Some(score)))
})
.collect();
items_with_scores.extend(aur_scored);
} else {
let aur_scored: Vec<(PackageItem, Option<i64>)> =
aur_items.into_iter().map(|item| (item, Some(0))).collect();
items_with_scores.extend(aur_scored);
}
}
/// What: Sort items based on fuzzy mode.
///
/// Inputs:
/// - `items_with_scores`: Mutable slice of (item, score) tuples
/// - `query_text`: Search query text
/// - `fuzzy_mode`: Whether to use fuzzy matching
///
/// Details:
/// - In fuzzy mode: sorts by fuzzy score (higher first), then repo order, then name
/// - In normal mode: sorts by match rank, then repo order, then name
fn sort_scored_items(
items_with_scores: &mut [(PackageItem, Option<i64>)],
query_text: &str,
fuzzy_mode: bool,
) {
if fuzzy_mode {
sort_items_fuzzy(items_with_scores);
} else {
sort_items_normal(items_with_scores, query_text);
}
}
/// What: Sort items in fuzzy mode by score, repo order, and name.
///
/// Inputs:
/// - `items_with_scores`: Mutable slice of (item, score) tuples
///
/// Details:
/// - Higher fuzzy scores come first
/// - Then sorted by repo order (official before AUR)
/// - Finally sorted by name (case-insensitive)
fn sort_items_fuzzy(items_with_scores: &mut [(PackageItem, Option<i64>)]) {
items_with_scores.sort_by(|a, b| match (a.1, b.1) {
(Some(sa), Some(sb)) => match sb.cmp(&sa) {
std::cmp::Ordering::Equal => compare_by_repo_and_name(&a.0, &b.0),
other => other,
},
(Some(_), None) => std::cmp::Ordering::Less,
(None, Some(_)) => std::cmp::Ordering::Greater,
(None, None) => compare_by_repo_and_name(&a.0, &b.0),
});
}
/// What: Sort items in normal mode by match rank, repo order, and name.
///
/// Inputs:
/// - `items_with_scores`: Mutable slice of (item, score) tuples
/// - `query_text`: Search query text
///
/// Details:
/// - Lower match ranks come first (exact > prefix > substring > no match)
/// - Then sorted by repo order (official before AUR)
/// - Finally sorted by name (case-insensitive)
fn sort_items_normal(items_with_scores: &mut [(PackageItem, Option<i64>)], query_text: &str) {
let query_lower = query_text.trim().to_lowercase();
items_with_scores.sort_by(|a, b| {
let oa = repo_order(&a.0.source);
let ob = repo_order(&b.0.source);
if oa != ob {
return oa.cmp(&ob);
}
let ra = match_rank(&a.0.name, &query_lower);
let rb = match_rank(&b.0.name, &query_lower);
if ra != rb {
return ra.cmp(&rb);
}
a.0.name.to_lowercase().cmp(&b.0.name.to_lowercase())
});
}
/// What: Compare two packages by repo order and name.
///
/// Inputs:
/// - `a`: First package item
/// - `b`: Second package item
///
/// Output:
/// - Ordering comparison result
///
/// Details:
/// - First compares by repo order (official before AUR)
/// - Then compares by name (case-insensitive)
fn compare_by_repo_and_name(a: &PackageItem, b: &PackageItem) -> std::cmp::Ordering {
let oa = repo_order(&a.source);
let ob = repo_order(&b.source);
oa.cmp(&ob)
.then_with(|| a.name.to_lowercase().cmp(&b.name.to_lowercase()))
}
/// What: Sort items by repo order and name.
///
/// Inputs:
/// - `items`: Mutable slice of package items
///
/// Details:
/// - Sorts by repo order (core > extra > others > AUR)
/// - Then sorts by name (case-insensitive)
fn sort_by_repo_and_name(items: &mut [PackageItem]) {
items.sort_by(compare_by_repo_and_name);
}
/// What: Deduplicate items by package name, keeping first occurrence.
///
/// Inputs:
/// - `items`: Mutable reference to list of package items
///
/// Details:
/// - Removes duplicate packages based on case-insensitive name comparison
/// - Keeps the first occurrence (preferring earlier entries in sort order)
fn deduplicate_items(items: &mut Vec<PackageItem>) {
let mut seen = HashSet::new();
items.retain(|p| seen.insert(p.name.to_lowercase()));
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/app/runtime/workers/updates_parsing.rs | src/app/runtime/workers/updates_parsing.rs | /// What: Parse packages from pacman -Qu output.
///
/// Inputs:
/// - `output`: Raw command output bytes
///
/// Output:
/// - Vector of (`package_name`, `old_version`, `new_version`) tuples
///
/// Details:
/// - Parses `"package-name old_version -> new_version"` format
pub fn parse_checkupdates(output: &[u8]) -> Vec<(String, String, String)> {
String::from_utf8_lossy(output)
.lines()
.filter_map(|line| {
let trimmed = line.trim();
if trimmed.is_empty() {
None
} else {
// Parse "package-name old_version -> new_version" format
trimmed.find(" -> ").and_then(|arrow_pos| {
let before_arrow = &trimmed[..arrow_pos];
let after_arrow = &trimmed[arrow_pos + 4..];
let parts: Vec<&str> = before_arrow.split_whitespace().collect();
if parts.len() >= 2 {
let name = parts[0].to_string();
let old_version = parts[1..].join(" "); // In case version has spaces
let new_version = after_arrow.trim().to_string();
Some((name, old_version, new_version))
} else {
None
}
})
}
})
.collect()
}
/// What: Parse packages from checkupdates output.
///
/// Inputs:
/// - `output`: Raw command output bytes
///
/// Output:
/// - Vector of (`package_name`, `new_version`) tuples
///
/// Details:
/// - Parses "package-name version" format (checkupdates only shows new version)
/// - Old version must be retrieved separately from installed packages
pub fn parse_checkupdates_tool(output: &[u8]) -> Vec<(String, String)> {
String::from_utf8_lossy(output)
.lines()
.filter_map(|line| {
let trimmed = line.trim();
if trimmed.is_empty() {
None
} else {
// Parse "package-name version" format
let parts: Vec<&str> = trimmed.split_whitespace().collect();
if parts.len() >= 2 {
let name = parts[0].to_string();
let new_version = parts[1..].join(" "); // In case version has spaces
Some((name, new_version))
} else {
None
}
}
})
.collect()
}
/// What: Get installed version of a package.
///
/// Inputs:
/// - `package_name`: Name of the package
///
/// Output:
/// - `Some(version)` if package is installed, `None` otherwise
///
/// Details:
/// - Uses `pacman -Q` to get the installed version
pub fn get_installed_version(package_name: &str) -> Option<String> {
use std::process::{Command, Stdio};
let output = Command::new("pacman")
.args(["-Q", package_name])
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::null())
.output()
.ok()?;
if output.status.success() {
let text = String::from_utf8_lossy(&output.stdout);
// Format: "package-name version"
let parts: Vec<&str> = text.split_whitespace().collect();
if parts.len() >= 2 {
Some(parts[1..].join(" "))
} else {
None
}
} else {
None
}
}
/// What: Parse packages from -Qua output.
///
/// Inputs:
/// - `output`: Raw command output bytes
///
/// Output:
/// - Vector of (`package_name`, `old_version`, `new_version`) tuples
///
/// Details:
/// - Parses "package old -> new" format
pub fn parse_qua(output: &[u8]) -> Vec<(String, String, String)> {
String::from_utf8_lossy(output)
.lines()
.filter_map(|line| {
let trimmed = line.trim();
if trimmed.is_empty() {
None
} else {
// Parse "package old -> new" format
trimmed.find(" -> ").and_then(|arrow_pos| {
let before_arrow = &trimmed[..arrow_pos];
let after_arrow = &trimmed[arrow_pos + 4..];
let parts: Vec<&str> = before_arrow.split_whitespace().collect();
if parts.len() >= 2 {
let name = parts[0].to_string();
let old_version = parts[1..].join(" "); // In case version has spaces
let new_version = after_arrow.trim().to_string();
Some((name, old_version, new_version))
} else {
None
}
})
}
})
.collect()
}
#[cfg(test)]
mod tests {
use super::parse_checkupdates;
/// What: Test that pacman -Qu parsing correctly extracts old and new versions.
///
/// Inputs:
/// - Sample pacman -Qu output with format `"package-name old_version -> new_version"`
///
/// Output:
/// - Verifies that `old_version` and `new_version` are correctly parsed and different
///
/// Details:
/// - Tests parsing of pacman -Qu output format
#[test]
fn test_parse_checkupdates_extracts_correct_versions() {
let test_cases = vec![
("bat 0.26.0-1 -> 0.26.0-2", "bat", "0.26.0-1", "0.26.0-2"),
(
"comgr 2:6.4.4-2 -> 2:7.1.0-1",
"comgr",
"2:6.4.4-2",
"2:7.1.0-1",
),
(
"composable-kernel 6.4.4-1 -> 7.1.0-1",
"composable-kernel",
"6.4.4-1",
"7.1.0-1",
),
];
for (input, expected_name, expected_old, expected_new) in test_cases {
let output = input.as_bytes();
let entries = parse_checkupdates(output);
assert_eq!(entries.len(), 1, "Failed to parse: {input}");
let (name, old_version, new_version) = &entries[0];
assert_eq!(name, expected_name, "Wrong name for: {input}");
assert_eq!(old_version, expected_old, "Wrong old_version for: {input}");
assert_eq!(new_version, expected_new, "Wrong new_version for: {input}");
}
}
/// What: Test that pacman -Qu parsing handles multiple packages.
///
/// Inputs:
/// - Multi-line pacman -Qu output
///
/// Output:
/// - Verifies that all packages are parsed correctly
#[test]
fn test_parse_checkupdates_multiple_packages() {
let input = "bat 0.26.0-1 -> 0.26.0-2\ncomgr 2:6.4.4-2 -> 2:7.1.0-1\n";
let output = input.as_bytes();
let entries = parse_checkupdates(output);
assert_eq!(entries.len(), 2);
assert_eq!(
entries[0],
(
"bat".to_string(),
"0.26.0-1".to_string(),
"0.26.0-2".to_string()
)
);
assert_eq!(
entries[1],
(
"comgr".to_string(),
"2:6.4.4-2".to_string(),
"2:7.1.0-1".to_string()
)
);
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/app/runtime/workers/executor.rs | src/app/runtime/workers/executor.rs | //! Background worker for executing commands via PTY.
use tokio::sync::mpsc;
use crate::install::{ExecutorOutput, ExecutorRequest};
#[cfg(not(target_os = "windows"))]
use crate::install::{
build_downgrade_command_for_executor, build_install_command_for_executor,
build_remove_command_for_executor, build_scan_command_for_executor,
build_update_command_for_executor,
};
/// What: Handle install request by building command and executing via PTY.
///
/// Inputs:
/// - `items`: Packages to install
/// - `password`: Optional sudo password
/// - `dry_run`: Whether to run in dry-run mode
/// - `res_tx`: Channel sender for output
///
/// Details:
/// - AUR helpers (paru/yay) need sudo for the final installation step
/// - Detects AUR commands and caches sudo credentials when password is provided
/// - Uses the same flow as custom commands for sudo passthrough
#[cfg(not(target_os = "windows"))]
#[allow(clippy::needless_pass_by_value)] // Values are moved into spawn_blocking closure
fn handle_install_request(
items: Vec<crate::state::PackageItem>,
password: Option<String>,
dry_run: bool,
res_tx: mpsc::UnboundedSender<ExecutorOutput>,
) {
use crate::install::shell_single_quote;
use crate::state::Source;
tracing::info!(
"[Runtime] Executor worker received install request: {} items, dry_run={}",
items.len(),
dry_run
);
// Check if there are AUR packages
let has_aur = items.iter().any(|item| matches!(item.source, Source::Aur));
// For official packages: password is piped to sudo (printf '%s\n' password | sudo -S command)
// For AUR packages: cache sudo credentials first, then run paru/yay (same sudo prompt flow)
let cmd = if has_aur {
// Build AUR command without password embedded
build_install_command_for_executor(&items, None, dry_run)
} else {
// Build official command with password piping
build_install_command_for_executor(&items, password.as_deref(), dry_run)
};
// For AUR packages, cache sudo credentials first using the same password piping approach
// This ensures paru/yay can use sudo without prompting (same flow as official packages)
// Use `;` instead of `&&` so the AUR command runs regardless of sudo -v result
// (paru/yay can handle their own sudo prompts if credential caching fails)
let final_cmd = if has_aur && !dry_run && password.is_some() {
if let Some(ref pass) = password {
let escaped_pass = shell_single_quote(pass);
// Cache sudo credentials first, then run the AUR command
// sudo -v validates and caches credentials without running a command
// Using `;` ensures AUR command runs even if sudo -v returns non-zero
format!("printf '%s\\n' {escaped_pass} | sudo -S -v 2>/dev/null ; {cmd}")
} else {
cmd
}
} else {
cmd
};
let res_tx_clone = res_tx;
tokio::task::spawn_blocking(move || {
execute_command_pty(&final_cmd, None, res_tx_clone);
});
}
/// What: Handle remove request by building command and executing via PTY.
///
/// Inputs:
/// - `names`: Package names to remove
/// - `password`: Optional sudo password
/// - `cascade`: Cascade removal mode
/// - `dry_run`: Whether to run in dry-run mode
/// - `res_tx`: Channel sender for output
#[cfg(not(target_os = "windows"))]
#[allow(clippy::needless_pass_by_value)] // Values are moved into spawn_blocking closure
fn handle_remove_request(
names: Vec<String>,
password: Option<String>,
cascade: crate::state::modal::CascadeMode,
dry_run: bool,
res_tx: mpsc::UnboundedSender<ExecutorOutput>,
) {
tracing::info!(
"[Runtime] Executor worker received remove request: {} packages, dry_run={}",
names.len(),
dry_run
);
let cmd = build_remove_command_for_executor(&names, password.as_deref(), cascade, dry_run);
let res_tx_clone = res_tx;
tokio::task::spawn_blocking(move || {
execute_command_pty(&cmd, None, res_tx_clone);
});
}
/// What: Handle downgrade request by building command and executing via PTY.
///
/// Inputs:
/// - `names`: Package names to downgrade
/// - `password`: Optional sudo password
/// - `dry_run`: Whether to run in dry-run mode
/// - `res_tx`: Channel sender for output
#[cfg(not(target_os = "windows"))]
#[allow(clippy::needless_pass_by_value)] // Values are moved into spawn_blocking closure
fn handle_downgrade_request(
names: Vec<String>,
password: Option<String>,
dry_run: bool,
res_tx: mpsc::UnboundedSender<ExecutorOutput>,
) {
tracing::info!(
"[Runtime] Executor worker received downgrade request: {} packages, dry_run={}",
names.len(),
dry_run
);
let cmd = build_downgrade_command_for_executor(&names, password.as_deref(), dry_run);
let res_tx_clone = res_tx;
tokio::task::spawn_blocking(move || {
execute_command_pty(&cmd, None, res_tx_clone);
});
}
/// What: Handle update request by building command and executing via PTY.
///
/// Inputs:
/// - `commands`: Commands to execute
/// - `password`: Optional sudo password
/// - `dry_run`: Whether to run in dry-run mode
/// - `res_tx`: Channel sender for output
#[cfg(not(target_os = "windows"))]
#[allow(clippy::needless_pass_by_value)] // Values are moved into spawn_blocking closure
fn handle_update_request(
commands: Vec<String>,
password: Option<String>,
dry_run: bool,
res_tx: mpsc::UnboundedSender<ExecutorOutput>,
) {
tracing::info!(
"[Runtime] Executor worker received update request: {} commands, dry_run={}",
commands.len(),
dry_run
);
let cmd = build_update_command_for_executor(&commands, password.as_deref(), dry_run);
tracing::debug!("[Runtime] Built update command (length={})", cmd.len());
let res_tx_clone = res_tx;
tokio::task::spawn_blocking(move || {
tracing::debug!("[Runtime] spawn_blocking started for update command");
execute_command_pty(&cmd, None, res_tx_clone);
tracing::debug!("[Runtime] spawn_blocking completed for update command");
});
}
/// What: Handle scan request by building command and executing via PTY.
///
/// Inputs:
/// - `package`: Package name to scan
/// - `do_clamav`/`do_trivy`/`do_semgrep`/`do_shellcheck`/`do_virustotal`/`do_custom`: Scan flags
/// - `dry_run`: Whether to run in dry-run mode
/// - `res_tx`: Channel sender for output
#[cfg(not(target_os = "windows"))]
#[allow(
clippy::needless_pass_by_value, // Values are moved into spawn_blocking closure
clippy::too_many_arguments, // Scan configuration requires multiple flags
clippy::fn_params_excessive_bools // Scan configuration requires multiple bool flags
)]
fn handle_scan_request(
package: String,
do_clamav: bool,
do_trivy: bool,
do_semgrep: bool,
do_shellcheck: bool,
do_virustotal: bool,
do_custom: bool,
dry_run: bool,
res_tx: mpsc::UnboundedSender<ExecutorOutput>,
) {
tracing::info!(
"[Runtime] Executor worker received scan request: package={}, dry_run={}",
package,
dry_run
);
let cmd = build_scan_command_for_executor(
&package,
do_clamav,
do_trivy,
do_semgrep,
do_shellcheck,
do_virustotal,
do_custom,
dry_run,
);
let res_tx_clone = res_tx;
tokio::task::spawn_blocking(move || {
execute_command_pty(&cmd, None, res_tx_clone);
});
}
/// What: Handle custom command request by building command and executing via PTY.
///
/// Inputs:
/// - `command`: Command string to execute
/// - `password`: Optional sudo password
/// - `dry_run`: Whether to run in dry-run mode
/// - `res_tx`: Channel sender for output
#[cfg(not(target_os = "windows"))]
#[allow(clippy::needless_pass_by_value)] // Values are moved into spawn_blocking closure
fn handle_custom_command_request(
command: String,
password: Option<String>,
dry_run: bool,
res_tx: mpsc::UnboundedSender<ExecutorOutput>,
) {
tracing::info!(
"[Runtime] Executor worker received custom command request, dry_run={}",
dry_run
);
let cmd = if dry_run {
// Properly quote the command to avoid syntax errors with complex shell constructs
use crate::install::shell_single_quote;
let quoted = shell_single_quote(&command);
format!("echo DRY RUN: {quoted}")
} else {
// For commands that use sudo, we need to handle sudo password
// Use SUDO_ASKPASS to provide password when sudo prompts
if command.contains("sudo") && password.is_some() {
if let Some(ref pass) = password {
// Create a temporary script that outputs the password
// Use printf instead of echo for better security
use std::fs;
use std::os::unix::fs::PermissionsExt;
let temp_dir = std::env::temp_dir();
#[allow(clippy::uninlined_format_args)]
// process::id() needs formatting
let askpass_script =
temp_dir.join(format!("pacsea_sudo_askpass_{}.sh", std::process::id()));
// Use printf with %s to safely output password
// Escape single quotes in password by replacing ' with '\''
let escaped_pass = pass.replace('\'', "'\\''");
#[allow(clippy::uninlined_format_args)] // Need to escape password
let script_content = format!("#!/bin/sh\nprintf '%s\\n' '{}'\n", escaped_pass);
if let Err(e) = fs::write(&askpass_script, script_content) {
let _ = res_tx.send(ExecutorOutput::Error(format!(
"Failed to create sudo askpass script: {e}"
)));
return;
}
// Make script executable
if let Err(e) =
fs::set_permissions(&askpass_script, fs::Permissions::from_mode(0o755))
{
let _ = res_tx.send(ExecutorOutput::Error(format!(
"Failed to make askpass script executable: {e}"
)));
return;
}
let askpass_path = askpass_script.to_string_lossy().to_string();
// Escape the path for shell
let escaped_path = askpass_path.replace('\'', "'\\''");
// Need to escape path and use command variable, so can't use inline format
let final_cmd = format!(
"export SUDO_ASKPASS='{escaped_path}'; {command}; rm -f '{escaped_path}'"
);
final_cmd
} else {
// No password provided, try without SUDO_ASKPASS
// (might work if passwordless sudo is configured)
command
}
} else {
command
}
};
let res_tx_clone = res_tx;
tokio::task::spawn_blocking(move || {
execute_command_pty(&cmd, password, res_tx_clone);
});
}
/// What: Spawn background worker for command execution via PTY.
///
/// Inputs:
/// - `executor_req_rx`: Channel receiver for executor requests
/// - `executor_res_tx`: Channel sender for executor output
///
/// Details:
/// - Executes commands in a PTY to capture full terminal output
/// - Streams output line by line to the main event loop
/// - Handles install, remove, downgrade, update, scan, and custom command operations
#[cfg(not(target_os = "windows"))]
pub fn spawn_executor_worker(
executor_req_rx: mpsc::UnboundedReceiver<ExecutorRequest>,
executor_res_tx: mpsc::UnboundedSender<ExecutorOutput>,
) {
let executor_res_tx_bg = executor_res_tx;
tokio::spawn(async move {
let mut executor_req_rx = executor_req_rx;
tracing::info!("[Runtime] Executor worker started, waiting for requests...");
while let Some(request) = executor_req_rx.recv().await {
let res_tx = executor_res_tx_bg.clone();
match request {
ExecutorRequest::Install {
items,
password,
dry_run,
} => handle_install_request(items, password, dry_run, res_tx),
ExecutorRequest::Remove {
names,
password,
cascade,
dry_run,
} => handle_remove_request(names, password, cascade, dry_run, res_tx),
ExecutorRequest::Downgrade {
names,
password,
dry_run,
} => handle_downgrade_request(names, password, dry_run, res_tx),
ExecutorRequest::Update {
commands,
password,
dry_run,
} => handle_update_request(commands, password, dry_run, res_tx),
#[cfg(not(target_os = "windows"))]
ExecutorRequest::Scan {
package,
do_clamav,
do_trivy,
do_semgrep,
do_shellcheck,
do_virustotal,
do_custom,
dry_run,
} => handle_scan_request(
package,
do_clamav,
do_trivy,
do_semgrep,
do_shellcheck,
do_virustotal,
do_custom,
dry_run,
res_tx,
),
ExecutorRequest::CustomCommand {
command,
password,
dry_run,
} => handle_custom_command_request(command, password, dry_run, res_tx),
}
}
tracing::debug!("[Runtime] Executor worker exiting (channel closed)");
});
}
#[cfg(not(target_os = "windows"))]
/// What: Process text characters and send lines via channel.
///
/// Inputs:
/// - `text`: Text to process
/// - `line_buffer`: Mutable reference to current line buffer
/// - `res_tx`: Channel sender for output lines
///
/// Details:
/// - Handles newlines and carriage returns, strips ANSI codes, and sends complete lines.
fn process_text_chars(
text: &str,
line_buffer: &mut String,
res_tx: &mpsc::UnboundedSender<ExecutorOutput>,
) -> usize {
let mut lines_sent = 0;
for ch in text.chars() {
match ch {
'\n' => {
// Newline - send the current line and start a new one
if !line_buffer.trim().is_empty() {
// Strip ANSI escape codes before sending
let cleaned = strip_ansi_escapes::strip_str(&*line_buffer);
tracing::trace!(
"[PTY] Sending line: {}...",
&cleaned[..cleaned.len().min(50)]
);
if res_tx.send(ExecutorOutput::Line(cleaned)).is_ok() {
lines_sent += 1;
} else {
tracing::warn!("[PTY] Failed to send line - channel closed");
}
}
line_buffer.clear();
}
'\r' => {
// Carriage return - check if this looks like a progress bar update
// Progress bars typically have patterns like [====>], percentages, or (X/Y) at start
// If the buffer is empty or doesn't look like a progress bar, treat as new line
if !line_buffer.trim().is_empty() {
let cleaned = strip_ansi_escapes::strip_str(&*line_buffer);
// Check if this looks like a progress bar (has progress indicators)
// Be conservative: only replace if it has both brackets AND percentage
// This avoids replacing regular output like "(1/1) Arming ConditionNeedsUpdate..."
let has_progress_brackets = cleaned.contains('[') && cleaned.contains(']');
let has_percentage = cleaned.contains('%');
let looks_like_progress = has_progress_brackets && has_percentage;
if looks_like_progress {
// This is a progress bar update - replace the last line
if res_tx
.send(ExecutorOutput::ReplaceLastLine(cleaned))
.is_ok()
{
lines_sent += 1;
}
} else {
// This is regular output with \r - send as new line
if res_tx.send(ExecutorOutput::Line(cleaned)).is_ok() {
lines_sent += 1;
}
}
}
line_buffer.clear();
}
_ => {
line_buffer.push(ch);
}
}
}
lines_sent
}
#[cfg(not(target_os = "windows"))]
/// What: Spawns a reader thread that reads from PTY and sends data to channel.
///
/// Inputs:
/// - `reader`: PTY reader to read from
/// - `data_tx`: Channel sender to send read bytes
///
/// Details:
/// - Reads in 4KB chunks and sends to channel
/// - Sends empty vec on EOF to signal completion
#[cfg(not(target_os = "windows"))]
fn spawn_pty_reader_thread(
reader: Box<dyn std::io::Read + Send>,
data_tx: std::sync::mpsc::Sender<Vec<u8>>,
) {
std::thread::spawn(move || {
tracing::debug!("[PTY Reader] Reader thread started");
let mut reader = reader;
let mut total_bytes_read: usize = 0;
loop {
let mut buf = [0u8; 4096];
match reader.read(&mut buf) {
Ok(0) => {
tracing::debug!(
"[PTY Reader] EOF received, total bytes read: {}",
total_bytes_read
);
let _ = data_tx.send(Vec::new());
break;
}
Ok(n) => {
total_bytes_read += n;
tracing::trace!(
"[PTY Reader] Read {} bytes (total: {})",
n,
total_bytes_read
);
if data_tx.send(buf[..n].to_vec()).is_err() {
tracing::debug!("[PTY Reader] Receiver dropped, exiting");
break;
}
}
Err(e) => {
tracing::debug!(
"[PTY Reader] Read error: {}, total bytes: {}",
e,
total_bytes_read
);
break;
}
}
}
tracing::debug!("[PTY Reader] Reader thread exiting");
});
}
/// What: Process byte buffer handling incomplete UTF-8 sequences.
///
/// Inputs:
/// - `byte_buffer`: Buffer containing raw bytes to process
/// - `line_buffer`: Buffer for accumulating line text
/// - `res_tx`: Channel to send processed output
///
/// Output:
/// - Number of lines sent to channel
///
/// Details:
/// - Handles split UTF-8 sequences at buffer boundaries
/// - Falls back to lossy conversion if needed
#[cfg(not(target_os = "windows"))]
fn process_byte_buffer_utf8(
byte_buffer: &mut Vec<u8>,
line_buffer: &mut String,
res_tx: &mpsc::UnboundedSender<ExecutorOutput>,
) -> usize {
let mut lines_sent = 0;
loop {
// Try to decode the full buffer
if let Ok(text) = String::from_utf8(byte_buffer.clone()) {
byte_buffer.clear();
lines_sent += process_text_chars(&text, line_buffer, res_tx);
break;
}
// Buffer is small - might be incomplete UTF-8 sequence, wait for more
if byte_buffer.len() < 4 {
break;
}
// Try to find valid UTF-8 by trimming bytes from the end
let mut found_valid = false;
for trim_len in 1..=4.min(byte_buffer.len()) {
let test_len = byte_buffer.len().saturating_sub(trim_len);
if test_len == 0 {
break;
}
if let Ok(text) = String::from_utf8(byte_buffer[..test_len].to_vec()) {
lines_sent += process_text_chars(&text, line_buffer, res_tx);
byte_buffer.drain(..test_len);
found_valid = true;
break;
}
}
if !found_valid {
// Fall back to lossy conversion
let text = String::from_utf8_lossy(byte_buffer);
lines_sent += process_text_chars(&text, line_buffer, res_tx);
byte_buffer.clear();
break;
}
}
lines_sent
}
/// What: Send remaining line content and finished message.
///
/// Inputs:
/// - `line_buffer`: Any remaining line content to send
/// - `lines_sent`: Current count of lines sent
/// - `exit_code_u32`: Exit code from process
/// - `res_tx`: Channel to send output
/// - `context`: String describing the context (for logging)
#[cfg(not(target_os = "windows"))]
fn send_finish_message(
line_buffer: &str,
lines_sent: &mut usize,
exit_code_u32: u32,
res_tx: &mpsc::UnboundedSender<ExecutorOutput>,
context: &str,
) {
// Send any remaining line
if !line_buffer.trim().is_empty() {
let cleaned = strip_ansi_escapes::strip_str(line_buffer);
if res_tx.send(ExecutorOutput::Line(cleaned)).is_ok() {
*lines_sent += 1;
}
}
let success = exit_code_u32 == 0;
let exit_code = i32::try_from(exit_code_u32).ok();
tracing::info!(
"[PTY] Process finished{}: success={}, exit_code={:?}, total_lines_sent={}",
context,
success,
exit_code,
lines_sent
);
let _ = res_tx.send(ExecutorOutput::Finished {
success,
exit_code,
failed_command: None,
});
}
/// What: Execute command in PTY and stream output.
///
/// Inputs:
/// - `cmd`: Command string to execute
/// - `_password`: Optional password (currently unused - password is handled in command builder)
/// - `res_tx`: Channel sender for output lines
///
/// Details:
/// - Creates a PTY, spawns bash to execute the command
/// - Reads output line by line and sends via channel
/// - Strips ANSI escape codes from output using `strip-ansi-escapes` crate
/// - Sends Finished message when command completes
/// - Note: Password is handled in command builder (piped for official packages, credential caching for AUR)
#[cfg(not(target_os = "windows"))]
#[allow(clippy::needless_pass_by_value)] // Pass by value needed for move into closure
fn execute_command_pty(
cmd: &str,
_password: Option<String>,
res_tx: mpsc::UnboundedSender<ExecutorOutput>,
) {
use portable_pty::{CommandBuilder, PtySize, native_pty_system};
use std::sync::mpsc as std_mpsc;
tracing::debug!("[PTY] Starting execute_command_pty");
tracing::debug!("[PTY] Command length: {} chars", cmd.len());
// Open PTY
let pty_system = native_pty_system();
let pty_size = PtySize {
rows: 24,
cols: 80,
pixel_width: 0,
pixel_height: 0,
};
tracing::debug!("[PTY] Opening PTY");
let pty = match pty_system.openpty(pty_size) {
Ok(pty) => pty,
Err(e) => {
tracing::error!("[PTY] Failed to open PTY: {e}");
let _ = res_tx.send(ExecutorOutput::Error(format!("Failed to open PTY: {e}")));
return;
}
};
// Spawn command
let mut cmd_builder = CommandBuilder::new("bash");
cmd_builder.arg("-c");
cmd_builder.arg(cmd);
tracing::debug!("[PTY] Spawning bash command");
let mut child = match pty.slave.spawn_command(cmd_builder) {
Ok(child) => child,
Err(e) => {
tracing::error!("[PTY] Failed to spawn command: {e}");
let _ = res_tx.send(ExecutorOutput::Error(format!("Failed to spawn: {e}")));
return;
}
};
// Setup reader thread
let reader = pty
.master
.try_clone_reader()
.expect("Failed to clone reader");
let _master = pty.master; // Keep master alive
let (data_tx, data_rx) = std_mpsc::channel::<Vec<u8>>();
spawn_pty_reader_thread(reader, data_tx);
// Process output
let mut byte_buffer = Vec::new();
let mut line_buffer = String::new();
let mut lines_sent: usize = 0;
tracing::debug!("[PTY] Entering main processing loop");
loop {
// Check if child has exited
match child.try_wait() {
Ok(Some(status)) => {
tracing::debug!("[PTY] Child exited with code: {:?}", status.exit_code());
drain_remaining_data(
&data_rx,
&mut byte_buffer,
&mut line_buffer,
&mut lines_sent,
&res_tx,
);
send_finish_message(
&line_buffer,
&mut lines_sent,
status.exit_code(),
&res_tx,
"",
);
return;
}
Ok(None) => {} // Still running
Err(e) => {
tracing::error!("[PTY] Error checking child status: {e}");
let _ = res_tx.send(ExecutorOutput::Error(format!("Process error: {e}")));
return;
}
}
// Receive data with timeout
match data_rx.recv_timeout(std::time::Duration::from_millis(50)) {
Ok(data) if data.is_empty() => {
tracing::debug!("[PTY] Got EOF signal");
break;
}
Ok(data) => {
byte_buffer.extend_from_slice(&data);
lines_sent += process_byte_buffer_utf8(&mut byte_buffer, &mut line_buffer, &res_tx);
}
Err(std_mpsc::RecvTimeoutError::Timeout) => {}
Err(std_mpsc::RecvTimeoutError::Disconnected) => {
tracing::debug!("[PTY] Read thread disconnected");
break;
}
}
}
// Wait for process and send finish (EOF path)
tracing::debug!("[PTY] Waiting for child process after EOF");
match child.wait() {
Ok(status) => {
send_finish_message(
&line_buffer,
&mut lines_sent,
status.exit_code(),
&res_tx,
" (post-loop)",
);
}
Err(e) => {
tracing::error!("[PTY] Child wait error: {e}");
let _ = res_tx.send(ExecutorOutput::Error(format!("Wait error: {e}")));
}
}
}
/// What: Drain remaining data from channel after child exits.
///
/// Inputs:
/// - `data_rx`: Channel receiver
/// - `byte_buffer`: Buffer to accumulate bytes
/// - `line_buffer`: Buffer for line text
/// - `lines_sent`: Counter for lines sent
/// - `res_tx`: Channel to send output
#[cfg(not(target_os = "windows"))]
fn drain_remaining_data(
data_rx: &std::sync::mpsc::Receiver<Vec<u8>>,
byte_buffer: &mut Vec<u8>,
line_buffer: &mut String,
lines_sent: &mut usize,
res_tx: &mpsc::UnboundedSender<ExecutorOutput>,
) {
while let Ok(data) = data_rx.recv_timeout(std::time::Duration::from_millis(100)) {
if data.is_empty() {
break;
}
byte_buffer.extend_from_slice(&data);
if let Ok(text) = String::from_utf8(byte_buffer.clone()) {
byte_buffer.clear();
*lines_sent += process_text_chars(&text, line_buffer, res_tx);
}
}
}
#[cfg(target_os = "windows")]
/// What: Placeholder executor worker for Windows (unsupported).
///
/// Inputs:
/// - `executor_req_rx`: Channel receiver for executor requests
/// - `executor_res_tx`: Channel sender for executor output
///
/// Details:
/// - Windows is not supported for PTY-based execution
pub fn spawn_executor_worker(
mut executor_req_rx: mpsc::UnboundedReceiver<ExecutorRequest>,
executor_res_tx: mpsc::UnboundedSender<ExecutorOutput>,
) {
tokio::spawn(async move {
while let Some(_request) = executor_req_rx.recv().await {
let _ = executor_res_tx.send(ExecutorOutput::Error(
"PTY execution is not supported on Windows".to_string(),
));
}
});
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/app/runtime/workers/mod.rs | src/app/runtime/workers/mod.rs | /// Auxiliary background workers (status, news, tick, index updates).
pub mod auxiliary;
/// AUR comments fetching worker.
pub mod comments;
/// Package details fetching worker.
pub mod details;
/// Package installation/removal executor worker.
pub mod executor;
/// News feed filtering and worker functions.
pub mod news;
/// News article content fetching worker.
pub mod news_content;
/// Preflight analysis workers (dependencies, files, services, sandbox, summary).
pub mod preflight;
/// Package search worker.
pub mod search;
/// Package update checking, parsing, and worker functions.
pub mod updates;
/// Helper functions for update checking (system checks, temp DB).
mod updates_helpers;
/// Parsing functions for update command output.
mod updates_parsing;
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/app/runtime/workers/updates_helpers.rs | src/app/runtime/workers/updates_helpers.rs | /// What: Check which AUR helper is available (paru or yay).
///
/// Output:
/// - Tuple of (`has_paru`, `has_yay`, `helper_name`)
pub fn check_aur_helper() -> (bool, bool, &'static str) {
use std::process::{Command, Stdio};
let has_paru = Command::new("paru")
.args(["--version"])
.stdin(Stdio::null())
.stdout(Stdio::null())
.stderr(Stdio::null())
.output()
.is_ok();
let has_yay = if has_paru {
false
} else {
Command::new("yay")
.args(["--version"])
.stdin(Stdio::null())
.stdout(Stdio::null())
.stderr(Stdio::null())
.output()
.is_ok()
};
let helper = if has_paru { "paru" } else { "yay" };
if has_paru || has_yay {
tracing::debug!("Using {} to check for AUR updates", helper);
}
(has_paru, has_yay, helper)
}
/// What: Check if fakeroot is available on the system.
///
/// Output:
/// - `true` if fakeroot is available, `false` otherwise
///
/// Details:
/// - Fakeroot is required to sync a temporary pacman database without root
#[cfg(not(target_os = "windows"))]
pub fn has_fakeroot() -> bool {
use std::process::{Command, Stdio};
Command::new("fakeroot")
.args(["--version"])
.stdin(Stdio::null())
.stdout(Stdio::null())
.stderr(Stdio::null())
.output()
.is_ok()
}
/// What: Check if checkupdates is available on the system.
///
/// Output:
/// - `true` if checkupdates is available, `false` otherwise
///
/// Details:
/// - checkupdates (from pacman-contrib) can check for updates without root
/// - It automatically syncs the database and doesn't require fakeroot
#[cfg(not(target_os = "windows"))]
pub fn has_checkupdates() -> bool {
use std::process::{Command, Stdio};
Command::new("checkupdates")
.args(["--version"])
.stdin(Stdio::null())
.stdout(Stdio::null())
.stderr(Stdio::null())
.output()
.is_ok()
}
/// What: Get the current user's UID by reading /proc/self/status.
///
/// Output:
/// - `Some(u32)` with the UID if successful
/// - `None` if unable to read the UID
///
/// Details:
/// - Reads /proc/self/status and parses the Uid line
/// - Returns the real UID (first value on the Uid line)
#[cfg(not(target_os = "windows"))]
pub fn get_uid() -> Option<u32> {
let status = std::fs::read_to_string("/proc/self/status").ok()?;
for line in status.lines() {
if line.starts_with("Uid:") {
// Format: "Uid:\treal\teffective\tsaved\tfs"
let parts: Vec<&str> = line.split_whitespace().collect();
if parts.len() >= 2 {
return parts[1].parse().ok();
}
}
}
None
}
/// What: Set up a temporary pacman database directory for safe update checks.
///
/// Output:
/// - `Some(PathBuf)` with the temp database path if setup succeeds
/// - `None` if setup fails
///
/// Details:
/// - Creates `/tmp/pacsea-db-{UID}/` directory
/// - Creates a symlink from `local` to `/var/lib/pacman/local`
/// - The symlink allows pacman to know which packages are installed
/// - Directory is kept for reuse across subsequent checks
#[cfg(not(target_os = "windows"))]
pub fn setup_temp_db() -> Option<std::path::PathBuf> {
// Get current user ID
let uid = get_uid()?;
let temp_db = std::path::PathBuf::from(format!("/tmp/pacsea-db-{uid}"));
// Create directory if needed
if let Err(e) = std::fs::create_dir_all(&temp_db) {
tracing::warn!("Failed to create temp database directory: {}", e);
return None;
}
// Create symlink to local database (skip if exists)
let local_link = temp_db.join("local");
if !local_link.exists()
&& let Err(e) = std::os::unix::fs::symlink("/var/lib/pacman/local", &local_link)
{
tracing::warn!("Failed to create symlink to local database: {}", e);
return None;
}
Some(temp_db)
}
/// What: Sync the temporary pacman database with remote repositories.
///
/// Inputs:
/// - `temp_db`: Path to the temporary database directory
///
/// Output:
/// - `true` if sync succeeds, `false` otherwise
///
/// Details:
/// - Uses fakeroot to run `pacman -Sy` without root privileges
/// - Syncs only the temporary database, not the system database
/// - Uses `--logfile /dev/null` to prevent log file creation
/// - Logs stderr on failure to help diagnose sync issues
#[cfg(not(target_os = "windows"))]
pub fn sync_temp_db(temp_db: &std::path::Path) -> bool {
use std::process::{Command, Stdio};
let output = Command::new("fakeroot")
.args(["--", "pacman", "-Sy", "--dbpath"])
.arg(temp_db)
.args(["--logfile", "/dev/null"])
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.output();
match output {
Ok(o) if o.status.success() => true,
Ok(o) => {
// Log stderr to help diagnose sync failures
let stderr = String::from_utf8_lossy(&o.stderr);
if !stderr.trim().is_empty() {
tracing::warn!(
"Temp database sync failed (exit code: {:?}): {}",
o.status.code(),
stderr.trim()
);
}
false
}
Err(e) => {
tracing::warn!("Failed to execute fakeroot pacman -Sy: {}", e);
false
}
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/app/runtime/workers/auxiliary.rs | src/app/runtime/workers/auxiliary.rs | use std::sync::Arc;
use std::sync::atomic::AtomicBool;
use crossterm::event::Event as CEvent;
use tokio::sync::mpsc;
use tokio::sync::oneshot;
use tokio::time::{Duration, sleep};
use crate::index as pkgindex;
use crate::sources;
use crate::state::ArchStatusColor;
use crate::app::runtime::workers::news;
use crate::app::runtime::workers::updates;
/// What: Spawns Arch status worker that fetches status once at startup and periodically.
///
/// Inputs:
/// - `status_tx`: Channel sender for Arch status updates
///
/// Output:
/// - None (spawns async task)
///
/// Details:
/// - Fetches Arch status text once at startup
/// - Periodically refreshes Arch status every 120 seconds
fn spawn_status_worker(status_tx: &mpsc::UnboundedSender<(String, ArchStatusColor)>) {
// Fetch Arch status text once at startup
let status_tx_once = status_tx.clone();
tokio::spawn(async move {
if let Ok((txt, color)) = sources::fetch_arch_status_text().await {
let _ = status_tx_once.send((txt, color));
}
});
// Periodically refresh Arch status every 120 seconds
let status_tx_periodic = status_tx.clone();
tokio::spawn(async move {
loop {
sleep(Duration::from_secs(120)).await;
if let Ok((txt, color)) = sources::fetch_arch_status_text().await {
let _ = status_tx_periodic.send((txt, color));
}
}
});
}
/// What: Spawns announcement worker that fetches remote announcement from GitHub Gist.
///
/// Inputs:
/// - `announcement_tx`: Channel sender for remote announcement updates
///
/// Output:
/// - None (spawns async task)
///
/// Details:
/// - Fetches remote announcement from hardcoded Gist URL
/// - Sends announcement to channel if successfully fetched and parsed
fn spawn_announcement_worker(
announcement_tx: &mpsc::UnboundedSender<crate::announcements::RemoteAnnouncement>,
) {
let announcement_tx_once = announcement_tx.clone();
// Hardcoded Gist URL for remote announcements
let url = "https://gist.githubusercontent.com/Firstp1ck/d2e6016b8d7a90f813a582078208e9bd/raw/announcement.json".to_string();
tokio::spawn(async move {
tracing::info!(url = %url, "fetching remote announcement");
match reqwest::get(&url).await {
Ok(response) => {
tracing::debug!(
status = response.status().as_u16(),
"announcement fetch response received"
);
match response
.json::<crate::announcements::RemoteAnnouncement>()
.await
{
Ok(json) => {
tracing::info!(id = %json.id, "announcement fetched successfully");
let _ = announcement_tx_once.send(json);
}
Err(e) => {
tracing::warn!(error = %e, "failed to parse announcement JSON");
}
}
}
Err(e) => {
tracing::warn!(url = %url, error = %e, "failed to fetch announcement");
}
}
});
}
/// What: Spawns index update worker for Windows platform.
///
/// Inputs:
/// - `official_index_path`: Path to official package index
/// - `net_err_tx`: Channel sender for network errors
/// - `index_notify_tx`: Channel sender for index update notifications
///
/// Output:
/// - None (spawns async task)
///
/// Details:
/// - Windows-specific: saves mirrors and builds index via Arch API
#[cfg(windows)]
fn spawn_index_update_worker(
official_index_path: &std::path::Path,
net_err_tx: &mpsc::UnboundedSender<String>,
index_notify_tx: &mpsc::UnboundedSender<()>,
) {
let repo_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("repository");
let index_path = official_index_path.to_path_buf();
let net_err = net_err_tx.clone();
let index_notify = index_notify_tx.clone();
tokio::spawn(async move {
crate::index::refresh_windows_mirrors_and_index(
index_path,
repo_dir,
net_err,
index_notify,
)
.await;
});
}
/// What: Spawns index update worker for non-Windows platforms.
///
/// Inputs:
/// - `headless`: When `true`, skip index update
/// - `official_index_path`: Path to official package index
/// - `net_err_tx`: Channel sender for network errors
/// - `index_notify_tx`: Channel sender for index update notifications
///
/// Output:
/// - None (spawns async task)
///
/// Details:
/// - Updates package index in background
/// - Skips in headless mode to avoid slow network/disk operations
#[cfg(not(windows))]
fn spawn_index_update_worker(
headless: bool,
official_index_path: &std::path::Path,
net_err_tx: &mpsc::UnboundedSender<String>,
index_notify_tx: &mpsc::UnboundedSender<()>,
) {
if headless {
return;
}
let index_path = official_index_path.to_path_buf();
let net_err = net_err_tx.clone();
let index_notify = index_notify_tx.clone();
tokio::spawn(async move {
pkgindex::update_in_background(index_path, net_err, index_notify).await;
});
}
/// What: Spawns cache refresh worker that refreshes pacman caches.
///
/// Inputs:
/// - `installed_packages_mode`: Filter mode for installed packages
///
/// Output:
/// - None (spawns async task)
///
/// Details:
/// - Refreshes installed and explicit package caches
/// - Uses the configured installed packages mode
fn spawn_cache_refresh_worker(installed_packages_mode: crate::state::InstalledPackagesMode) {
let mode = installed_packages_mode;
tokio::spawn(async move {
pkgindex::refresh_installed_cache().await;
pkgindex::refresh_explicit_cache(mode).await;
});
}
/// What: Spawns tick worker that sends tick events every 200ms.
///
/// Inputs:
/// - `tick_tx`: Channel sender for tick events
///
/// Output:
/// - None (spawns async task)
///
/// Details:
/// - Sends tick events every 200ms to drive UI updates
fn spawn_tick_worker(tick_tx: &mpsc::UnboundedSender<()>) {
let tick_tx_bg = tick_tx.clone();
tokio::spawn(async move {
let mut interval = tokio::time::interval(Duration::from_millis(200));
loop {
interval.tick().await;
let _ = tick_tx_bg.send(());
}
});
}
/// What: Spawns faillock check worker that triggers tick events every minute.
///
/// Inputs:
/// - `tick_tx`: Channel sender for tick events
///
/// Output:
/// - None (spawns async task)
///
/// Details:
/// - Triggers tick events every 60 seconds to update faillock status in UI
fn spawn_faillock_worker(tick_tx: &mpsc::UnboundedSender<()>) {
let faillock_tx = tick_tx.clone();
tokio::spawn(async move {
let mut interval = tokio::time::interval(Duration::from_secs(60));
// Skip the first tick to avoid immediate check after startup
interval.tick().await;
loop {
interval.tick().await;
// Trigger a tick to update faillock status in the UI
let _ = faillock_tx.send(());
}
});
}
/// What: Spawn background workers for status, news, announcements, and tick events.
///
/// Inputs:
/// - `headless`: When `true`, skip terminal-dependent operations
/// - `status_tx`: Channel sender for Arch status updates
/// - `news_tx`: Channel sender for Arch news updates
/// - `news_feed_tx`: Channel sender for aggregated news feed (Arch news + advisories)
/// - `news_incremental_tx`: Channel sender for incremental background news items
/// - `announcement_tx`: Channel sender for remote announcement updates
/// - `tick_tx`: Channel sender for tick events
/// - `news_read_ids`: Set of already-read news IDs
/// - `news_read_urls`: Set of already-read news URLs
/// - `official_index_path`: Path to official package index
/// - `net_err_tx`: Channel sender for network errors
/// - `index_notify_tx`: Channel sender for index update notifications
/// - `updates_tx`: Channel sender for package updates
/// - `updates_refresh_interval`: Refresh interval in seconds for pacman -Qu and AUR helper checks
/// - `installed_packages_mode`: Filter mode for installed packages (leaf only vs all explicit)
/// - `get_announcement`: Whether to fetch remote announcements from GitHub Gist
/// - `last_startup_timestamp`: Previous TUI startup time (`YYYYMMDD:HHMMSS`) for incremental updates
///
/// Details:
/// - Fetches Arch status text once at startup and periodically every 120 seconds
/// - Fetches Arch news once at startup, filtering out already-read items
/// - Fetches remote announcement once at startup if URL is configured
/// - Updates package index in background (Windows vs non-Windows handling)
/// - Refreshes pacman caches (installed, explicit) using the configured installed packages mode
/// - Spawns tick worker that sends events every 200ms
/// - Checks for available package updates once at startup and periodically at configured interval
#[allow(clippy::too_many_arguments)]
pub fn spawn_auxiliary_workers(
headless: bool,
status_tx: &mpsc::UnboundedSender<(String, ArchStatusColor)>,
news_tx: &mpsc::UnboundedSender<Vec<crate::state::types::NewsFeedItem>>,
news_feed_tx: &mpsc::UnboundedSender<crate::state::types::NewsFeedPayload>,
news_incremental_tx: &mpsc::UnboundedSender<crate::state::types::NewsFeedItem>,
announcement_tx: &mpsc::UnboundedSender<crate::announcements::RemoteAnnouncement>,
tick_tx: &mpsc::UnboundedSender<()>,
news_read_ids: &std::collections::HashSet<String>,
news_read_urls: &std::collections::HashSet<String>,
news_seen_pkg_versions: &std::collections::HashMap<String, String>,
news_seen_aur_comments: &std::collections::HashMap<String, String>,
official_index_path: &std::path::Path,
net_err_tx: &mpsc::UnboundedSender<String>,
index_notify_tx: &mpsc::UnboundedSender<()>,
updates_tx: &mpsc::UnboundedSender<(usize, Vec<String>)>,
updates_refresh_interval: u64,
installed_packages_mode: crate::state::InstalledPackagesMode,
get_announcement: bool,
last_startup_timestamp: Option<&str>,
) {
tracing::info!(
headless,
get_announcement,
updates_refresh_interval,
"auxiliary workers starting"
);
// Spawn status worker (skip in headless mode)
if !headless {
spawn_status_worker(status_tx);
}
// Handle news workers
if headless {
tracing::info!("headless mode: skipping news/advisory fetch and announcements");
// In headless mode, send empty array to news channel to ensure event loop doesn't hang
let news_tx_headless = news_tx.clone();
tokio::spawn(async move {
tracing::debug!("headless mode: sending empty news array to clear any pending waits");
let _ = news_tx_headless.send(Vec::new());
});
} else {
// Create a oneshot channel to coordinate startup and aggregated news fetches
// This prevents concurrent requests to archlinux.org which can cause rate limiting/blocking
let (completion_tx, completion_rx) = oneshot::channel();
news::spawn_startup_news_worker(
news_tx,
news_read_ids,
news_read_urls,
news_seen_pkg_versions,
news_seen_aur_comments,
last_startup_timestamp,
Some(completion_tx),
);
news::spawn_aggregated_news_feed_worker(
news_feed_tx,
news_incremental_tx,
news_seen_pkg_versions,
news_seen_aur_comments,
Some(completion_rx),
);
}
// Spawn announcement worker (skip in headless mode)
if !headless && get_announcement {
spawn_announcement_worker(announcement_tx);
}
// Spawn index update worker (platform-specific)
#[cfg(windows)]
spawn_index_update_worker(official_index_path, net_err_tx, index_notify_tx);
#[cfg(not(windows))]
spawn_index_update_worker(headless, official_index_path, net_err_tx, index_notify_tx);
// Spawn cache refresh worker (skip in headless mode)
if !headless {
spawn_cache_refresh_worker(installed_packages_mode);
}
// Spawn periodic updates worker (skip in headless mode)
if !headless {
updates::spawn_periodic_updates_worker(updates_tx, updates_refresh_interval);
}
// Spawn tick worker (always runs)
spawn_tick_worker(tick_tx);
// Spawn faillock worker (skip in headless mode)
if !headless {
spawn_faillock_worker(tick_tx);
}
}
/// What: Spawn event reading thread for terminal input.
///
/// Inputs:
/// - `headless`: When `true`, skip spawning the thread
/// - `event_tx`: Channel sender for terminal events
/// - `event_thread_cancelled`: Atomic flag to signal thread cancellation
///
/// Details:
/// - Spawns a blocking thread that polls for terminal events
/// - Checks cancellation flag periodically to allow immediate exit
/// - Uses 50ms poll timeout to balance responsiveness and CPU usage
pub fn spawn_event_thread(
headless: bool,
event_tx: mpsc::UnboundedSender<CEvent>,
event_thread_cancelled: Arc<AtomicBool>,
) {
if !headless {
let event_tx_for_thread = event_tx;
let cancelled = event_thread_cancelled;
std::thread::spawn(move || {
loop {
// Check cancellation flag first for immediate exit
if cancelled.load(std::sync::atomic::Ordering::Relaxed) {
break;
}
// Use poll with timeout to allow periodic cancellation checks
// This prevents blocking indefinitely when exit is requested
match crossterm::event::poll(std::time::Duration::from_millis(50)) {
Ok(true) => {
// Event available, read it
if let Ok(ev) = crossterm::event::read() {
// Check cancellation again before sending
if cancelled.load(std::sync::atomic::Ordering::Relaxed) {
break;
}
// Check if channel is still open before sending
// When receiver is dropped (on exit), send will fail
if event_tx_for_thread.send(ev).is_err() {
// Channel closed, exit thread
break;
}
}
// ignore transient read errors and continue
}
Ok(false) => {
// No event available, check cancellation flag
// This allows the thread to exit promptly when exit is requested
if cancelled.load(std::sync::atomic::Ordering::Relaxed) {
break;
}
}
Err(_) => {
// Poll error, check cancellation before continuing
if cancelled.load(std::sync::atomic::Ordering::Relaxed) {
break;
}
}
}
}
});
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/app/runtime/workers/details.rs | src/app/runtime/workers/details.rs | use tokio::sync::mpsc;
use tokio::time::{Duration, sleep};
use crate::sources;
use crate::sources::fetch_details;
use crate::state::{PackageDetails, PackageItem, Source};
/// What: Spawn background worker for batched package details fetching.
///
/// Inputs:
/// - `net_err_tx`: Channel sender for network errors
/// - `details_req_rx`: Channel receiver for detail requests
/// - `details_res_tx`: Channel sender for detail responses
///
/// Details:
/// - Batches requests within a 120ms window to reduce network calls
/// - Deduplicates requests by package name
/// - Filters out disallowed packages
pub fn spawn_details_worker(
net_err_tx: &mpsc::UnboundedSender<String>,
mut details_req_rx: mpsc::UnboundedReceiver<PackageItem>,
details_res_tx: mpsc::UnboundedSender<PackageDetails>,
) {
use std::collections::HashSet;
let net_err_tx_details = net_err_tx.clone();
tokio::spawn(async move {
const DETAILS_BATCH_WINDOW_MS: u64 = 120;
loop {
let Some(first) = details_req_rx.recv().await else {
break;
};
let mut batch: Vec<PackageItem> = vec![first];
loop {
tokio::select! {
Some(next) = details_req_rx.recv() => { batch.push(next); }
() = sleep(Duration::from_millis(DETAILS_BATCH_WINDOW_MS)) => { break; }
}
}
let mut seen: HashSet<String> = HashSet::new();
let mut ordered: Vec<PackageItem> = Vec::with_capacity(batch.len());
for it in batch {
if seen.insert(it.name.clone()) {
ordered.push(it);
}
}
for it in ordered {
if !crate::logic::is_allowed(&it.name) {
continue;
}
match fetch_details(it.clone()).await {
Ok(details) => {
let _ = details_res_tx.send(details);
}
Err(e) => {
let msg = match it.source {
Source::Official { .. } => format!(
"Official package details unavailable for {}: {}",
it.name, e
),
Source::Aur => {
format!("AUR package details unavailable for {}: {e}", it.name)
}
};
let _ = net_err_tx_details.send(msg);
}
}
}
}
});
}
/// What: Spawn background worker for PKGBUILD fetching.
///
/// Inputs:
/// - `pkgb_req_rx`: Channel receiver for PKGBUILD requests
/// - `pkgb_res_tx`: Channel sender for PKGBUILD responses
pub fn spawn_pkgbuild_worker(
mut pkgb_req_rx: mpsc::UnboundedReceiver<PackageItem>,
pkgb_res_tx: mpsc::UnboundedSender<(String, String)>,
) {
tokio::spawn(async move {
while let Some(item) = pkgb_req_rx.recv().await {
let name = item.name.clone();
match sources::fetch_pkgbuild_fast(&item).await {
Ok(txt) => {
let _ = pkgb_res_tx.send((name, txt));
}
Err(e) => {
let _ = pkgb_res_tx.send((name, format!("Failed to fetch PKGBUILD: {e}")));
}
}
}
});
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/app/runtime/workers/news.rs | src/app/runtime/workers/news.rs | use std::collections::HashSet;
use rand::Rng;
use tokio::{sync::mpsc, sync::oneshot, time::Duration};
use crate::index as pkgindex;
use crate::sources;
use crate::state::types::{NewsFeedSource, NewsSortMode};
/// What: Ensures installed packages set is populated, refreshing caches if needed.
///
/// Inputs:
/// - `installed`: Initial set of installed package names
///
/// Output:
/// - `HashSet<String>` with installed package names (refreshed if needed)
///
/// Details:
/// - If the initial set is empty, refreshes installed and explicit caches
/// - Returns refreshed set if available, otherwise returns original set
pub async fn ensure_installed_set(installed: HashSet<String>) -> HashSet<String> {
if installed.is_empty() {
crate::index::refresh_installed_cache().await;
crate::index::refresh_explicit_cache(crate::state::InstalledPackagesMode::AllExplicit)
.await;
let refreshed: HashSet<String> = pkgindex::explicit_names().into_iter().collect();
if !refreshed.is_empty() {
return refreshed;
}
}
installed
}
/// What: Filters news feed items by source type based on startup news preferences.
///
/// Inputs:
/// - `feed`: Vector of news feed items to filter
/// - `prefs`: Theme settings containing startup news preferences
///
/// Output:
/// - Filtered vector of news feed items
///
/// Details:
/// - Filters items based on whether each source type is enabled in preferences
pub fn filter_news_by_source(
feed: Vec<crate::state::types::NewsFeedItem>,
prefs: &crate::theme::Settings,
) -> Vec<crate::state::types::NewsFeedItem> {
feed.into_iter()
.filter(|item| match item.source {
crate::state::types::NewsFeedSource::ArchNews => prefs.startup_news_show_arch_news,
crate::state::types::NewsFeedSource::SecurityAdvisory => {
prefs.startup_news_show_advisories
}
crate::state::types::NewsFeedSource::InstalledPackageUpdate => {
prefs.startup_news_show_pkg_updates
}
crate::state::types::NewsFeedSource::AurPackageUpdate => {
prefs.startup_news_show_aur_updates
}
crate::state::types::NewsFeedSource::AurComment => prefs.startup_news_show_aur_comments,
})
.collect()
}
/// What: Filters news feed items by maximum age in days.
///
/// Inputs:
/// - `feed`: Vector of news feed items to filter
/// - `max_age_days`: Optional maximum age in days
///
/// Output:
/// - Filtered vector of news feed items
///
/// Details:
/// - If `max_age_days` is Some, filters out items older than the cutoff date
/// - If `max_age_days` is None, returns all items unchanged
pub fn filter_news_by_age(
feed: Vec<crate::state::types::NewsFeedItem>,
max_age_days: Option<u32>,
) -> Vec<crate::state::types::NewsFeedItem> {
if let Some(max_days) = max_age_days {
let cutoff_date = chrono::Utc::now()
.checked_sub_signed(chrono::Duration::days(i64::from(max_days)))
.map(|dt| dt.format("%Y-%m-%d").to_string());
#[allow(clippy::unnecessary_map_or)]
feed.into_iter()
.filter(|item| {
cutoff_date
.as_ref()
.map_or(true, |cutoff| &item.date >= cutoff)
})
.collect()
} else {
feed
}
}
/// What: Filters out already-read news items by ID and URL.
///
/// Inputs:
/// - `feed`: Vector of news feed items to filter
/// - `read_ids`: Set of already-read news IDs
/// - `read_urls`: Set of already-read news URLs
///
/// Output:
/// - Filtered vector containing only unread items
///
/// Details:
/// - Removes items whose ID is in the `read_ids` set or whose URL is in the `read_urls` set
/// - Package updates and AUR comments are tracked by ID, while Arch news items are tracked by URL
pub fn filter_unread_news(
feed: Vec<crate::state::types::NewsFeedItem>,
read_ids: &HashSet<String>,
read_urls: &HashSet<String>,
) -> Vec<crate::state::types::NewsFeedItem> {
feed.into_iter()
.filter(|item| {
!read_ids.contains(&item.id)
&& item.url.as_ref().is_none_or(|url| !read_urls.contains(url))
})
.collect()
}
/// What: Spawns startup news worker that fetches and filters news items for startup popup.
///
/// Inputs:
/// - `news_tx`: Channel sender for startup news updates
/// - `news_read_ids`: Set of already-read news IDs
/// - `news_read_urls`: Set of already-read news URLs
/// - `news_seen_pkg_versions`: Map of seen package versions
/// - `news_seen_aur_comments`: Map of seen AUR comments
/// - `last_startup_timestamp`: Previous TUI startup time for incremental updates
/// - `completion_tx`: Optional oneshot sender to signal completion
///
/// Output:
/// - None (spawns async task)
///
/// Details:
/// - Fetches news items based on startup news preferences
/// - Filters by source type, max age, and read status (by both ID and URL)
/// - Sends filtered items to the news channel
pub fn spawn_startup_news_worker(
news_tx: &mpsc::UnboundedSender<Vec<crate::state::types::NewsFeedItem>>,
news_read_ids: &HashSet<String>,
news_read_urls: &HashSet<String>,
news_seen_pkg_versions: &std::collections::HashMap<String, String>,
news_seen_aur_comments: &std::collections::HashMap<String, String>,
last_startup_timestamp: Option<&str>,
completion_tx: Option<oneshot::Sender<()>>,
) {
let prefs = crate::theme::settings();
if !prefs.startup_news_configured {
// If startup news is not configured, signal completion immediately
if let Some(tx) = completion_tx {
let _ = tx.send(());
}
return;
}
let news_tx_once = news_tx.clone();
let read_ids = news_read_ids.clone();
let read_urls = news_read_urls.clone();
let installed: HashSet<String> = pkgindex::explicit_names().into_iter().collect();
let mut seen_versions = news_seen_pkg_versions.clone();
let mut seen_aur_comments = news_seen_aur_comments.clone();
let last_startup = last_startup_timestamp.map(str::to_owned);
tracing::info!(
read_ids = read_ids.len(),
read_urls = read_urls.len(),
last_startup = ?last_startup,
"queueing startup news fetch (startup)"
);
tokio::spawn(async move {
// Use random jitter (0-500ms) before startup news fetch
// Keep this short since the startup popup should appear quickly
let jitter_ms = rand::rng().random_range(0..=500_u64);
if jitter_ms > 0 {
tracing::info!(jitter_ms, "staggering startup news fetch");
tokio::time::sleep(Duration::from_millis(jitter_ms)).await;
}
tracing::info!("startup news fetch task started");
let optimized_max_age = sources::optimize_max_age_for_startup(
last_startup.as_deref(),
prefs.startup_news_max_age_days,
);
let installed_set = ensure_installed_set(installed).await;
let include_pkg_updates =
prefs.startup_news_show_pkg_updates || prefs.startup_news_show_aur_updates;
#[allow(clippy::items_after_statements)]
const STARTUP_NEWS_LIMIT: usize = 20;
let updates_limit =
if prefs.startup_news_show_pkg_updates && prefs.startup_news_show_aur_updates {
STARTUP_NEWS_LIMIT * 2
} else {
STARTUP_NEWS_LIMIT
};
let ctx = sources::NewsFeedContext {
force_emit_all: true,
updates_list_path: Some(crate::theme::lists_dir().join("available_updates.txt")),
limit: updates_limit,
include_arch_news: prefs.startup_news_show_arch_news,
include_advisories: prefs.startup_news_show_advisories,
include_pkg_updates,
include_aur_comments: prefs.startup_news_show_aur_comments,
installed_filter: Some(&installed_set),
installed_only: false,
sort_mode: NewsSortMode::DateDesc,
seen_pkg_versions: &mut seen_versions,
seen_aur_comments: &mut seen_aur_comments,
max_age_days: optimized_max_age,
};
tracing::info!(
limit = updates_limit,
include_arch_news = prefs.startup_news_show_arch_news,
include_advisories = prefs.startup_news_show_advisories,
include_pkg_updates,
include_aur_comments = prefs.startup_news_show_aur_comments,
configured_max_age = ?prefs.startup_news_max_age_days,
optimized_max_age = ?optimized_max_age,
installed_count = installed_set.len(),
"starting startup news fetch"
);
match sources::fetch_news_feed(ctx).await {
Ok(feed) => {
tracing::info!(
total_items = feed.len(),
"startup news fetch completed successfully"
);
let source_filtered = filter_news_by_source(feed, &prefs);
let filtered = filter_news_by_age(source_filtered, prefs.startup_news_max_age_days);
let unread = filter_unread_news(filtered, &read_ids, &read_urls);
tracing::info!(
unread_count = unread.len(),
"sending startup news items to channel"
);
match news_tx_once.send(unread) {
Ok(()) => {
tracing::info!("startup news items sent to channel successfully");
}
Err(e) => {
tracing::error!(
error = %e,
"failed to send startup news items to channel (receiver dropped?)"
);
}
}
}
Err(e) => {
tracing::warn!(error = %e, "startup news fetch failed");
tracing::info!("sending empty array to clear loading flag after fetch error");
let _ = news_tx_once.send(Vec::new());
}
}
// Signal completion to allow aggregated feed fetch to proceed
if let Some(tx) = completion_tx {
let _ = tx.send(());
}
});
}
/// What: Spawns aggregated news feed worker that fetches combined news feed.
///
/// Inputs:
/// - `news_feed_tx`: Channel sender for aggregated news feed
/// - `news_incremental_tx`: Channel sender for incremental background news items
/// - `news_seen_pkg_versions`: Map of seen package versions
/// - `news_seen_aur_comments`: Map of seen AUR comments
/// - `completion_rx`: Optional oneshot receiver to wait for startup news fetch completion
///
/// Output:
/// - None (spawns async task)
///
/// Details:
/// - Fetches aggregated news feed (Arch news + security advisories + package updates + AUR comments)
/// - Sends feed payload to the news feed channel
/// - Spawns background continuation task to fetch remaining items after initial limit
/// - Waits for startup news fetch to complete before starting to prevent concurrent archlinux.org requests
pub fn spawn_aggregated_news_feed_worker(
news_feed_tx: &mpsc::UnboundedSender<crate::state::types::NewsFeedPayload>,
news_incremental_tx: &mpsc::UnboundedSender<crate::state::types::NewsFeedItem>,
news_seen_pkg_versions: &std::collections::HashMap<String, String>,
news_seen_aur_comments: &std::collections::HashMap<String, String>,
completion_rx: Option<oneshot::Receiver<()>>,
) {
let news_feed_tx_once = news_feed_tx.clone();
let news_incremental_tx_clone = news_incremental_tx.clone();
let installed: HashSet<String> = pkgindex::explicit_names().into_iter().collect();
let mut seen_versions = news_seen_pkg_versions.clone();
let mut seen_aur_comments = news_seen_aur_comments.clone();
tracing::info!(
installed_names = installed.len(),
"queueing combined news feed fetch (startup)"
);
tokio::spawn(async move {
// Wait for startup news fetch to complete before starting aggregated feed fetch
// This prevents concurrent requests to archlinux.org which can cause rate limiting/blocking
if let Some(rx) = completion_rx {
tracing::info!(
"waiting for startup news fetch to complete before starting aggregated feed fetch"
);
let _ = rx.await; // Wait for startup fetch completion signal
// Add a small additional delay after startup fetch completes to ensure clean separation
let additional_delay_ms = rand::rng().random_range(500..=1500_u64);
tracing::info!(
additional_delay_ms,
"additional delay after startup fetch completion"
);
tokio::time::sleep(Duration::from_millis(additional_delay_ms)).await;
} else {
// Fallback: use fixed delay if no completion signal is provided
// This should not happen in normal operation, but provides safety
let base_delay_ms = 10000_u64; // Increased to 10 seconds as fallback
let jitter_ms = rand::rng().random_range(0..=2000_u64);
let stagger_ms = base_delay_ms + jitter_ms;
tracing::warn!(
stagger_ms,
"no completion signal available, using fallback delay for aggregated feed fetch"
);
tokio::time::sleep(Duration::from_millis(stagger_ms)).await;
}
let installed_set = ensure_installed_set(installed).await;
let ctx = sources::NewsFeedContext {
force_emit_all: true,
updates_list_path: Some(crate::theme::lists_dir().join("available_updates.txt")),
limit: 50,
include_arch_news: true,
include_advisories: true,
include_pkg_updates: true,
include_aur_comments: true,
installed_filter: Some(&installed_set),
installed_only: false,
sort_mode: NewsSortMode::DateDesc,
seen_pkg_versions: &mut seen_versions,
seen_aur_comments: &mut seen_aur_comments,
max_age_days: None, // Main feed doesn't use date filtering
};
match sources::fetch_news_feed(ctx).await {
Ok(feed) => {
let arch_ct = feed
.iter()
.filter(|i| matches!(i.source, NewsFeedSource::ArchNews))
.count();
let adv_ct = feed
.iter()
.filter(|i| matches!(i.source, NewsFeedSource::SecurityAdvisory))
.count();
tracing::info!(
total = feed.len(),
arch = arch_ct,
advisories = adv_ct,
installed_names = installed_set.len(),
"news feed fetched"
);
if feed.is_empty() {
tracing::warn!(
installed_names = installed_set.len(),
"news feed is empty after fetch"
);
}
let payload = crate::state::types::NewsFeedPayload {
items: feed.clone(),
seen_pkg_versions: seen_versions,
seen_aur_comments,
};
tracing::info!(
items_count = feed.len(),
"sending aggregated news feed payload to channel"
);
if let Err(e) = news_feed_tx_once.send(payload) {
tracing::warn!(error = ?e, "failed to send news feed to channel");
} else {
tracing::info!("aggregated news feed payload sent successfully");
// Spawn background continuation task to fetch remaining items
let initial_ids: HashSet<String> = feed.iter().map(|i| i.id.clone()).collect();
spawn_news_continuation_worker(
news_incremental_tx_clone.clone(),
installed_set.clone(),
initial_ids,
);
}
}
Err(e) => {
tracing::warn!(error = %e, "failed to fetch news feed");
}
}
});
}
/// What: Spawns background worker to continue fetching news items after initial limit.
///
/// Inputs:
/// - `news_incremental_tx`: Channel sender for incremental news items
/// - `installed_set`: Set of installed package names
/// - `initial_ids`: Set of item IDs already sent in initial batch
///
/// Output:
/// - None (spawns async task)
///
/// Details:
/// - Fetches remaining items from all news sources (no limit)
/// - Sends one item per second to the channel
/// - Skips items already in `initial_ids`
fn spawn_news_continuation_worker(
news_incremental_tx: mpsc::UnboundedSender<crate::state::types::NewsFeedItem>,
installed_set: HashSet<String>,
initial_ids: HashSet<String>,
) {
tokio::spawn(async move {
tracing::info!(
initial_count = initial_ids.len(),
"starting news continuation worker"
);
// Wait a bit before starting continuation to let UI settle
tokio::time::sleep(Duration::from_secs(2)).await;
// Fetch continuation items from sources (high limit to get everything)
let continuation_items =
sources::fetch_continuation_items(&installed_set, &initial_ids).await;
match continuation_items {
Ok(items) => {
tracing::info!(
count = items.len(),
"continuation worker received items to send"
);
for item in items {
// Skip if already sent in initial batch
if initial_ids.contains(&item.id) {
continue;
}
// Send item to channel
if let Err(e) = news_incremental_tx.send(item.clone()) {
tracing::warn!(error = ?e, "failed to send incremental news item");
break;
}
// Throttle: 1 item per second
tokio::time::sleep(Duration::from_secs(1)).await;
}
tracing::info!("news continuation worker completed");
}
Err(e) => {
tracing::warn!(error = %e, "news continuation fetch failed");
}
}
});
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/app/runtime/workers/updates.rs | src/app/runtime/workers/updates.rs | use std::sync::OnceLock;
use tokio::sync::mpsc;
use crate::app::runtime::workers::updates_helpers::check_aur_helper;
#[cfg(not(target_os = "windows"))]
use crate::app::runtime::workers::updates_helpers::{
has_checkupdates, has_fakeroot, setup_temp_db, sync_temp_db,
};
use crate::app::runtime::workers::updates_parsing::{
get_installed_version, parse_checkupdates, parse_checkupdates_tool, parse_qua,
};
/// What: Process pacman -Qu or checkupdates output and add packages to collections.
///
/// Inputs:
/// - `output`: Command output result
/// - `is_checkupdates_tool`: `true` if output is from checkupdates tool, `false` if from pacman -Qu
/// - `packages_map`: Mutable `HashMap` to store formatted package strings
/// - `packages_set`: Mutable `HashSet` to track unique package names
fn process_checkupdates_output(
output: Result<std::process::Output, std::io::Error>,
is_checkupdates_tool: bool,
packages_map: &mut std::collections::HashMap<String, String>,
packages_set: &mut std::collections::HashSet<String>,
) {
match output {
Ok(output) => {
let exit_code = output.status.code();
if output.status.success() {
if is_checkupdates_tool {
// Parse checkupdates output (package-name version format)
let packages = parse_checkupdates_tool(&output.stdout);
let count = packages.len();
for (name, new_version) in packages {
// Get old version from installed packages
let old_version =
get_installed_version(&name).unwrap_or_else(|| "unknown".to_string());
// Format: "name - old_version -> name - new_version"
let formatted = format!("{name} - {old_version} -> {name} - {new_version}");
packages_map.insert(name.clone(), formatted);
packages_set.insert(name);
}
tracing::debug!(
"checkupdates completed successfully (exit code: {:?}): found {} packages from official repos",
exit_code,
count
);
} else {
// Parse pacman -Qu output (package-name old_version -> new_version format)
let packages = parse_checkupdates(&output.stdout);
let count = packages.len();
for (name, old_version, new_version) in packages {
// Format: "name - old_version -> name - new_version"
let formatted = format!("{name} - {old_version} -> {name} - {new_version}");
packages_map.insert(name.clone(), formatted);
packages_set.insert(name);
}
tracing::debug!(
"pacman -Qu completed successfully (exit code: {:?}): found {} packages from official repos",
exit_code,
count
);
}
} else if output.status.code() == Some(1) {
// Exit code 1 is normal (no updates)
if is_checkupdates_tool {
tracing::debug!(
"checkupdates returned exit code 1 (no updates available in official repos)"
);
} else {
tracing::debug!(
"pacman -Qu returned exit code 1 (no updates available in official repos)"
);
}
} else {
// Other exit codes are errors
let stderr = String::from_utf8_lossy(&output.stderr);
if is_checkupdates_tool {
tracing::warn!(
"checkupdates command failed with exit code: {:?}, stderr: {}",
exit_code,
stderr.trim()
);
} else {
tracing::warn!("pacman -Qu command failed with exit code: {:?}", exit_code);
}
}
}
Err(e) => {
if is_checkupdates_tool {
tracing::warn!("Failed to execute checkupdates: {}", e);
} else {
tracing::warn!("Failed to execute pacman -Qu: {}", e);
}
}
}
}
/// What: Process -Qua output and add packages to collections.
///
/// Inputs:
/// - `result`: Command output result
/// - `helper`: Helper name for logging
/// - `packages_map`: Mutable `HashMap` to store formatted package strings
/// - `packages_set`: Mutable `HashSet` to track unique package names
fn process_qua_output(
result: Option<Result<std::process::Output, std::io::Error>>,
helper: &str,
packages_map: &mut std::collections::HashMap<String, String>,
packages_set: &mut std::collections::HashSet<String>,
) {
if let Some(result) = result {
match result {
Ok(output) => {
let exit_code = output.status.code();
if output.status.success() {
let packages = parse_qua(&output.stdout);
let count = packages.len();
let before_count = packages_set.len();
for (name, old_version, new_version) in packages {
// Format: "name - old_version -> name - new_version"
let formatted = format!("{name} - {old_version} -> {name} - {new_version}");
packages_map.insert(name.clone(), formatted);
packages_set.insert(name);
}
let after_count = packages_set.len();
tracing::debug!(
"{} -Qua completed successfully (exit code: {:?}): found {} packages from AUR, {} total ({} new)",
helper,
exit_code,
count,
after_count,
after_count - before_count
);
} else if output.status.code() == Some(1) {
// Exit code 1 is normal (no updates)
tracing::debug!(
"{} -Qua returned exit code 1 (no updates available in AUR)",
helper
);
} else {
// Other exit codes are errors
tracing::warn!(
"{} -Qua command failed with exit code: {:?}",
helper,
exit_code
);
}
}
Err(e) => {
tracing::warn!("Failed to execute {} -Qua: {}", helper, e);
}
}
} else {
tracing::debug!("No AUR helper available, skipping AUR updates check");
}
}
/// Static mutex to prevent concurrent update checks.
///
/// What: Tracks whether an update check is currently in progress.
///
/// Details:
/// - Uses `OnceLock` for lazy initialization
/// - Uses `tokio::sync::Mutex` for async-safe synchronization
/// - Prevents overlapping file writes to `available_updates.txt`
static UPDATE_CHECK_IN_PROGRESS: OnceLock<tokio::sync::Mutex<bool>> = OnceLock::new();
/// What: Spawn background worker to check for available package updates.
///
/// Inputs:
/// - `updates_tx`: Channel sender for updates (count, sorted list)
///
/// Output:
/// - None (spawns async task)
///
/// Details:
/// - Uses a temporary database to safely check for updates without modifying the system
/// - Syncs the temp database with `fakeroot pacman -Sy` if fakeroot is available
/// - Falls back to `pacman -Qu` (stale local DB) if fakeroot is not available
/// - Executes `yay -Qua` or `paru -Qua` for AUR updates
/// - Removes duplicates using `HashSet`
/// - Sorts package names alphabetically
/// - Saves list to `~/.config/pacsea/lists/available_updates.txt`
/// - Sends `(count, sorted_list)` via channel
/// - Uses synchronization to prevent concurrent update checks and file writes
#[allow(clippy::too_many_lines)] // Complex function handling multiple update check methods (function has 204 lines)
pub fn spawn_updates_worker(updates_tx: mpsc::UnboundedSender<(usize, Vec<String>)>) {
let updates_tx_once = updates_tx;
tokio::spawn(async move {
// Get mutex reference inside async block
let mutex = UPDATE_CHECK_IN_PROGRESS.get_or_init(|| tokio::sync::Mutex::new(false));
// Check if update check is already in progress
let mut in_progress = mutex.lock().await;
if *in_progress {
tracing::debug!("Update check already in progress, skipping concurrent call");
return;
}
// Set flag to indicate update check is in progress
*in_progress = true;
drop(in_progress); // Release lock before blocking operation
let result = tokio::task::spawn_blocking(move || {
use std::collections::HashSet;
use std::process::{Command, Stdio};
tracing::debug!("Starting update check");
let (has_paru, has_yay, helper) = check_aur_helper();
// Try safe update check with temp database (non-Windows only)
#[cfg(not(target_os = "windows"))]
let (temp_db_path, use_checkupdates_tool) = {
let db_result = if has_fakeroot() {
tracing::debug!("fakeroot is available, setting up temp database");
setup_temp_db().and_then(|temp_db| {
tracing::debug!("Syncing temporary database at {:?}", temp_db);
if sync_temp_db(&temp_db) {
tracing::debug!("Temp database sync successful");
Some(temp_db)
} else {
tracing::warn!("Temp database sync failed");
None
}
})
} else {
tracing::debug!("fakeroot not available");
None
};
// If temp database sync failed, try checkupdates as fallback
if db_result.is_none() && has_checkupdates() {
tracing::info!("Temp database sync failed, trying checkupdates as fallback");
(None, true)
} else if db_result.is_none() {
tracing::warn!("Temp database sync failed and checkupdates not available, falling back to pacman -Qu (may show stale results)");
(None, false)
} else {
(db_result, false)
}
};
// Execute update check command
#[cfg(not(target_os = "windows"))]
let (output_checkupdates, is_checkupdates_tool) = if use_checkupdates_tool {
tracing::info!("Executing: checkupdates (automatically syncs database)");
(
Command::new("checkupdates")
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.output(),
true,
)
} else if let Some(db_path) = temp_db_path.as_ref() {
tracing::debug!(
"Executing: pacman -Qu --dbpath {:?} (using synced temp database)",
db_path
);
(
Command::new("pacman")
.args(["-Qu", "--dbpath"])
.arg(db_path)
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::null())
.output(),
false,
)
} else {
tracing::debug!("Executing: pacman -Qu (using system database - may be stale)");
(
Command::new("pacman")
.args(["-Qu"])
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::null())
.output(),
false,
)
};
#[cfg(target_os = "windows")]
let (output_checkupdates, _is_checkupdates_tool) = {
tracing::debug!("Executing: pacman -Qu (Windows fallback)");
(
Command::new("pacman")
.args(["-Qu"])
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::null())
.output(),
false,
)
};
// Execute -Qua command (AUR) - only if helper is available
let output_qua = if has_paru {
tracing::debug!("Executing: paru -Qua (AUR updates)");
Some(
Command::new("paru")
.args(["-Qua"])
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::null())
.output(),
)
} else if has_yay {
tracing::debug!("Executing: yay -Qua (AUR updates)");
Some(
Command::new("yay")
.args(["-Qua"])
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::null())
.output(),
)
} else {
tracing::debug!("No AUR helper available (paru/yay), skipping AUR updates check");
None
};
// Collect packages from both commands
// Use HashMap to store: package_name -> formatted_string
// Use HashSet to track unique package names for deduplication
let mut packages_map: std::collections::HashMap<String, String> =
std::collections::HashMap::new();
let mut packages_set = HashSet::new();
// Parse pacman -Qu or checkupdates output (official repos)
#[cfg(target_os = "windows")]
let is_checkupdates_tool = false;
process_checkupdates_output(
output_checkupdates,
is_checkupdates_tool,
&mut packages_map,
&mut packages_set,
);
// Parse -Qua output (AUR)
process_qua_output(output_qua, helper, &mut packages_map, &mut packages_set);
// Convert to Vec of formatted strings, sorted by package name
let mut package_names: Vec<String> = packages_set.into_iter().collect();
package_names.sort_unstable();
let packages: Vec<String> = package_names
.iter()
.filter_map(|name| packages_map.get(name).cloned())
.collect();
let count = packages.len();
tracing::info!(
"Update check completed: found {} total available updates (after deduplication)",
count
);
// Save to file
let lists_dir = crate::theme::lists_dir();
let updates_file = lists_dir.join("available_updates.txt");
if let Err(e) = std::fs::write(&updates_file, packages.join("\n")) {
tracing::warn!("Failed to save updates list to file: {}", e);
} else {
tracing::debug!("Saved updates list to {:?}", updates_file);
}
// Return count and package names (for display) - not the formatted strings
(count, package_names)
})
.await;
// Reset flag when done (even on error)
let mutex = UPDATE_CHECK_IN_PROGRESS.get_or_init(|| tokio::sync::Mutex::new(false));
let mut in_progress = mutex.lock().await;
*in_progress = false;
drop(in_progress);
match result {
Ok((count, list)) => {
let _ = updates_tx_once.send((count, list));
}
Err(e) => {
tracing::error!("Updates worker task panicked: {:?}", e);
let _ = updates_tx_once.send((0, Vec::new()));
}
}
});
}
/// What: Spawns periodic updates worker that checks for package updates at intervals.
///
/// Inputs:
/// - `updates_tx`: Channel sender for package updates
/// - `updates_refresh_interval`: Refresh interval in seconds
///
/// Output:
/// - None (spawns async task)
///
/// Details:
/// - Checks for updates once at startup
/// - Periodically refreshes updates list at configured interval
pub fn spawn_periodic_updates_worker(
updates_tx: &mpsc::UnboundedSender<(usize, Vec<String>)>,
updates_refresh_interval: u64,
) {
spawn_updates_worker(updates_tx.clone());
let updates_tx_periodic = updates_tx.clone();
tokio::spawn(async move {
let mut interval =
tokio::time::interval(tokio::time::Duration::from_secs(updates_refresh_interval));
// Skip the first tick to avoid immediate refresh after startup
interval.tick().await;
loop {
interval.tick().await;
spawn_updates_worker(updates_tx_periodic.clone());
}
});
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/app/runtime/workers/news_content.rs | src/app/runtime/workers/news_content.rs | //! Background worker for fetching news article content.
use std::time::Instant;
use tokio::sync::mpsc;
use crate::sources;
/// What: Spawn background worker for news article content fetching.
///
/// Inputs:
/// - `news_content_req_rx`: Channel receiver for content requests (URL as String)
/// - `news_content_res_tx`: Channel sender for content responses (URL, content)
///
/// Output:
/// - None (spawns async task)
///
/// Details:
/// - Listens for URL requests on the channel
/// - Drains stale requests and only processes the most recent one
/// - This prevents queue buildup when users scroll quickly through items
/// - Fetches article content asynchronously using `fetch_news_content`
/// - Sends results as `(String, String)` with URL and content
/// - On error, sends error message as content string
pub fn spawn_news_content_worker(
mut news_content_req_rx: mpsc::UnboundedReceiver<String>,
news_content_res_tx: mpsc::UnboundedSender<(String, String)>,
) {
tokio::spawn(async move {
while let Some(mut url) = news_content_req_rx.recv().await {
// Drain any pending requests and use the most recent one
// This prevents queue buildup when users scroll quickly or when
// slow requests (e.g., unreachable hosts) block the queue
let mut skipped = 0usize;
while let Ok(newer_url) = news_content_req_rx.try_recv() {
skipped += 1;
url = newer_url;
}
if skipped > 0 {
tracing::debug!(
skipped,
url = %url,
"news_content_worker: drained stale requests, processing most recent"
);
}
let url_clone = url.clone();
let started = Instant::now();
tracing::info!(url = %url_clone, "news_content_worker: fetch start");
match sources::fetch_news_content(&url).await {
Ok(content) => {
tracing::debug!(
url = %url_clone,
elapsed_ms = started.elapsed().as_millis(),
len = content.len(),
"news_content_worker: fetch success"
);
let _ = news_content_res_tx.send((url_clone, content));
}
Err(e) => {
tracing::warn!(
error = %e,
url = %url_clone,
elapsed_ms = started.elapsed().as_millis(),
"news_content_worker: fetch failed"
);
let _ = news_content_res_tx
.send((url_clone, format!("Failed to load content: {e}")));
}
}
}
});
}
#[cfg(test)]
mod tests {
#[test]
/// What: Test error message format for failed content fetches.
///
/// Inputs:
/// - Error string from `fetch_news_content`.
///
/// Output:
/// - Error message formatted as "Failed to load content: {error}".
///
/// Details:
/// - Verifies error message format matches worker behavior.
fn test_news_content_worker_error_format() {
let error = "Network error";
let error_msg = format!("Failed to load content: {error}");
assert!(error_msg.contains("Failed to load content"));
assert!(error_msg.contains(error));
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/app/runtime/handlers/services.rs | src/app/runtime/handlers/services.rs | use tokio::sync::mpsc;
use crate::app::runtime::handlers::common::{HandlerConfig, handle_result};
use crate::state::AppState;
/// What: Handler configuration for service results.
struct ServiceHandlerConfig;
impl HandlerConfig for ServiceHandlerConfig {
type Result = crate::state::modal::ServiceImpact;
fn get_resolving(&self, app: &AppState) -> bool {
app.services_resolving
}
fn set_resolving(&self, app: &mut AppState, value: bool) {
app.services_resolving = value;
}
fn get_preflight_resolving(&self, app: &AppState) -> bool {
app.preflight_services_resolving
}
fn set_preflight_resolving(&self, app: &mut AppState, value: bool) {
app.preflight_services_resolving = value;
}
fn stage_name(&self) -> &'static str {
"services"
}
fn update_cache(&self, app: &mut AppState, results: &[Self::Result]) {
app.install_list_services = results.to_vec();
}
fn set_cache_dirty(&self, app: &mut AppState) {
app.services_cache_dirty = true;
tracing::debug!(
"[Runtime] handle_service_result: Marked services_cache_dirty=true, install_list_services has {} entries",
app.install_list_services.len()
);
}
fn clear_preflight_items(&self, app: &mut AppState) {
app.preflight_services_items = None;
}
fn sync_to_modal(&self, app: &mut AppState, _results: &[Self::Result], was_preflight: bool) {
// Sync services to preflight modal if it's open
if was_preflight
&& let crate::state::Modal::Preflight {
service_info,
services_loaded,
..
} = &mut app.modal
{
service_info.clone_from(&app.install_list_services);
*services_loaded = true;
tracing::debug!(
"[Runtime] Synced {} services to preflight modal",
service_info.len()
);
}
}
fn log_flag_clear(&self, app: &AppState, was_preflight: bool, cancelled: bool) {
tracing::debug!(
"[Runtime] handle_service_result: Clearing flags - was_preflight={}, services_resolving={}, preflight_services_resolving={}, cancelled={}",
was_preflight,
self.get_resolving(app),
app.preflight_services_resolving,
cancelled
);
}
}
/// What: Handle service resolution result event.
///
/// Inputs:
/// - `app`: Application state
/// - `services`: Service resolution results
/// - `tick_tx`: Channel sender for tick events
///
/// Details:
/// - Updates cached services
/// - Syncs services to preflight modal if open
/// - Respects cancellation flag
pub fn handle_service_result(
app: &mut AppState,
services: &[crate::state::modal::ServiceImpact],
tick_tx: &mpsc::UnboundedSender<()>,
) {
handle_result(app, services, tick_tx, &ServiceHandlerConfig);
}
#[cfg(test)]
mod tests {
use super::*;
/// What: Provide a baseline `AppState` for handler tests.
///
/// Inputs: None
/// Output: Fresh `AppState` with default values
fn new_app() -> AppState {
AppState::default()
}
#[test]
/// What: Verify that `handle_service_result` updates cache correctly.
///
/// Inputs:
/// - App state
/// - Service resolution results
///
/// Output:
/// - Services are cached
/// - Flags are reset
///
/// Details:
/// - Tests that service results are properly processed
fn handle_service_result_updates_cache() {
let mut app = new_app();
app.services_resolving = true;
app.preflight_services_resolving = true;
let (tick_tx, _tick_rx) = mpsc::unbounded_channel();
let services = vec![crate::state::modal::ServiceImpact {
unit_name: "test.service".to_string(),
providers: vec!["test-package".to_string()],
is_active: false,
needs_restart: false,
recommended_decision: crate::state::modal::ServiceRestartDecision::Defer,
restart_decision: crate::state::modal::ServiceRestartDecision::Defer,
}];
handle_service_result(&mut app, &services, &tick_tx);
// Services should be cached
assert_eq!(app.install_list_services.len(), 1);
// Flags should be reset
assert!(!app.services_resolving);
assert!(!app.preflight_services_resolving);
// Cache dirty flag should be set
assert!(app.services_cache_dirty);
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/app/runtime/handlers/sandbox.rs | src/app/runtime/handlers/sandbox.rs | use tokio::sync::mpsc;
use crate::state::AppState;
/// What: Log detailed dependency information for `SandboxInfo` entries.
///
/// Inputs:
/// - `sandbox_info`: `SandboxInfo` resolution results to log
///
/// Output: None (side effect: logging)
///
/// Details:
/// - Logs summary and per-package dependency counts
fn log_sandbox_info_details(sandbox_info: &[crate::logic::sandbox::SandboxInfo]) {
if sandbox_info.is_empty() {
tracing::warn!("[Runtime] handle_sandbox_result: Received empty sandbox info");
return;
}
tracing::info!(
"[Runtime] handle_sandbox_result: Received {} sandbox info entries",
sandbox_info.len()
);
for info in sandbox_info {
let total_deps = info.depends.len()
+ info.makedepends.len()
+ info.checkdepends.len()
+ info.optdepends.len();
let installed_deps = info.depends.iter().filter(|d| d.is_installed).count()
+ info.makedepends.iter().filter(|d| d.is_installed).count()
+ info.checkdepends.iter().filter(|d| d.is_installed).count()
+ info.optdepends.iter().filter(|d| d.is_installed).count();
tracing::info!(
"[Runtime] handle_sandbox_result: Package '{}' - total_deps={}, installed_deps={}, depends={}, makedepends={}, checkdepends={}, optdepends={}",
info.package_name,
total_deps,
installed_deps,
info.depends.len(),
info.makedepends.len(),
info.checkdepends.len(),
info.optdepends.len()
);
}
}
/// What: Check if `SandboxInfo` is empty (all dependency vectors are empty).
///
/// Inputs:
/// - `info`: `SandboxInfo` to check
///
/// Output: `true` if all dependency vectors are empty, `false` otherwise
const fn is_empty_sandbox(info: &crate::logic::sandbox::SandboxInfo) -> bool {
info.depends.is_empty()
&& info.makedepends.is_empty()
&& info.checkdepends.is_empty()
&& info.optdepends.is_empty()
}
/// What: Merge new `SandboxInfo` into existing cache, preserving valid entries.
///
/// Inputs:
/// - `current_cache`: Current cached `SandboxInfo`
/// - `new_info`: New sandbox resolution results
///
/// Output: Updated sandbox cache with merged entries
///
/// Details:
/// - Preserves entries for packages not in the new result
/// - Preserves existing valid entries if new entry is empty
/// - Replaces entries when new data is available
fn merge_sandbox_cache(
current_cache: &[crate::logic::sandbox::SandboxInfo],
new_info: &[crate::logic::sandbox::SandboxInfo],
) -> Vec<crate::logic::sandbox::SandboxInfo> {
let mut updated_sandbox = current_cache.to_vec();
let new_package_names: std::collections::HashSet<String> =
new_info.iter().map(|s| s.package_name.clone()).collect();
// Extract existing valid entries for packages that will be updated
let mut existing_valid: std::collections::HashMap<String, crate::logic::sandbox::SandboxInfo> =
updated_sandbox
.iter()
.filter(|s| new_package_names.contains(&s.package_name))
.filter(|s| !is_empty_sandbox(s))
.map(|s| (s.package_name.clone(), s.clone()))
.collect();
// Remove old entries for packages that are in the new result
updated_sandbox.retain(|s| !new_package_names.contains(&s.package_name));
// Add new entries, preserving existing valid data if new entry is empty
for new_entry in new_info {
if is_empty_sandbox(new_entry) {
if let Some(existing) = existing_valid.remove(&new_entry.package_name) {
tracing::debug!(
"[Runtime] handle_sandbox_result: Preserving existing valid sandbox info for '{}' (new entry is empty)",
new_entry.package_name
);
updated_sandbox.push(existing);
} else {
updated_sandbox.push(new_entry.clone());
}
} else {
updated_sandbox.push(new_entry.clone());
}
}
updated_sandbox
}
/// What: Sync `SandboxInfo` to preflight modal if open.
///
/// Inputs:
/// - `modal`: Preflight modal state
/// - `sandbox_info`: `SandboxInfo` resolution results
///
/// Output: None (side effect: updates modal state)
///
/// Details:
/// - Filters `SandboxInfo` to match modal items
/// - Handles empty results and mismatches gracefully
/// - Sets appropriate error messages when needed
fn sync_sandbox_to_modal(
modal: &mut crate::state::Modal,
sandbox_info: &[crate::logic::sandbox::SandboxInfo],
) {
let crate::state::Modal::Preflight {
items,
sandbox_info: modal_sandbox,
sandbox_loaded,
sandbox_error,
..
} = modal
else {
tracing::debug!("[Runtime] handle_sandbox_result: Preflight modal not open, skipping sync");
return;
};
let item_names: std::collections::HashSet<String> =
items.iter().map(|i| i.name.clone()).collect();
let aur_items: Vec<_> = items
.iter()
.filter(|p| matches!(p.source, crate::state::Source::Aur))
.collect();
let filtered_sandbox: Vec<_> = sandbox_info
.iter()
.filter(|sb| item_names.contains(&sb.package_name))
.cloned()
.collect();
tracing::info!(
"[Runtime] handle_sandbox_result: Modal open - items={}, aur_items={}, filtered_sandbox={}, modal_current={}",
items.len(),
aur_items.len(),
filtered_sandbox.len(),
modal_sandbox.len()
);
if !filtered_sandbox.is_empty() {
sync_matching_sandbox(
modal_sandbox,
sandbox_loaded,
sandbox_error,
filtered_sandbox,
);
return;
}
sync_empty_or_mismatched_sandbox(
sandbox_info,
&item_names,
aur_items.as_slice(),
modal_sandbox,
sandbox_loaded,
sandbox_error,
);
}
/// What: Sync matching `SandboxInfo` to modal.
///
/// Inputs:
/// - `modal_sandbox`: Modal `SandboxInfo` field to update
/// - `sandbox_loaded`: Modal loaded flag to update
/// - `sandbox_error`: Modal error field to update
/// - `filtered_sandbox`: Matching `SandboxInfo` to sync
///
/// Output: None (side effect: updates modal fields)
fn sync_matching_sandbox(
modal_sandbox: &mut Vec<crate::logic::sandbox::SandboxInfo>,
sandbox_loaded: &mut bool,
sandbox_error: &mut Option<String>,
filtered_sandbox: Vec<crate::logic::sandbox::SandboxInfo>,
) {
tracing::info!(
"[Runtime] handle_sandbox_result: Syncing {} sandbox infos to preflight modal",
filtered_sandbox.len()
);
*modal_sandbox = filtered_sandbox;
*sandbox_loaded = true;
*sandbox_error = None;
tracing::debug!(
"[Runtime] handle_sandbox_result: Successfully synced sandbox info to modal, loaded={}",
*sandbox_loaded
);
}
/// What: Handle empty or mismatched `SandboxInfo` for modal sync.
///
/// Inputs:
/// - `sandbox_info`: All sandbox resolution results
/// - `item_names`: Names of items in the modal
/// - `aur_items`: AUR items in the modal
/// - `modal_sandbox`: Modal `SandboxInfo` field to update
/// - `sandbox_loaded`: Modal loaded flag to update
/// - `sandbox_error`: Modal error field to update
///
/// Output: None (side effect: updates modal fields)
///
/// Details:
/// - Handles cases where `SandboxInfo` doesn't match modal items
/// - Sets appropriate error messages for empty results
fn sync_empty_or_mismatched_sandbox(
sandbox_info: &[crate::logic::sandbox::SandboxInfo],
item_names: &std::collections::HashSet<String>,
aur_items: &[&crate::state::PackageItem],
modal_sandbox: &mut Vec<crate::logic::sandbox::SandboxInfo>,
sandbox_loaded: &mut bool,
sandbox_error: &mut Option<String>,
) {
if aur_items.is_empty() {
*sandbox_loaded = true;
*sandbox_error = None;
return;
}
if sandbox_info.is_empty() {
handle_empty_sandbox_result(aur_items, sandbox_loaded, sandbox_error);
} else {
handle_partial_match(
sandbox_info,
item_names,
modal_sandbox,
sandbox_loaded,
sandbox_error,
);
}
}
/// What: Handle partial match between `SandboxInfo` and modal items.
///
/// Inputs:
/// - `sandbox_info`: All sandbox resolution results
/// - `item_names`: Names of items in the modal
/// - `modal_sandbox`: Modal `SandboxInfo` field to update
/// - `sandbox_loaded`: Modal loaded flag to update
/// - `sandbox_error`: Modal error field to update
///
/// Output: None (side effect: updates modal fields)
fn handle_partial_match(
sandbox_info: &[crate::logic::sandbox::SandboxInfo],
item_names: &std::collections::HashSet<String>,
modal_sandbox: &mut Vec<crate::logic::sandbox::SandboxInfo>,
sandbox_loaded: &mut bool,
sandbox_error: &mut Option<String>,
) {
let partial_match: Vec<_> = sandbox_info
.iter()
.filter(|sb| item_names.contains(&sb.package_name))
.cloned()
.collect();
if partial_match.is_empty() {
tracing::warn!(
"[Runtime] Sandbox info exists but doesn't match modal items. Modal items: {:?}, Sandbox packages: {:?}",
item_names,
sandbox_info
.iter()
.map(|s| &s.package_name)
.collect::<Vec<_>>()
);
} else {
tracing::debug!(
"[Runtime] Partial sandbox sync: {} of {} packages matched",
partial_match.len(),
item_names.len()
);
*modal_sandbox = partial_match;
}
*sandbox_loaded = true;
*sandbox_error = None;
}
/// What: Handle empty sandbox result when AUR packages are expected.
///
/// Inputs:
/// - `aur_items`: AUR items in the modal
/// - `sandbox_loaded`: Modal loaded flag to update
/// - `sandbox_error`: Modal error field to update
///
/// Output: None (side effect: updates modal fields)
fn handle_empty_sandbox_result(
aur_items: &[&crate::state::PackageItem],
sandbox_loaded: &mut bool,
sandbox_error: &mut Option<String>,
) {
tracing::warn!(
"[Runtime] handle_sandbox_result: Sandbox resolution returned empty results for {} AUR packages (AUR may be down or network issues). Modal items: {:?}",
aur_items.len(),
aur_items.iter().map(|i| &i.name).collect::<Vec<_>>()
);
*sandbox_loaded = true;
*sandbox_error = Some(format!(
"Failed to fetch sandbox information for {} AUR package(s). AUR may be temporarily unavailable.",
aur_items.len()
));
}
use crate::app::runtime::handlers::common::{HandlerConfig, handle_result};
/// What: Handler configuration for sandbox results.
struct SandboxHandlerConfig;
impl HandlerConfig for SandboxHandlerConfig {
type Result = crate::logic::sandbox::SandboxInfo;
fn get_resolving(&self, app: &AppState) -> bool {
app.sandbox_resolving
}
fn set_resolving(&self, app: &mut AppState, value: bool) {
app.sandbox_resolving = value;
}
fn get_preflight_resolving(&self, app: &AppState) -> bool {
app.preflight_sandbox_resolving
}
fn set_preflight_resolving(&self, app: &mut AppState, value: bool) {
app.preflight_sandbox_resolving = value;
}
fn stage_name(&self) -> &'static str {
"sandbox"
}
fn update_cache(&self, app: &mut AppState, results: &[Self::Result]) {
log_sandbox_info_details(results);
tracing::debug!(
"[Runtime] handle_sandbox_result: Updating install_list_sandbox with {} entries (current cache has {})",
results.len(),
app.install_list_sandbox.len()
);
app.install_list_sandbox = merge_sandbox_cache(&app.install_list_sandbox, results);
tracing::debug!(
"[Runtime] handle_sandbox_result: install_list_sandbox now has {} entries: {:?}",
app.install_list_sandbox.len(),
app.install_list_sandbox
.iter()
.map(|s| &s.package_name)
.collect::<Vec<_>>()
);
}
fn set_cache_dirty(&self, app: &mut AppState) {
app.sandbox_cache_dirty = true;
tracing::debug!(
"[Runtime] handle_sandbox_result: Marked sandbox_cache_dirty=true, install_list_sandbox has {} entries: {:?}",
app.install_list_sandbox.len(),
app.install_list_sandbox
.iter()
.map(|s| &s.package_name)
.collect::<Vec<_>>()
);
}
fn clear_preflight_items(&self, app: &mut AppState) {
app.preflight_sandbox_items = None;
}
fn sync_to_modal(&self, app: &mut AppState, results: &[Self::Result], _was_preflight: bool) {
sync_sandbox_to_modal(&mut app.modal, results);
}
fn log_flag_clear(&self, app: &AppState, was_preflight: bool, cancelled: bool) {
tracing::debug!(
"[Runtime] handle_sandbox_result: Clearing flags - was_preflight={}, sandbox_resolving={}, preflight_sandbox_resolving={}, cancelled={}",
was_preflight,
self.get_resolving(app),
app.preflight_sandbox_resolving,
cancelled
);
}
fn is_resolution_complete(&self, app: &AppState, results: &[Self::Result]) -> bool {
// Check if preflight modal is open
if let crate::state::Modal::Preflight { items, .. } = &app.modal {
// Only AUR packages need sandbox data
let aur_items: std::collections::HashSet<String> = items
.iter()
.filter(|p| matches!(p.source, crate::state::Source::Aur))
.map(|i| i.name.clone())
.collect();
if aur_items.is_empty() {
// No AUR packages, resolution is complete
return true;
}
let result_names: std::collections::HashSet<String> =
results.iter().map(|s| s.package_name.clone()).collect();
let cache_names: std::collections::HashSet<String> = app
.install_list_sandbox
.iter()
.map(|s| s.package_name.clone())
.collect();
let all_have_data = aur_items
.iter()
.all(|name| result_names.contains(name) || cache_names.contains(name));
if !all_have_data {
let missing: Vec<String> = aur_items
.iter()
.filter(|name| !result_names.contains(*name) && !cache_names.contains(*name))
.cloned()
.collect();
tracing::debug!(
"[Runtime] handle_sandbox_result: Resolution incomplete - missing sandbox for: {:?}",
missing
);
}
return all_have_data;
}
// If no preflight modal, check preflight_sandbox_items
if let Some(ref install_items) = app.preflight_sandbox_items {
// Only AUR packages need sandbox data
let aur_items: std::collections::HashSet<String> = install_items
.iter()
.filter(|p| matches!(p.source, crate::state::Source::Aur))
.map(|i| i.name.clone())
.collect();
if aur_items.is_empty() {
// No AUR packages, resolution is complete
return true;
}
let result_names: std::collections::HashSet<String> =
results.iter().map(|s| s.package_name.clone()).collect();
let cache_names: std::collections::HashSet<String> = app
.install_list_sandbox
.iter()
.map(|s| s.package_name.clone())
.collect();
let all_have_data = aur_items
.iter()
.all(|name| result_names.contains(name) || cache_names.contains(name));
if !all_have_data {
let missing: Vec<String> = aur_items
.iter()
.filter(|name| !result_names.contains(*name) && !cache_names.contains(*name))
.cloned()
.collect();
tracing::debug!(
"[Runtime] handle_sandbox_result: Resolution incomplete - missing sandbox for: {:?}",
missing
);
}
return all_have_data;
}
// No items to check, resolution is complete
true
}
}
/// What: Handle sandbox resolution result event.
///
/// Inputs:
/// - `app`: Application state
/// - `sandbox_info`: `SandboxInfo` resolution results
/// - `tick_tx`: Channel sender for tick events
///
/// Details:
/// - Updates cached `SandboxInfo`
/// - Syncs `SandboxInfo` to preflight modal if open
/// - Handles empty results and errors gracefully
/// - Respects cancellation flag
pub fn handle_sandbox_result(
app: &mut AppState,
sandbox_info: &[crate::logic::sandbox::SandboxInfo],
tick_tx: &mpsc::UnboundedSender<()>,
) {
handle_result(app, sandbox_info, tick_tx, &SandboxHandlerConfig);
}
#[cfg(test)]
mod tests {
use super::*;
/// What: Provide a baseline `AppState` for handler tests.
///
/// Inputs: None
/// Output: Fresh `AppState` with default values
fn new_app() -> AppState {
AppState::default()
}
#[test]
/// What: Verify that `handle_sandbox_result` updates cache correctly.
///
/// Inputs:
/// - App state
/// - Sandbox resolution results
///
/// Output:
/// - `SandboxInfo` is cached
/// - Flags are reset
///
/// Details:
/// - Tests that sandbox results are properly processed
fn handle_sandbox_result_updates_cache() {
let mut app = new_app();
app.sandbox_resolving = true;
let (tick_tx, _tick_rx) = mpsc::unbounded_channel();
let sandbox_info = vec![crate::logic::sandbox::SandboxInfo {
package_name: "test-package".to_string(),
depends: vec![],
makedepends: vec![],
checkdepends: vec![],
optdepends: vec![],
}];
handle_sandbox_result(&mut app, &sandbox_info, &tick_tx);
// `SandboxInfo` should be cached
assert_eq!(app.install_list_sandbox.len(), 1);
// Flags should be reset
assert!(!app.sandbox_resolving);
assert!(!app.preflight_sandbox_resolving);
// Cache dirty flag should be set
assert!(app.sandbox_cache_dirty);
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/app/runtime/handlers/search.rs | src/app/runtime/handlers/search.rs | use tokio::sync::mpsc;
use crate::state::{AppState, PackageDetails, PackageItem, SearchResults, Source};
/// What: Handle search results update event.
///
/// Inputs:
/// - `app`: Application state
/// - `new_results`: New search results
/// - `details_req_tx`: Channel sender for detail requests
/// - `index_notify_tx`: Channel sender for index update notifications
///
/// Details:
/// - Filters results based on installed-only mode if enabled
/// - Updates selection to preserve previously selected item
/// - Triggers detail fetch and ring prefetch for selected item
/// - Requests index enrichment for official packages near selection
pub fn handle_search_results(
app: &mut AppState,
new_results: SearchResults,
details_req_tx: &mpsc::UnboundedSender<PackageItem>,
index_notify_tx: &mpsc::UnboundedSender<()>,
) {
if new_results.id != app.latest_query_id {
return;
}
// Check cache before processing
let query_text = app.input.trim().to_string();
let cache_hit = if let Some(cached_query) = &app.search_cache_query {
cached_query == &query_text
&& app.search_cache_fuzzy == app.fuzzy_search_enabled
&& app.search_cache_results.is_some()
} else {
false
};
// If cache hit, use cached results and skip processing new_results
if cache_hit && let Some(cached_results) = &app.search_cache_results {
let prev_selected_name = app.results.get(app.selected).map(|p| p.name.clone());
app.all_results = cached_results.clone();
crate::logic::apply_filters_and_sort_preserve_selection(app);
let new_sel = prev_selected_name
.and_then(|name| app.results.iter().position(|p| p.name == name))
.unwrap_or(0);
app.selected = new_sel.min(app.results.len().saturating_sub(1));
app.list_state.select(if app.results.is_empty() {
None
} else {
Some(app.selected)
});
if let Some(item) = app.results.get(app.selected).cloned() {
app.details_focus = Some(item.name.clone());
if let Some(cached) = app.details_cache.get(&item.name).cloned() {
app.details = cached;
} else {
let _ = details_req_tx.send(item);
}
}
crate::logic::set_allowed_ring(app, 30);
if !app.need_ring_prefetch {
crate::logic::ring_prefetch_from_selected(app, details_req_tx);
}
return; // Early return on cache hit
}
let prev_selected_name = app.results.get(app.selected).map(|p| p.name.clone());
// Respect installed-only mode: keep results restricted to explicit installs
let mut incoming = new_results.items;
if app.installed_only_mode {
use std::collections::HashSet;
let explicit = crate::index::explicit_names();
if app.input.trim().is_empty() {
// For empty query, reconstruct full installed list (official + AUR fallbacks)
let mut items: Vec<PackageItem> = crate::index::all_official()
.into_iter()
.filter(|p| explicit.contains(&p.name))
.collect();
let official_names: HashSet<String> = items.iter().map(|p| p.name.clone()).collect();
for name in explicit {
if !official_names.contains(&name) {
let is_eos = name.to_lowercase().contains("eos-");
let src = if is_eos {
Source::Official {
repo: "EOS".to_string(),
arch: String::new(),
}
} else {
Source::Aur
};
items.push(PackageItem {
name: name.clone(),
version: String::new(),
description: String::new(),
source: src,
popularity: None,
out_of_date: None,
orphaned: false,
});
}
}
incoming = items;
} else {
// For non-empty query, just intersect results with explicit installed set
incoming.retain(|p| explicit.contains(&p.name));
}
}
app.all_results = incoming;
crate::logic::apply_filters_and_sort_preserve_selection(app);
let new_sel = prev_selected_name
.and_then(|name| app.results.iter().position(|p| p.name == name))
.unwrap_or(0);
app.selected = new_sel.min(app.results.len().saturating_sub(1));
app.list_state.select(if app.results.is_empty() {
None
} else {
Some(app.selected)
});
if let Some(item) = app.results.get(app.selected).cloned() {
app.details_focus = Some(item.name.clone());
if let Some(cached) = app.details_cache.get(&item.name).cloned() {
app.details = cached;
} else {
let _ = details_req_tx.send(item);
}
}
crate::logic::set_allowed_ring(app, 30);
if app.need_ring_prefetch {
/* defer */
} else {
crate::logic::ring_prefetch_from_selected(app, details_req_tx);
}
let len_u = app.results.len();
let mut enrich_names: Vec<String> = Vec::new();
if let Some(sel) = app.results.get(app.selected)
&& matches!(sel.source, Source::Official { .. })
{
enrich_names.push(sel.name.clone());
}
let max_radius: usize = 30;
let mut step: usize = 1;
while step <= max_radius {
if let Some(i) = app.selected.checked_sub(step)
&& let Some(it) = app.results.get(i)
&& matches!(it.source, Source::Official { .. })
{
enrich_names.push(it.name.clone());
}
let below = app.selected + step;
if below < len_u
&& let Some(it) = app.results.get(below)
&& matches!(it.source, Source::Official { .. })
{
enrich_names.push(it.name.clone());
}
step += 1;
}
if !enrich_names.is_empty() {
crate::index::request_enrich_for(
app.official_index_path.clone(),
index_notify_tx.clone(),
enrich_names,
);
}
// Update search cache with current query and results
app.search_cache_query = Some(query_text);
app.search_cache_fuzzy = app.fuzzy_search_enabled;
app.search_cache_results = Some(app.results.clone());
}
/// What: Handle package details update event.
///
/// Inputs:
/// - `app`: Application state
/// - `details`: New package details
/// - `tick_tx`: Channel sender for tick events
///
/// Details:
/// - Updates details cache and current details if focused
/// - Updates result list entry with new information
pub fn handle_details_update(
app: &mut AppState,
details: &PackageDetails,
tick_tx: &mpsc::UnboundedSender<()>,
) {
let details_clone = details.clone();
if app.details_focus.as_deref() == Some(details.name.as_str()) {
app.details = details_clone.clone();
}
app.details_cache
.insert(details_clone.name.clone(), details_clone.clone());
app.cache_dirty = true;
if let Some(pos) = app.results.iter().position(|p| p.name == details.name) {
app.results[pos].description = details_clone.description;
if !details_clone.version.is_empty() && app.results[pos].version != details_clone.version {
app.results[pos].version = details_clone.version;
}
if details_clone.popularity.is_some() {
app.results[pos].popularity = details_clone.popularity;
}
if let crate::state::Source::Official { repo, arch } = &mut app.results[pos].source {
if repo.is_empty() && !details_clone.repository.is_empty() {
*repo = details_clone.repository;
}
if arch.is_empty() && !details_clone.architecture.is_empty() {
*arch = details_clone.architecture;
}
}
}
let _ = tick_tx.send(());
}
/// What: Handle preview item event.
///
/// Inputs:
/// - `app`: Application state
/// - `item`: Package item to preview
/// - `details_req_tx`: Channel sender for detail requests
///
/// Details:
/// - Loads details for previewed item (from cache or network)
/// - Adjusts selection if needed
pub fn handle_preview(
app: &mut AppState,
item: PackageItem,
details_req_tx: &mpsc::UnboundedSender<PackageItem>,
) {
if let Some(cached) = app.details_cache.get(&item.name).cloned() {
app.details = cached;
} else {
let _ = details_req_tx.send(item);
}
if !app.results.is_empty() && app.selected >= app.results.len() {
app.selected = app.results.len() - 1;
app.list_state.select(Some(app.selected));
}
}
#[cfg(test)]
mod tests {
use super::*;
/// What: Provide a baseline `AppState` for handler tests.
///
/// Inputs: None
/// Output: Fresh `AppState` with default values
fn new_app() -> AppState {
AppState::default()
}
#[test]
/// What: Verify that `handle_search_results` ignores results with mismatched query ID.
///
/// Inputs:
/// - `AppState` with `latest_query_id` = 1
/// - `SearchResults` with `id` = 2
///
/// Output:
/// - Results are ignored, app state unchanged
///
/// Details:
/// - Tests that stale results are properly filtered
fn handle_search_results_ignores_stale_results() {
let mut app = new_app();
app.latest_query_id = 1;
app.results = vec![PackageItem {
name: "old-package".to_string(),
version: "1.0.0".to_string(),
description: "Old".to_string(),
source: Source::Aur,
popularity: None,
out_of_date: None,
orphaned: false,
}];
let (details_tx, _details_rx) = mpsc::unbounded_channel();
let (index_tx, _index_rx) = mpsc::unbounded_channel();
let stale_results = SearchResults {
id: 2, // Different from app.latest_query_id
items: vec![PackageItem {
name: "new-package".to_string(),
version: "2.0.0".to_string(),
description: "New".to_string(),
source: Source::Aur,
popularity: None,
out_of_date: None,
orphaned: false,
}],
};
handle_search_results(&mut app, stale_results, &details_tx, &index_tx);
// Results should not be updated
assert_eq!(app.results.len(), 1);
assert_eq!(app.results[0].name, "old-package");
}
#[test]
/// What: Verify that `handle_search_results` updates results when query ID matches.
///
/// Inputs:
/// - `AppState` with `latest_query_id` = 1
/// - `SearchResults` with `id` = 1 and new items
///
/// Output:
/// - Results are updated with new items
/// - Selection is preserved or adjusted
///
/// Details:
/// - Tests that valid results are properly processed
fn handle_search_results_updates_when_id_matches() {
let mut app = new_app();
app.latest_query_id = 1;
app.input = "hello".to_string();
app.results = vec![PackageItem {
name: "old-package".to_string(),
version: "1.0.0".to_string(),
description: "Old".to_string(),
source: Source::Aur,
popularity: None,
out_of_date: None,
orphaned: false,
}];
let (details_tx, _details_rx) = mpsc::unbounded_channel();
let (index_tx, _index_rx) = mpsc::unbounded_channel();
let new_results = SearchResults {
id: 1, // Matches app.latest_query_id
items: vec![PackageItem {
name: "new-package".to_string(),
version: "2.0.0".to_string(),
description: "New".to_string(),
source: Source::Aur,
popularity: None,
out_of_date: None,
orphaned: false,
}],
};
handle_search_results(&mut app, new_results, &details_tx, &index_tx);
// Results should be updated
assert_eq!(app.results.len(), 1);
assert_eq!(app.results[0].name, "new-package");
// Cache should be updated
assert_eq!(app.search_cache_query.as_deref(), Some("hello"));
assert_eq!(app.search_cache_results.as_ref().map(Vec::len), Some(1));
}
#[test]
/// What: Verify that `handle_details_update` updates cache and current details.
///
/// Inputs:
/// - `AppState` with `details_focus` set
/// - `PackageDetails` for focused package
///
/// Output:
/// - Details cache is updated
/// - Current details are updated if focused
///
/// Details:
/// - Tests that details are properly cached and displayed
fn handle_details_update_updates_cache_and_details() {
let mut app = new_app();
app.details_focus = Some("test-package".to_string());
app.details_cache = std::collections::HashMap::new();
let (tick_tx, _tick_rx) = mpsc::unbounded_channel();
let details = PackageDetails {
name: "test-package".to_string(),
version: "1.0.0".to_string(),
description: "Test package".to_string(),
repository: String::new(),
architecture: String::new(),
url: String::new(),
licenses: Vec::new(),
groups: Vec::new(),
provides: Vec::new(),
depends: Vec::new(),
opt_depends: Vec::new(),
required_by: Vec::new(),
optional_for: Vec::new(),
conflicts: Vec::new(),
replaces: Vec::new(),
download_size: None,
install_size: None,
owner: String::new(),
build_date: String::new(),
popularity: None,
out_of_date: None,
orphaned: false,
};
handle_details_update(&mut app, &details, &tick_tx);
// Cache should be updated
assert!(app.details_cache.contains_key("test-package"));
// Current details should be updated if focused
assert_eq!(app.details.name, "test-package");
// Cache dirty flag should be set
assert!(app.cache_dirty);
}
#[test]
/// What: Verify that `handle_preview` loads details from cache when available.
///
/// Inputs:
/// - `AppState` with cached details
/// - `PackageItem` to preview
///
/// Output:
/// - Details are loaded from cache
/// - No network request is made
///
/// Details:
/// - Tests that cached details are used when available
fn handle_preview_uses_cache_when_available() {
let mut app = new_app();
let cached_details = PackageDetails {
name: "test-package".to_string(),
version: "1.0.0".to_string(),
description: "Cached".to_string(),
repository: String::new(),
architecture: String::new(),
url: String::new(),
licenses: Vec::new(),
groups: Vec::new(),
provides: Vec::new(),
depends: Vec::new(),
opt_depends: Vec::new(),
required_by: Vec::new(),
optional_for: Vec::new(),
conflicts: Vec::new(),
replaces: Vec::new(),
download_size: None,
install_size: None,
owner: String::new(),
build_date: String::new(),
popularity: None,
out_of_date: None,
orphaned: false,
};
app.details_cache
.insert("test-package".to_string(), cached_details);
let (details_tx, mut details_rx) = mpsc::unbounded_channel();
let item = PackageItem {
name: "test-package".to_string(),
version: "1.0.0".to_string(),
description: "Test".to_string(),
source: Source::Aur,
popularity: None,
out_of_date: None,
orphaned: false,
};
handle_preview(&mut app, item, &details_tx);
// Details should be loaded from cache
assert_eq!(app.details.name, "test-package");
// No request should be sent (channel should be empty)
assert!(details_rx.try_recv().is_err());
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/app/runtime/handlers/install.rs | src/app/runtime/handlers/install.rs | use tokio::sync::mpsc;
use crate::app::runtime::handlers::common::{HandlerConfig, handle_result};
use crate::logic::add_to_install_list;
use crate::state::{AppState, PackageItem};
/// What: Handle add to install list event (single item).
///
/// Inputs:
/// - `app`: Application state
/// - `item`: Package item to add
/// - `deps_req_tx`: Channel sender for dependency resolution requests (with action)
/// - `files_req_tx`: Channel sender for file resolution requests (with action)
/// - `services_req_tx`: Channel sender for service resolution requests
/// - `sandbox_req_tx`: Channel sender for sandbox resolution requests
///
/// Details:
/// - Adds item to install list
/// - Triggers background resolution for dependencies, files, services, and sandbox
pub fn handle_add_to_install_list(
app: &mut AppState,
item: PackageItem,
deps_req_tx: &mpsc::UnboundedSender<(Vec<PackageItem>, crate::state::modal::PreflightAction)>,
files_req_tx: &mpsc::UnboundedSender<(Vec<PackageItem>, crate::state::modal::PreflightAction)>,
services_req_tx: &mpsc::UnboundedSender<(
Vec<PackageItem>,
crate::state::modal::PreflightAction,
)>,
sandbox_req_tx: &mpsc::UnboundedSender<Vec<PackageItem>>,
) {
add_to_install_list(app, item);
// Trigger background dependency resolution for updated install list (Install action)
if !app.install_list.is_empty() {
app.deps_resolving = true;
let _ = deps_req_tx.send((
app.install_list.clone(),
crate::state::modal::PreflightAction::Install,
));
// Trigger background file resolution for updated install list (Install action)
app.files_resolving = true;
let _ = files_req_tx.send((
app.install_list.clone(),
crate::state::modal::PreflightAction::Install,
));
// Trigger background service resolution for updated install list
app.services_resolving = true;
let _ = services_req_tx.send((
app.install_list.clone(),
crate::state::modal::PreflightAction::Install,
));
// Trigger background sandbox resolution for updated install list
app.sandbox_resolving = true;
let _ = sandbox_req_tx.send(app.install_list.clone());
}
}
/// What: Handler configuration for dependency results.
struct DependencyHandlerConfig;
impl HandlerConfig for DependencyHandlerConfig {
type Result = crate::state::modal::DependencyInfo;
fn get_resolving(&self, app: &AppState) -> bool {
app.deps_resolving
}
fn set_resolving(&self, app: &mut AppState, value: bool) {
app.deps_resolving = value; // CRITICAL: Always reset this flag when we receive ANY result
}
fn get_preflight_resolving(&self, app: &AppState) -> bool {
app.preflight_deps_resolving
}
fn set_preflight_resolving(&self, app: &mut AppState, value: bool) {
app.preflight_deps_resolving = value;
}
fn stage_name(&self) -> &'static str {
"dependencies"
}
fn update_cache(&self, app: &mut AppState, results: &[Self::Result]) {
app.install_list_deps = results.to_vec();
}
fn set_cache_dirty(&self, app: &mut AppState) {
app.deps_cache_dirty = true;
}
fn clear_preflight_items(&self, app: &mut AppState) {
app.preflight_deps_items = None;
}
fn sync_to_modal(&self, app: &mut AppState, results: &[Self::Result], was_preflight: bool) {
// Sync dependencies to preflight modal if it's open (whether preflight or install list resolution)
if let crate::state::Modal::Preflight {
items,
action,
dependency_info,
..
} = &mut app.modal
{
tracing::info!(
"[Runtime] sync_to_modal: action={:?}, results={}, items={}, was_preflight={}",
action,
results.len(),
items.len(),
was_preflight
);
// Filter dependencies to only those required by current modal items
let item_names: std::collections::HashSet<String> =
items.iter().map(|i| i.name.clone()).collect();
// Log first few results for debugging
for (i, dep) in results.iter().take(3).enumerate() {
tracing::info!(
"[Runtime] sync_to_modal: result[{}] name={}, required_by={:?}",
i,
dep.name,
dep.required_by
);
}
let filtered_deps: Vec<_> = results
.iter()
.filter(|dep| {
let matches = dep
.required_by
.iter()
.any(|req_by| item_names.contains(req_by));
if !matches && results.len() <= 10 {
tracing::debug!(
"[Runtime] sync_to_modal: dep {} required_by={:?} doesn't match items={:?}",
dep.name,
dep.required_by,
item_names
);
}
matches
})
.cloned()
.collect();
let old_deps_len = dependency_info.len();
tracing::info!(
"[Runtime] sync_to_modal: filtered {} deps from {} results (items={:?})",
filtered_deps.len(),
results.len(),
item_names
);
if filtered_deps.is_empty() {
tracing::info!(
"[Runtime] No matching dependencies to sync (results={}, items={:?})",
results.len(),
item_names
);
// For Remove action with no matching deps, still update to empty
// This indicates no reverse dependencies found
if matches!(action, crate::state::PreflightAction::Remove) {
tracing::info!(
"[Runtime] Remove action: setting dependency_info to empty (no reverse deps)"
);
*dependency_info = Vec::new();
}
} else {
tracing::info!(
"[Runtime] Syncing {} dependencies to preflight modal (was_preflight={}, modal had {} before)",
filtered_deps.len(),
was_preflight,
old_deps_len
);
*dependency_info = filtered_deps;
tracing::info!(
"[Runtime] Modal dependency_info now has {} entries (was {})",
dependency_info.len(),
old_deps_len
);
}
} else {
tracing::debug!("[Runtime] sync_to_modal: Modal is not Preflight, skipping sync");
}
}
fn log_flag_clear(&self, app: &AppState, was_preflight: bool, cancelled: bool) {
tracing::debug!(
"[Runtime] handle_dependency_result: Clearing flags - was_preflight={}, deps_resolving={}, preflight_deps_resolving={}, cancelled={}",
was_preflight,
self.get_resolving(app),
app.preflight_deps_resolving,
cancelled
);
}
fn is_resolution_complete(&self, app: &AppState, results: &[Self::Result]) -> bool {
// Check if preflight modal is open
if let crate::state::Modal::Preflight { items, action, .. } = &app.modal {
let item_names: std::collections::HashSet<String> =
items.iter().map(|i| i.name.clone()).collect();
if item_names.is_empty() {
return true;
}
// For Remove action: reverse dependency resolution is always complete when we get
// a result back. Having 0 results means no packages depend on the removal targets,
// which is a valid complete state.
if matches!(action, crate::state::PreflightAction::Remove) {
tracing::debug!(
"[Runtime] handle_dependency_result: Remove action - resolution complete with {} results",
results.len()
);
return true;
}
// For Install action: check if all items have been processed
// Collect all packages that appear in required_by fields
let result_packages: std::collections::HashSet<String> = results
.iter()
.flat_map(|d| d.required_by.iter().cloned())
.collect();
let cache_packages: std::collections::HashSet<String> = app
.install_list_deps
.iter()
.flat_map(|d| d.required_by.iter().cloned())
.collect();
// Check if all items appear in required_by (meaning they've been processed)
// OR if they're in the cache from a previous resolution
let all_processed = item_names
.iter()
.all(|name| result_packages.contains(name) || cache_packages.contains(name));
if !all_processed {
let missing: Vec<String> = item_names
.iter()
.filter(|name| {
!result_packages.contains(*name) && !cache_packages.contains(*name)
})
.cloned()
.collect();
tracing::debug!(
"[Runtime] handle_dependency_result: Resolution incomplete - missing deps for: {:?}",
missing
);
}
return all_processed;
}
// If no preflight modal, check preflight_deps_items
if let Some((ref install_items, ref action)) = app.preflight_deps_items {
let item_names: std::collections::HashSet<String> =
install_items.iter().map(|i| i.name.clone()).collect();
if item_names.is_empty() {
return true;
}
// For Remove action: always complete when we get a result
if matches!(action, crate::state::PreflightAction::Remove) {
tracing::debug!(
"[Runtime] handle_dependency_result: Remove action (no modal) - resolution complete with {} results",
results.len()
);
return true;
}
// For Install action: check if all items have been processed
// Collect all packages that appear in required_by fields
let result_packages: std::collections::HashSet<String> = results
.iter()
.flat_map(|d| d.required_by.iter().cloned())
.collect();
let cache_packages: std::collections::HashSet<String> = app
.install_list_deps
.iter()
.flat_map(|d| d.required_by.iter().cloned())
.collect();
// Check if all items appear in required_by (meaning they've been processed)
let all_processed = item_names
.iter()
.all(|name| result_packages.contains(name) || cache_packages.contains(name));
if !all_processed {
let missing: Vec<String> = item_names
.iter()
.filter(|name| {
!result_packages.contains(*name) && !cache_packages.contains(*name)
})
.cloned()
.collect();
tracing::debug!(
"[Runtime] handle_dependency_result: Resolution incomplete - missing deps for: {:?}",
missing
);
}
return all_processed;
}
// No items to check, resolution is complete
true
}
}
/// What: Handle dependency resolution result event.
///
/// Inputs:
/// - `app`: Application state
/// - `deps`: Dependency resolution results
/// - `tick_tx`: Channel sender for tick events
///
/// Details:
/// - Updates cached dependencies
/// - Syncs dependencies to preflight modal if open
/// - Respects cancellation flag
pub fn handle_dependency_result(
app: &mut AppState,
deps: &[crate::state::modal::DependencyInfo],
tick_tx: &mpsc::UnboundedSender<()>,
) {
handle_result(app, deps, tick_tx, &DependencyHandlerConfig);
}
#[cfg(test)]
mod tests {
use super::*;
use crate::state::Source;
/// What: Provide a baseline `AppState` for handler tests.
///
/// Inputs: None
/// Output: Fresh `AppState` with default values
fn new_app() -> AppState {
AppState::default()
}
#[test]
/// What: Verify that `handle_add_to_install_list` adds item and triggers resolutions.
///
/// Inputs:
/// - App state with empty install list
/// - `PackageItem` to add
/// - Channel senders
///
/// Output:
/// - Item is added to install list
/// - Resolution flags are set
/// - Requests are sent to resolution channels
///
/// Details:
/// - Tests that adding items triggers background resolution
fn handle_add_to_install_list_adds_and_triggers_resolution() {
let mut app = new_app();
app.install_list.clear();
let (deps_tx, mut deps_rx) =
mpsc::unbounded_channel::<(Vec<PackageItem>, crate::state::modal::PreflightAction)>();
let (files_tx, mut files_rx) = mpsc::unbounded_channel();
let (services_tx, mut services_rx) = mpsc::unbounded_channel();
let (sandbox_tx, mut sandbox_rx) = mpsc::unbounded_channel();
let item = PackageItem {
name: "test-package".to_string(),
version: "1.0.0".to_string(),
description: "Test".to_string(),
source: Source::Aur,
popularity: None,
out_of_date: None,
orphaned: false,
};
handle_add_to_install_list(
&mut app,
item,
&deps_tx,
&files_tx,
&services_tx,
&sandbox_tx,
);
// Item should be added
assert_eq!(app.install_list.len(), 1);
assert_eq!(app.install_list[0].name, "test-package");
// Flags should be set
assert!(app.deps_resolving);
assert!(app.files_resolving);
assert!(app.services_resolving);
assert!(app.sandbox_resolving);
// Requests should be sent (with Install action)
let (items, action) = deps_rx.try_recv().expect("deps request should be sent");
assert_eq!(items.len(), 1);
assert!(matches!(
action,
crate::state::modal::PreflightAction::Install
));
assert!(files_rx.try_recv().is_ok());
assert!(services_rx.try_recv().is_ok());
assert!(sandbox_rx.try_recv().is_ok());
}
#[test]
/// What: Verify that `handle_dependency_result` updates cache and respects cancellation.
///
/// Inputs:
/// - App state
/// - Dependency resolution results
/// - Cancellation flag not set
///
/// Output:
/// - Dependencies are cached
/// - Flags are reset
///
/// Details:
/// - Tests that dependency results are properly processed
fn handle_dependency_result_updates_cache() {
let mut app = new_app();
app.deps_resolving = true;
app.preflight_deps_resolving = false;
app.preflight_cancelled
.store(false, std::sync::atomic::Ordering::Relaxed);
let (tick_tx, _tick_rx) = mpsc::unbounded_channel();
let deps = vec![crate::state::modal::DependencyInfo {
name: "dep-package".to_string(),
version: "1.0.0".to_string(),
status: crate::state::modal::DependencyStatus::ToInstall,
source: crate::state::modal::DependencySource::Official {
repo: "extra".to_string(),
},
required_by: vec!["test-package".to_string()],
depends_on: Vec::new(),
is_core: false,
is_system: false,
}];
handle_dependency_result(&mut app, &deps, &tick_tx);
// Dependencies should be cached
assert_eq!(app.install_list_deps.len(), 1);
// Flags should be reset
assert!(!app.deps_resolving);
assert!(!app.preflight_deps_resolving);
// Cache dirty flag should be set
assert!(app.deps_cache_dirty);
}
#[test]
/// What: Verify that `handle_dependency_result` ignores results when cancelled.
///
/// Inputs:
/// - App state with cancellation flag set
/// - Dependency resolution results
///
/// Output:
/// - Results are ignored
/// - Flags are still reset
///
/// Details:
/// - Tests that cancellation is properly respected
fn handle_dependency_result_respects_cancellation() {
let mut app = new_app();
app.preflight_deps_resolving = true;
app.preflight_cancelled
.store(true, std::sync::atomic::Ordering::Relaxed);
app.install_list_deps = vec![]; // Empty before
let (tick_tx, _tick_rx) = mpsc::unbounded_channel();
let deps = vec![crate::state::modal::DependencyInfo {
name: "dep-package".to_string(),
version: "1.0.0".to_string(),
status: crate::state::modal::DependencyStatus::ToInstall,
source: crate::state::modal::DependencySource::Official {
repo: "extra".to_string(),
},
required_by: vec!["test-package".to_string()],
depends_on: Vec::new(),
is_core: false,
is_system: false,
}];
handle_dependency_result(&mut app, &deps, &tick_tx);
// Dependencies should not be updated when cancelled
assert_eq!(app.install_list_deps.len(), 0);
// Flags should still be reset
assert!(!app.deps_resolving);
assert!(!app.preflight_deps_resolving);
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/app/runtime/handlers/mod.rs | src/app/runtime/handlers/mod.rs | /// Common utilities for channel handlers.
mod common;
/// Handler for file analysis results.
pub mod files;
/// Handler for install list and dependency results.
pub mod install;
/// Handler for sandbox analysis results.
pub mod sandbox;
/// Handler for search results and details updates.
pub mod search;
/// Handler for service impact analysis results.
pub mod services;
pub use files::handle_file_result;
pub use install::{handle_add_to_install_list, handle_dependency_result};
pub use sandbox::handle_sandbox_result;
pub use search::{handle_details_update, handle_preview, handle_search_results};
pub use services::handle_service_result;
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/app/runtime/handlers/files.rs | src/app/runtime/handlers/files.rs | use tokio::sync::mpsc;
use crate::app::runtime::handlers::common::{HandlerConfig, handle_result};
use crate::state::AppState;
/// What: Handler configuration for file results.
struct FileHandlerConfig;
impl HandlerConfig for FileHandlerConfig {
type Result = crate::state::modal::PackageFileInfo;
fn get_resolving(&self, app: &AppState) -> bool {
app.files_resolving
}
fn set_resolving(&self, app: &mut AppState, value: bool) {
app.files_resolving = value;
}
fn get_preflight_resolving(&self, app: &AppState) -> bool {
app.preflight_files_resolving
}
fn set_preflight_resolving(&self, app: &mut AppState, value: bool) {
app.preflight_files_resolving = value;
}
fn stage_name(&self) -> &'static str {
"files"
}
fn update_cache(&self, app: &mut AppState, results: &[Self::Result]) {
tracing::debug!(
"[Runtime] handle_file_result: Updating install_list_files with {} entries (current cache has {})",
results.len(),
app.install_list_files.len()
);
for file_info in results {
tracing::info!(
"[Runtime] handle_file_result: Package '{}' - total={}, new={}, changed={}, removed={}, config={}, pacnew={}, pacsave={}",
file_info.name,
file_info.total_count,
file_info.new_count,
file_info.changed_count,
file_info.removed_count,
file_info.config_count,
file_info.pacnew_candidates,
file_info.pacsave_candidates
);
}
app.install_list_files = results.to_vec();
tracing::debug!(
"[Runtime] handle_file_result: install_list_files now has {} entries: {:?}",
app.install_list_files.len(),
app.install_list_files
.iter()
.map(|f| &f.name)
.collect::<Vec<_>>()
);
}
fn set_cache_dirty(&self, app: &mut AppState) {
app.files_cache_dirty = true;
tracing::debug!(
"[Runtime] handle_file_result: Marked files_cache_dirty=true, install_list_files has {} entries: {:?}",
app.install_list_files.len(),
app.install_list_files
.iter()
.map(|f| &f.name)
.collect::<Vec<_>>()
);
}
fn clear_preflight_items(&self, app: &mut AppState) {
app.preflight_files_items = None;
}
fn sync_to_modal(&self, app: &mut AppState, results: &[Self::Result], was_preflight: bool) {
// Sync files to preflight modal if it's open (whether preflight or install list resolution)
if let crate::state::Modal::Preflight {
items, file_info, ..
} = &mut app.modal
{
// Filter files to only those for current modal items
let item_names: std::collections::HashSet<String> =
items.iter().map(|i| i.name.clone()).collect();
let filtered_files: Vec<_> = results
.iter()
.filter(|file_info| item_names.contains(&file_info.name))
.cloned()
.collect();
let old_files_len = file_info.len();
tracing::info!(
"[Runtime] handle_file_result: Modal open - items={}, filtered_files={}, modal_current={} (was {})",
items.len(),
filtered_files.len(),
file_info.len(),
old_files_len
);
if filtered_files.is_empty() {
tracing::debug!(
"[Runtime] handle_file_result: No matching files to sync. Modal items: {:?}, File packages: {:?}",
item_names,
results.iter().map(|f| &f.name).collect::<Vec<_>>()
);
} else {
tracing::info!(
"[Runtime] handle_file_result: Syncing {} file infos to preflight modal (was_preflight={}, modal had {} before)",
filtered_files.len(),
was_preflight,
old_files_len
);
// Merge new file data into existing entries instead of replacing
// This preserves empty entries for packages that don't have data yet
let filtered_files_map: std::collections::HashMap<String, _> = filtered_files
.iter()
.map(|f| (f.name.clone(), f.clone()))
.collect();
// Update existing entries with new data, or add new entries
for file_info_entry in file_info.iter_mut() {
if let Some(new_data) = filtered_files_map.get(&file_info_entry.name) {
let old_total = file_info_entry.total_count;
*file_info_entry = new_data.clone();
if old_total != new_data.total_count {
tracing::info!(
"[Runtime] handle_file_result: Updated modal entry for '{}' from total={} to total={}",
file_info_entry.name,
old_total,
new_data.total_count
);
}
}
}
// Add any new entries that weren't in the modal yet
for new_file in &filtered_files {
if !file_info.iter().any(|f| f.name == new_file.name) {
file_info.push(new_file.clone());
}
}
tracing::info!(
"[Runtime] handle_file_result: Successfully synced file info to modal, modal now has {} entries (was {})",
file_info.len(),
old_files_len
);
}
} else {
tracing::debug!(
"[Runtime] handle_file_result: Preflight modal not open, skipping sync"
);
}
}
fn log_flag_clear(&self, app: &AppState, was_preflight: bool, cancelled: bool) {
tracing::debug!(
"[Runtime] handle_file_result: Clearing flags - was_preflight={}, files_resolving={}, preflight_files_resolving={}, cancelled={}",
was_preflight,
self.get_resolving(app),
app.preflight_files_resolving,
cancelled
);
}
fn is_resolution_complete(&self, app: &AppState, results: &[Self::Result]) -> bool {
// Check if all items have file info
// If preflight modal is open, check modal items
if let crate::state::Modal::Preflight { items, .. } = &app.modal {
let item_names: std::collections::HashSet<String> =
items.iter().map(|i| i.name.clone()).collect();
let result_names: std::collections::HashSet<String> =
results.iter().map(|f| f.name.clone()).collect();
let cache_names: std::collections::HashSet<String> = app
.install_list_files
.iter()
.map(|f| f.name.clone())
.collect();
// Check if all items are in results or cache
let all_have_data = item_names
.iter()
.all(|name| result_names.contains(name) || cache_names.contains(name));
if !all_have_data {
let missing: Vec<String> = item_names
.iter()
.filter(|name| !result_names.contains(*name) && !cache_names.contains(*name))
.cloned()
.collect();
tracing::debug!(
"[Runtime] handle_file_result: Resolution incomplete - missing files for: {:?}",
missing
);
}
return all_have_data;
}
// If no preflight modal, check install list items
if let Some(ref install_items) = app.preflight_files_items {
let item_names: std::collections::HashSet<String> =
install_items.iter().map(|i| i.name.clone()).collect();
let result_names: std::collections::HashSet<String> =
results.iter().map(|f| f.name.clone()).collect();
let cache_names: std::collections::HashSet<String> = app
.install_list_files
.iter()
.map(|f| f.name.clone())
.collect();
// Check if all items are in results or cache
let all_have_data = item_names
.iter()
.all(|name| result_names.contains(name) || cache_names.contains(name));
if !all_have_data {
let missing: Vec<String> = item_names
.iter()
.filter(|name| !result_names.contains(*name) && !cache_names.contains(*name))
.cloned()
.collect();
tracing::debug!(
"[Runtime] handle_file_result: Resolution incomplete - missing files for: {:?}",
missing
);
}
return all_have_data;
}
// No items to check, resolution is complete
true
}
}
/// What: Handle file resolution result event.
///
/// Inputs:
/// - `app`: Application state
/// - `files`: File resolution results
/// - `tick_tx`: Channel sender for tick events
///
/// Details:
/// - Updates cached files
/// - Syncs files to preflight modal if open
/// - Respects cancellation flag
pub fn handle_file_result(
app: &mut AppState,
files: &[crate::state::modal::PackageFileInfo],
tick_tx: &mpsc::UnboundedSender<()>,
) {
handle_result(app, files, tick_tx, &FileHandlerConfig);
}
#[cfg(test)]
mod tests {
use super::*;
use crate::test_utils::new_app;
#[test]
/// What: Verify that `handle_file_result` updates cache correctly.
///
/// Inputs:
/// - App state
/// - File resolution results
///
/// Output:
/// - Files are cached
/// - Flags are reset
///
/// Details:
/// - Tests that file results are properly processed
fn handle_file_result_updates_cache() {
let mut app = new_app();
app.files_resolving = true;
let (tick_tx, _tick_rx) = mpsc::unbounded_channel();
let files = vec![crate::state::modal::PackageFileInfo {
name: "test-package".to_string(),
files: vec![],
total_count: 0,
new_count: 0,
changed_count: 0,
removed_count: 0,
config_count: 0,
pacnew_candidates: 0,
pacsave_candidates: 0,
}];
handle_file_result(&mut app, &files, &tick_tx);
// Files should be cached
assert_eq!(app.install_list_files.len(), 1);
// Flags should be reset
assert!(!app.files_resolving);
assert!(!app.preflight_files_resolving);
// Cache dirty flag should be set
assert!(app.files_cache_dirty);
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/app/runtime/handlers/common.rs | src/app/runtime/handlers/common.rs | //! Common handler infrastructure for result processing.
//!
//! This module provides a generic trait-based system for handling resolution results
//! with shared cancellation, flag management, and cache update logic.
use tokio::sync::mpsc;
use crate::state::AppState;
/// What: Configuration for a result handler that specifies how to access
/// and update `AppState` fields for a specific result type.
///
/// Inputs: Used by generic handler infrastructure
///
/// Output: Provides field accessors and update logic
///
/// Details:
/// - Each handler type implements this trait to specify its field accessors
/// - The generic handler uses these to perform common operations
pub trait HandlerConfig {
/// The result type this handler processes
type Result: Clone;
/// What: Get the current resolving flag value.
///
/// Inputs: `app` - Application state
///
/// Output: Current value of the resolving flag
fn get_resolving(&self, app: &AppState) -> bool;
/// What: Set the resolving flag to false.
///
/// Inputs: `app` - Mutable application state
///
/// Output: None (side effect: resets flag)
fn set_resolving(&self, app: &mut AppState, value: bool);
/// What: Get the current preflight resolving flag value.
///
/// Inputs: `app` - Application state
///
/// Output: Current value of the preflight resolving flag
fn get_preflight_resolving(&self, app: &AppState) -> bool;
/// What: Set the preflight resolving flag to false.
///
/// Inputs: `app` - Mutable application state
///
/// Output: None (side effect: resets flag)
fn set_preflight_resolving(&self, app: &mut AppState, value: bool);
/// What: Get the stage name for logging.
///
/// Inputs: None
///
/// Output: Stage name string (e.g., "files", "services")
fn stage_name(&self) -> &'static str;
/// What: Update the cache with new results.
///
/// Inputs:
/// - `app` - Mutable application state
/// - `results` - New resolution results
///
/// Output: None (side effect: updates cache)
fn update_cache(&self, app: &mut AppState, results: &[Self::Result]);
/// What: Mark the cache as dirty.
///
/// Inputs: `app` - Mutable application state
///
/// Output: None (side effect: sets dirty flag)
fn set_cache_dirty(&self, app: &mut AppState);
/// What: Clear preflight items if cancellation occurred.
///
/// Inputs: `app` - Mutable application state
///
/// Output: None (side effect: clears preflight items)
fn clear_preflight_items(&self, app: &mut AppState);
/// What: Sync results to the preflight modal if open.
///
/// Inputs:
/// - `app` - Mutable application state
/// - `results` - Resolution results to sync
/// - `was_preflight` - Whether this was a preflight resolution
///
/// Output: None (side effect: updates modal)
fn sync_to_modal(&self, app: &mut AppState, results: &[Self::Result], was_preflight: bool);
/// What: Log debug information about clearing flags.
///
/// Inputs:
/// - `app` - Application state
/// - `was_preflight` - Whether this was a preflight resolution
/// - `cancelled` - Whether the operation was cancelled
///
/// Output: None (side effect: logging)
fn log_flag_clear(&self, app: &AppState, was_preflight: bool, cancelled: bool);
/// What: Check if resolution is complete (all items have data).
///
/// Inputs:
/// - `app` - Application state
/// - `results` - Latest resolution results
///
/// Output: `true` if resolution is complete, `false` if more data is expected
///
/// Details:
/// - Default implementation returns `true` (assumes complete)
/// - Can be overridden to check for incomplete data
fn is_resolution_complete(&self, app: &AppState, results: &[Self::Result]) -> bool {
let _ = (app, results);
true
}
}
/// What: Generic handler function that processes resolution results with common logic.
///
/// Inputs:
/// - `app` - Mutable application state
/// - `results` - Resolution results to process
/// - `tick_tx` - Channel sender for tick events
/// - `config` - Handler configuration implementing `HandlerConfig`
///
/// Output: None (side effect: updates app state and sends tick)
///
/// Details:
/// - Handles cancellation checking
/// - Manages resolving flags
/// - Updates cache and syncs to modal
/// - Sends tick event
pub fn handle_result<C: HandlerConfig>(
app: &mut AppState,
results: &[C::Result],
tick_tx: &mpsc::UnboundedSender<()>,
config: &C,
) {
// Check if cancelled before updating
let cancelled = app
.preflight_cancelled
.load(std::sync::atomic::Ordering::Relaxed);
let was_preflight = config.get_preflight_resolving(app);
config.log_flag_clear(app, was_preflight, cancelled);
// Check if resolution is complete before clearing flags
let is_complete = config.is_resolution_complete(app, results);
// Only reset resolving flags if resolution is complete
if is_complete {
config.set_resolving(app, false);
}
config.set_preflight_resolving(app, false);
if cancelled {
if was_preflight {
tracing::debug!(
"[Runtime] Ignoring {} result (preflight cancelled)",
config.stage_name()
);
config.clear_preflight_items(app);
}
let _ = tick_tx.send(());
return;
}
// Update cache and sync to modal
tracing::info!(
stage = config.stage_name(),
result_count = results.len(),
was_preflight = was_preflight,
"[Runtime] {} resolution worker completed",
config.stage_name()
);
config.update_cache(app, results);
config.sync_to_modal(app, results, was_preflight);
if was_preflight {
config.clear_preflight_items(app);
}
config.set_cache_dirty(app);
let _ = tick_tx.send(());
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/i18n/translations.rs | src/i18n/translations.rs | //! Translation map and lookup utilities.
use std::collections::HashMap;
/// Translation map: dot-notation key -> translated string.
pub type TranslationMap = HashMap<String, String>;
/// What: Look up a translation in the translation map.
///
/// Inputs:
/// - `key`: Dot-notation key (e.g., "app.titles.search")
/// - `translations`: Translation map to search
///
/// Output:
/// - `Option<String>` containing translation or None if not found
///
/// Details:
/// - Direct key lookup
/// - Returns None if key not found
#[must_use]
pub fn translate(key: &str, translations: &TranslationMap) -> Option<String> {
translations.get(key).cloned()
}
/// What: Look up translation with fallback to English.
///
/// Inputs:
/// - `key`: Dot-notation key
/// - `translations`: Primary translation map
/// - `fallback_translations`: Fallback translation map (usually English)
///
/// Output:
/// - Translated string (from primary or fallback, or key itself if both missing)
///
/// Details:
/// - Tries primary translations first
/// - Falls back to English if not found
/// - Returns key itself if neither has translation (for debugging)
/// - Logs warnings for missing keys (only once per key to avoid spam)
pub fn translate_with_fallback(
key: &str,
translations: &TranslationMap,
fallback_translations: &TranslationMap,
) -> String {
// Try primary translations first
if let Some(translation) = translations.get(key) {
return translation.clone();
}
// Try fallback translations
if let Some(translation) = fallback_translations.get(key) {
// Log that we're using fallback (only at debug level to avoid spam)
tracing::debug!(
"Translation key '{}' not found in primary locale, using fallback",
key
);
return translation.clone();
}
// Neither has the key - log warning and return key itself
// Use debug level to avoid flooding logs, but make it discoverable
tracing::debug!(
"Missing translation key: '{}'. Returning key as-is. Please add this key to locale files.",
key
);
key.to_string()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_translate() {
let mut translations = HashMap::new();
translations.insert("app.titles.search".to_string(), "Suche".to_string());
assert_eq!(
translate("app.titles.search", &translations),
Some("Suche".to_string())
);
assert_eq!(translate("app.titles.help", &translations), None);
}
#[test]
fn test_translate_with_fallback() {
let mut primary = HashMap::new();
primary.insert("app.titles.search".to_string(), "Suche".to_string());
let mut fallback = HashMap::new();
fallback.insert("app.titles.search".to_string(), "Search".to_string());
fallback.insert("app.titles.help".to_string(), "Help".to_string());
assert_eq!(
translate_with_fallback("app.titles.search", &primary, &fallback),
"Suche"
);
assert_eq!(
translate_with_fallback("app.titles.help", &primary, &fallback),
"Help"
);
assert_eq!(
translate_with_fallback("app.titles.missing", &primary, &fallback),
"app.titles.missing"
);
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/i18n/mod.rs | src/i18n/mod.rs | //! Internationalization (i18n) module for Pacsea.
//!
//! This module provides locale detection, resolution, loading, and translation lookup.
//!
//! # Overview
//!
//! The i18n system supports:
//! - **Locale Detection**: Auto-detects system locale from environment variables (`LANG`, `LC_ALL`, `LC_MESSAGES`)
//! - **Locale Resolution**: Resolves locale with fallback chain (settings -> system -> default)
//! - **Fallback Chain**: Supports locale fallbacks (e.g., `de-CH` -> `de-DE` -> `en-US`)
//! - **Translation Loading**: Loads YAML locale files from `locales/` directory
//! - **Translation Lookup**: Provides `t()`, `t_fmt()`, and `t_fmt1()` helpers for translation access
//!
//! # Locale Files
//!
//! Locale files are stored in `locales/{locale}.yml` (e.g., `locales/en-US.yml`, `locales/de-DE.yml`).
//! Each file contains a nested YAML structure that is flattened into dot-notation keys:
//!
//! ```yaml
//! app:
//! titles:
//! search: "Search"
//! ```
//!
//! This becomes accessible as `app.titles.search`.
//!
//! # Configuration
//!
//! The i18n system is configured via `config/i18n.yml`:
//! - `default_locale`: Default locale if auto-detection fails (usually `en-US`)
//! - `fallbacks`: Map of locale codes to their fallback locales
//!
//! # Usage
//!
//! ```rust,no_run
//! use pacsea::i18n;
//! use pacsea::state::AppState;
//!
//! # let mut app = AppState::default();
//! // Simple translation lookup
//! let text = i18n::t(&app, "app.titles.search");
//!
//! // Translation with format arguments
//! let file_path = "/path/to/file";
//! let text = i18n::t_fmt1(&app, "app.toasts.exported_to", file_path);
//! ```
//!
//! # Adding a New Locale
//!
//! 1. Create `locales/{locale}.yml` (e.g., `locales/fr-FR.yml`)
//! 2. Copy structure from `locales/en-US.yml` and translate all strings
//! 3. Optionally add fallback in `config/i18n.yml` if needed (e.g., `fr: fr-FR`)
//! 4. Users can set `locale = fr-FR` in `settings.conf` or leave empty for auto-detection
//!
//! # Error Handling
//!
//! - Missing locale files fall back to English automatically
//! - Invalid locale codes in `settings.conf` trigger warnings and fallback to system/default
//! - Missing translation keys return the key itself (for debugging) and log debug messages
//! - All errors are logged but do not crash the application
mod detection;
mod loader;
mod resolver;
pub mod translations;
pub use detection::detect_system_locale;
pub use loader::{LocaleLoader, load_locale_file};
pub use resolver::{LocaleResolver, resolve_locale};
pub use translations::{TranslationMap, translate, translate_with_fallback};
use std::path::PathBuf;
/// What: Find a config file in development and installed locations.
///
/// Inputs:
/// - `relative_path`: Relative path from config directory (e.g., "i18n.yml")
///
/// Output:
/// - `Some(PathBuf)` pointing to the first existing file found, or `None` if not found
///
/// Details:
/// - Tries locations in order:
/// 1. Development location: `CARGO_MANIFEST_DIR/config/{relative_path}` (prioritized when running from source)
/// 2. Installed location: `/usr/share/pacsea/config/{relative_path}`
/// - Development location is checked first to allow working with repo files during development
#[must_use]
pub fn find_config_file(relative_path: &str) -> Option<PathBuf> {
// Try development location first (when running from source)
let dev_path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("config")
.join(relative_path);
if dev_path.exists() {
return Some(dev_path);
}
// Try installed location
let installed_path = PathBuf::from("/usr/share/pacsea/config").join(relative_path);
if installed_path.exists() {
return Some(installed_path);
}
None
}
/// What: Find the locales directory in development and installed locations.
///
/// Output:
/// - `Some(PathBuf)` pointing to the first existing locales directory found, or `None` if not found
///
/// Details:
/// - Tries locations in order:
/// 1. Development location: `CARGO_MANIFEST_DIR/config/locales` (prioritized when running from source)
/// 2. Installed location: `/usr/share/pacsea/locales`
/// - Development location is checked first to allow working with repo files during development
#[must_use]
pub fn find_locales_dir() -> Option<PathBuf> {
// Try development location first (when running from source)
// Note: locales are in config/locales/ in the dev environment
let dev_path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("config")
.join("locales");
if dev_path.exists() && dev_path.is_dir() {
return Some(dev_path);
}
// Also try the old location for backwards compatibility
let dev_path_old = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("locales");
if dev_path_old.exists() && dev_path_old.is_dir() {
return Some(dev_path_old);
}
// Try installed location
let installed_path = PathBuf::from("/usr/share/pacsea/locales");
if installed_path.exists() && installed_path.is_dir() {
return Some(installed_path);
}
None
}
/// What: Get a translation for a given key from `AppState`.
///
/// Inputs:
/// - `app`: `AppState` containing translation maps
/// - `key`: Dot-notation key (e.g., "app.titles.search")
///
/// Output:
/// - Translated string, or the key itself if translation not found
///
/// Details:
/// - Uses translations from `AppState`
/// - Falls back to English if translation missing
#[must_use]
pub fn t(app: &crate::state::AppState, key: &str) -> String {
crate::i18n::translations::translate_with_fallback(
key,
&app.translations,
&app.translations_fallback,
)
}
/// What: Get a translation with format arguments.
///
/// Inputs:
/// - `app`: `AppState` containing translation maps
/// - `key`: Dot-notation key
/// - `args`: Format arguments (as Display trait objects)
///
/// Output:
/// - Formatted translated string
///
/// Details:
/// - Replaces placeholders in order: first {} gets first arg, etc.
/// - Supports multiple placeholders: "{} and {}" -> "arg1 and arg2"
pub fn t_fmt(app: &crate::state::AppState, key: &str, args: &[&dyn std::fmt::Display]) -> String {
let translation = t(app, key);
let mut result = translation;
for arg in args {
result = result.replacen("{}", &arg.to_string(), 1);
}
result
}
/// What: Get a translation with a single format argument (convenience function).
///
/// Inputs:
/// - `app`: `AppState` containing translation maps
/// - `key`: Dot-notation key
/// - `arg`: Single format argument
///
/// Output:
/// - Formatted translated string
pub fn t_fmt1<T: std::fmt::Display>(app: &crate::state::AppState, key: &str, arg: T) -> String {
t_fmt(app, key, &[&arg])
}
/// What: Format translated string with two format arguments.
///
/// Inputs:
/// - `app`: Application state (for locale access)
/// - `key`: Translation key
/// - `arg1`: First format argument
/// - `arg2`: Second format argument
///
/// Output:
/// - Formatted translated string
pub fn t_fmt2<T1: std::fmt::Display, T2: std::fmt::Display>(
app: &crate::state::AppState,
key: &str,
arg1: T1,
arg2: T2,
) -> String {
t_fmt(app, key, &[&arg1, &arg2])
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/i18n/loader.rs | src/i18n/loader.rs | //! Locale file loading and parsing.
use std::collections::HashMap;
use std::fs;
use std::path::{Path, PathBuf};
use crate::i18n::translations::TranslationMap;
/// What: Load a locale YAML file and parse it into a `TranslationMap`.
///
/// Inputs:
/// - `locale`: Locale code (e.g., "de-DE")
/// - `locales_dir`: Path to locales directory
///
/// Output:
/// - `Result<TranslationMap, String>` containing translations or error
///
/// # Errors
/// - Returns `Err` when the locale code is empty or has an invalid format
/// - Returns `Err` when the locale file does not exist in the locales directory
/// - Returns `Err` when the locale file cannot be read (I/O error)
/// - Returns `Err` when the locale file is empty
/// - Returns `Err` when the YAML content cannot be parsed
///
/// Details:
/// - Loads file from `locales_dir/{locale}.yml`
/// - Parses YAML structure into nested `HashMap`
/// - Returns error if file not found or invalid YAML
/// - Validates locale format before attempting to load
pub fn load_locale_file(locale: &str, locales_dir: &Path) -> Result<TranslationMap, String> {
// Validate locale format
if locale.is_empty() {
return Err("Locale code cannot be empty".to_string());
}
if !is_valid_locale_format(locale) {
return Err(format!(
"Invalid locale code format: '{locale}'. Expected format: language[-region] (e.g., 'en-US', 'de-DE')"
));
}
let file_path = locales_dir.join(format!("{locale}.yml"));
if !file_path.exists() {
return Err(format!(
"Locale file not found: {}. Available locales can be checked in the locales/ directory.",
file_path.display()
));
}
let contents = fs::read_to_string(&file_path)
.map_err(|e| format!("Failed to read locale file {}: {e}", file_path.display()))?;
if contents.trim().is_empty() {
return Err(format!("Locale file is empty: {}", file_path.display()));
}
parse_locale_yaml(&contents).map_err(|e| {
format!(
"Failed to parse locale file {}: {}. Please check YAML syntax.",
file_path.display(),
e
)
})
}
/// What: Validate locale code format (same as resolver).
///
/// Inputs:
/// - `locale`: Locale code to validate
///
/// Output:
/// - `true` if format looks valid, `false` otherwise
fn is_valid_locale_format(locale: &str) -> bool {
if locale.is_empty() || locale.len() > 20 {
return false;
}
locale.chars().all(|c| c.is_alphanumeric() || c == '-')
&& !locale.starts_with('-')
&& !locale.ends_with('-')
&& !locale.contains("--")
}
/// What: Parse YAML content into a `TranslationMap`.
///
/// Inputs:
/// - `yaml_content`: YAML file content as string
///
/// Output:
/// - `Result<TranslationMap, String>` containing parsed translations
///
/// Details:
/// - Expects top-level key matching locale code (e.g., "de-DE:")
/// - Flattens nested structure into dot-notation keys
fn parse_locale_yaml(yaml_content: &str) -> Result<TranslationMap, String> {
let doc: serde_norway::Value =
serde_norway::from_str(yaml_content).map_err(|e| format!("Failed to parse YAML: {e}"))?;
let mut translations = HashMap::new();
// Get the top-level locale key (e.g., "de-DE")
if let Some(locale_obj) = doc.as_mapping() {
for (_locale_key, locale_value) in locale_obj {
// Flatten the nested structure (skip the top-level locale key)
flatten_yaml_value(locale_value, "", &mut translations);
}
}
Ok(translations)
}
/// What: Recursively flatten YAML structure into dot-notation keys.
///
/// Inputs:
/// - `value`: Current YAML value
/// - `prefix`: Current key prefix (e.g., "app.titles")
/// - `translations`: Map to populate
///
/// Details:
/// - Converts nested maps to dot-notation (e.g., app.titles.search)
/// - Handles arrays by preserving them as YAML values
fn flatten_yaml_value(
value: &serde_norway::Value,
prefix: &str,
translations: &mut TranslationMap,
) {
match value {
serde_norway::Value::Mapping(map) => {
for (key, val) in map {
if let Some(key_str) = key.as_str() {
let new_prefix = if prefix.is_empty() {
key_str.to_string()
} else {
format!("{prefix}.{key_str}")
};
flatten_yaml_value(val, &new_prefix, translations);
}
}
}
serde_norway::Value::String(s) => {
translations.insert(prefix.to_string(), s.clone());
}
serde_norway::Value::Sequence(_seq) => {
// Store arrays as YAML strings for now
// Can be enhanced later to handle arrays properly
if let Ok(yaml_str) = serde_norway::to_string(value) {
translations.insert(prefix.to_string(), yaml_str.trim().to_string());
}
}
_ => {
// Convert other types to string representation
let val_str = value.as_str().map_or_else(
|| {
value.as_i64().map_or_else(
|| {
value.as_f64().map_or_else(
|| value.as_bool().map_or_else(String::new, |b| b.to_string()),
|n| n.to_string(),
)
},
|n| n.to_string(),
)
},
std::string::ToString::to_string,
);
translations.insert(prefix.to_string(), val_str);
}
}
}
/// Locale loader that caches loaded translations.
pub struct LocaleLoader {
/// Directory containing locale translation files.
locales_dir: PathBuf,
/// Cache of loaded translations by locale name.
cache: HashMap<String, TranslationMap>,
}
impl LocaleLoader {
/// What: Create a new `LocaleLoader`.
///
/// Inputs:
/// - `locales_dir`: Path to locales directory
///
/// Output:
/// - `LocaleLoader` instance
#[must_use]
pub fn new(locales_dir: PathBuf) -> Self {
Self {
locales_dir,
cache: HashMap::new(),
}
}
/// What: Load locale file, using cache if available.
///
/// Inputs:
/// - `locale`: Locale code to load
///
/// Output:
/// - `Result<TranslationMap, String>` containing translations
///
/// # Errors
/// - Returns `Err` when the locale file cannot be loaded (see `load_locale_file` for specific error conditions)
///
/// # Panics
/// - Panics if the cache is modified between the `contains_key` check and the `get` call (should not happen in single-threaded usage)
///
/// Details:
/// - Caches loaded translations to avoid re-reading files
/// - Returns cached version if available
/// - Logs warnings for missing or invalid locale files
pub fn load(&mut self, locale: &str) -> Result<TranslationMap, String> {
if self.cache.contains_key(locale) {
Ok(self
.cache
.get(locale)
.expect("locale should be in cache after contains_key check")
.clone())
} else {
match load_locale_file(locale, &self.locales_dir) {
Ok(translations) => {
let key_count = translations.len();
tracing::debug!(
"Loaded locale '{}' with {} translation keys",
locale,
key_count
);
self.cache.insert(locale.to_string(), translations.clone());
Ok(translations)
}
Err(e) => {
tracing::warn!("Failed to load locale '{}': {}", locale, e);
Err(e)
}
}
}
}
/// What: Get locales directory path.
#[must_use]
pub fn locales_dir(&self) -> &Path {
&self.locales_dir
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::fs;
use tempfile::TempDir;
#[test]
fn test_parse_locale_yaml() {
let yaml = r#"
de-DE:
app:
titles:
search: "Suche"
help: "Hilfe"
"#;
let result = parse_locale_yaml(yaml).expect("Failed to parse test locale YAML");
assert_eq!(result.get("app.titles.search"), Some(&"Suche".to_string()));
assert_eq!(result.get("app.titles.help"), Some(&"Hilfe".to_string()));
}
#[test]
fn test_parse_locale_yaml_nested() {
let yaml = r#"
en-US:
app:
modals:
preflight:
title_install: " Preflight: Install "
tabs:
summary: "Summary"
deps: "Deps"
"#;
let result = parse_locale_yaml(yaml).expect("Failed to parse test locale YAML");
assert_eq!(
result.get("app.modals.preflight.title_install"),
Some(&" Preflight: Install ".to_string())
);
assert_eq!(
result.get("app.modals.preflight.tabs.summary"),
Some(&"Summary".to_string())
);
assert_eq!(
result.get("app.modals.preflight.tabs.deps"),
Some(&"Deps".to_string())
);
}
#[test]
fn test_parse_locale_yaml_invalid() {
let yaml = "invalid: yaml: content: [";
assert!(parse_locale_yaml(yaml).is_err());
}
#[test]
fn test_load_locale_file() {
let temp_dir = TempDir::new().expect("Failed to create temp directory for test");
let locales_dir = temp_dir.path();
// Create a test locale file
let locale_file = locales_dir.join("test-LOCALE.yml");
let yaml_content = r#"
test-LOCALE:
app:
titles:
search: "Test Search"
"#;
fs::write(&locale_file, yaml_content).expect("Failed to write test locale file");
let result =
load_locale_file("test-LOCALE", locales_dir).expect("Failed to load test locale file");
assert_eq!(
result.get("app.titles.search"),
Some(&"Test Search".to_string())
);
}
#[test]
fn test_load_locale_file_not_found() {
let temp_dir = TempDir::new().expect("Failed to create temp directory for test");
let locales_dir = temp_dir.path();
let result = load_locale_file("nonexistent", locales_dir);
assert!(result.is_err());
assert!(
result
.expect_err("Expected error for nonexistent locale file")
.contains("not found")
);
}
#[test]
fn test_load_locale_file_invalid_format() {
let temp_dir = TempDir::new().expect("Failed to create temp directory for test");
let locales_dir = temp_dir.path();
// Test with invalid locale format
let result = load_locale_file("invalid-format-", locales_dir);
assert!(result.is_err());
assert!(
result
.expect_err("Expected error for invalid locale format")
.contains("Invalid locale code format")
);
}
#[test]
fn test_load_locale_file_empty() {
let temp_dir = TempDir::new().expect("Failed to create temp directory for test");
let locales_dir = temp_dir.path();
// Create an empty locale file
let locale_file = locales_dir.join("empty.yml");
fs::write(&locale_file, "").expect("Failed to write empty test locale file");
let result = load_locale_file("empty", locales_dir);
assert!(result.is_err());
assert!(
result
.expect_err("Expected error for empty locale file")
.contains("empty")
);
}
#[test]
fn test_locale_loader_caching() {
let temp_dir = TempDir::new().expect("Failed to create temp directory for test");
let locales_dir = temp_dir.path();
// Create a test locale file
let locale_file = locales_dir.join("cache-test.yml");
let yaml_content = r#"
cache-test:
app:
titles:
search: "Cached"
"#;
fs::write(&locale_file, yaml_content).expect("Failed to write test locale file");
let mut loader = LocaleLoader::new(locales_dir.to_path_buf());
// First load
let result1 = loader
.load("cache-test")
.expect("Failed to load locale in test");
assert_eq!(
result1.get("app.titles.search"),
Some(&"Cached".to_string())
);
// Second load should use cache
let result2 = loader
.load("cache-test")
.expect("Failed to load cached locale in test");
assert_eq!(
result2.get("app.titles.search"),
Some(&"Cached".to_string())
);
// Both should be the same reference (cached)
assert_eq!(result1.len(), result2.len());
}
#[test]
fn test_is_valid_locale_format() {
// Valid formats
assert!(is_valid_locale_format("en-US"));
assert!(is_valid_locale_format("de-DE"));
assert!(is_valid_locale_format("zh-Hans-CN"));
assert!(is_valid_locale_format("en"));
// Invalid formats
assert!(!is_valid_locale_format(""));
assert!(!is_valid_locale_format("-en-US"));
assert!(!is_valid_locale_format("en-US-"));
assert!(!is_valid_locale_format("en--US"));
assert!(!is_valid_locale_format("en US"));
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/i18n/resolver.rs | src/i18n/resolver.rs | //! Locale resolution with fallback chain support.
use std::collections::HashMap;
use std::fs;
use std::path::PathBuf;
use crate::i18n::detection::detect_system_locale;
/// What: Resolve the effective locale to use, following fallback chain.
///
/// Inputs:
/// - `settings_locale`: Locale from settings.conf (empty string means auto-detect)
/// - `i18n_config_path`: Path to config/i18n.yml
///
/// Output:
/// - Resolved locale code (e.g., "de-DE")
///
/// Details:
/// - Priority: `settings_locale` -> system locale -> default from `i18n.yml`
/// - Applies fallback chain from `i18n.yml` (e.g., de-CH -> de-DE -> en-US)
/// - Validates locale format (basic check for valid locale code structure)
#[must_use]
pub fn resolve_locale(settings_locale: &str, i18n_config_path: &PathBuf) -> String {
let fallbacks = load_fallbacks(i18n_config_path);
let default_locale = load_default_locale(i18n_config_path);
let available_locales = load_available_locales(i18n_config_path);
// Determine initial locale
let initial_locale = if settings_locale.trim().is_empty() {
// Auto-detect from system
detect_system_locale().unwrap_or_else(|| {
tracing::debug!(
"System locale detection failed, using default: {}",
default_locale
);
default_locale.clone()
})
} else {
let trimmed = settings_locale.trim().to_string();
// Validate locale format (basic check)
if is_valid_locale_format(&trimmed) {
trimmed
} else {
tracing::warn!(
"Invalid locale format in settings.conf: '{}'. Using system locale or default.",
trimmed
);
detect_system_locale().unwrap_or_else(|| default_locale.clone())
}
};
// Apply fallback chain
let resolved = resolve_with_fallbacks(
&initial_locale,
&fallbacks,
&default_locale,
&available_locales,
);
if resolved != initial_locale {
tracing::debug!(
"Locale '{}' resolved to '{}' via fallback chain",
initial_locale,
resolved
);
}
resolved
}
/// What: Validate locale code format.
///
/// Inputs:
/// - `locale`: Locale code to validate
///
/// Output:
/// - `true` if format looks valid, `false` otherwise
///
/// Details:
/// - Checks for basic structure: language[-region] or language[-script][-region]
/// - Allows simple language codes (e.g., "en") or full codes (e.g., "en-US")
/// - Rejects obviously invalid formats (empty, spaces, special chars)
fn is_valid_locale_format(locale: &str) -> bool {
if locale.is_empty() || locale.len() > 20 {
return false;
}
// Basic pattern: language[-region] or language[-script][-region]
// Allow: en, en-US, de-DE, zh-Hans-CN, etc.
// Reject: spaces, most special chars (except hyphens)
locale.chars().all(|c| c.is_alphanumeric() || c == '-')
&& !locale.starts_with('-')
&& !locale.ends_with('-')
&& !locale.contains("--")
}
/// What: Resolve locale using fallback chain.
///
/// Inputs:
/// - `locale`: Initial locale code
/// - `fallbacks`: Map of locale -> fallback locale
/// - `default_locale`: Ultimate fallback (usually "en-US")
///
/// Output:
/// - Resolved locale that exists in available locales
///
/// Details:
/// - Follows fallback chain until reaching a locale without fallback or default
/// - Prevents infinite loops with cycle detection
/// - Logs warnings for suspicious fallback chains
fn resolve_with_fallbacks(
locale: &str,
fallbacks: &HashMap<String, String>,
default_locale: &str,
available_locales: &std::collections::HashSet<String>,
) -> String {
let mut current = locale.to_string();
let mut visited = std::collections::HashSet::new();
// Follow fallback chain until we find a valid locale or hit default
while visited.insert(current.clone()) {
// Check if we have a fallback for this locale
if let Some(fallback) = fallbacks.get(¤t) {
tracing::debug!("Locale '{}' has fallback: {}", current, fallback);
current.clone_from(fallback);
} else {
// No fallback defined - check if this locale is available
if available_locales.contains(¤t) {
// Locale is available, use it directly
tracing::debug!(
"Locale '{}' has no fallback but is available, using it directly",
current
);
return current;
} else if current == default_locale {
// Default locale is always valid
tracing::debug!(
"Locale '{}' has no fallback and is the default locale, using it directly",
current
);
return current;
}
// Locale not available and not default, fall back to default
tracing::debug!(
"Locale '{}' has no fallback and is not available, falling back to default: {}",
current,
default_locale
);
return default_locale.to_string();
}
// Safety check: prevent infinite loops
if visited.len() > 10 {
tracing::warn!(
"Fallback chain too long ({} steps) for locale '{}', using default: {}",
visited.len(),
locale,
default_locale
);
return default_locale.to_string();
}
}
// Detected a cycle in fallback chain
tracing::warn!(
"Detected cycle in fallback chain for locale '{}', using default: {}",
locale,
default_locale
);
default_locale.to_string()
}
/// What: Load fallback mappings from i18n.yml.
///
/// Inputs:
/// - `config_path`: Path to config/i18n.yml
///
/// Output:
/// - `HashMap` mapping locale codes to their fallback locales
fn load_fallbacks(config_path: &PathBuf) -> HashMap<String, String> {
let mut fallbacks = HashMap::new();
if let Ok(contents) = fs::read_to_string(config_path)
&& let Ok(doc) = serde_norway::from_str::<serde_norway::Value>(&contents)
&& let Some(fallbacks_map) = doc.get("fallbacks").and_then(|v| v.as_mapping())
{
for (key, value) in fallbacks_map {
if let (Some(k), Some(v)) = (key.as_str(), value.as_str()) {
fallbacks.insert(k.to_string(), v.to_string());
}
}
tracing::debug!(
"Loaded {} fallback mappings from i18n.yml: {:?}",
fallbacks.len(),
fallbacks.keys().collect::<Vec<_>>()
);
} else {
tracing::warn!("Failed to load fallbacks from i18n.yml");
}
fallbacks
}
/// What: Load available locales from i18n.yml.
///
/// Inputs:
/// - `config_path`: Path to config/i18n.yml
///
/// Output:
/// - `HashSet` of available locale codes
fn load_available_locales(config_path: &PathBuf) -> std::collections::HashSet<String> {
let mut locales = std::collections::HashSet::new();
if let Ok(contents) = fs::read_to_string(config_path)
&& let Ok(doc) = serde_norway::from_str::<serde_norway::Value>(&contents)
&& let Some(locales_map) = doc.get("locales").and_then(|v| v.as_mapping())
{
for key in locales_map.keys() {
if let Some(locale) = key.as_str() {
locales.insert(locale.to_string());
}
}
tracing::debug!(
"Loaded {} available locales from i18n.yml: {:?}",
locales.len(),
locales.iter().collect::<Vec<_>>()
);
}
locales
}
/// What: Load default locale from i18n.yml.
///
/// Inputs:
/// - `config_path`: Path to config/i18n.yml
///
/// Output:
/// - Default locale code (defaults to "en-US" if not found)
fn load_default_locale(config_path: &PathBuf) -> String {
if let Ok(contents) = fs::read_to_string(config_path)
&& let Ok(doc) = serde_norway::from_str::<serde_norway::Value>(&contents)
&& let Some(default) = doc.get("default_locale").and_then(|v| v.as_str())
{
return default.to_string();
}
"en-US".to_string()
}
/// Locale resolver that caches configuration.
pub struct LocaleResolver {
/// Map of locale to fallback locale.
fallbacks: HashMap<String, String>,
/// Default locale to use when no match is found.
default_locale: String,
/// Set of available locales.
available_locales: std::collections::HashSet<String>,
}
impl LocaleResolver {
/// What: Create a new `LocaleResolver` by loading `i18n.yml`.
///
/// Inputs:
/// - `i18n_config_path`: Path to config/i18n.yml
///
/// Output:
/// - `LocaleResolver` instance
#[must_use]
pub fn new(i18n_config_path: &PathBuf) -> Self {
Self {
fallbacks: load_fallbacks(i18n_config_path),
default_locale: load_default_locale(i18n_config_path),
available_locales: load_available_locales(i18n_config_path),
}
}
/// What: Resolve locale using cached fallback configuration.
///
/// Inputs:
/// - `settings_locale`: Locale from settings.conf
///
/// Output:
/// - Resolved locale code
#[must_use]
pub fn resolve(&self, settings_locale: &str) -> String {
let initial_locale = if settings_locale.trim().is_empty() {
detect_system_locale().unwrap_or_else(|| self.default_locale.clone())
} else {
let trimmed = settings_locale.trim().to_string();
// Validate locale format (basic check)
if is_valid_locale_format(&trimmed) {
trimmed
} else {
tracing::warn!(
"Invalid locale format in settings.conf: '{}'. Using system locale or default.",
trimmed
);
detect_system_locale().unwrap_or_else(|| self.default_locale.clone())
}
};
tracing::debug!(
"Resolving locale '{}' with {} fallbacks available",
initial_locale,
self.fallbacks.len()
);
if initial_locale == "ch" {
tracing::debug!(
"Checking for 'ch' in fallbacks: {}",
self.fallbacks.contains_key("ch")
);
if let Some(fallback) = self.fallbacks.get("ch") {
tracing::debug!("Found fallback for 'ch': {}", fallback);
}
}
let resolved = resolve_with_fallbacks(
&initial_locale,
&self.fallbacks,
&self.default_locale,
&self.available_locales,
);
if resolved != initial_locale {
tracing::debug!(
"Locale '{}' resolved to '{}' via fallback chain",
initial_locale,
resolved
);
}
resolved
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::fs;
use tempfile::TempDir;
#[test]
fn test_resolve_with_fallbacks() {
let mut fallbacks = HashMap::new();
fallbacks.insert("de-CH".to_string(), "de-DE".to_string());
fallbacks.insert("de".to_string(), "de-DE".to_string());
let mut available_locales = std::collections::HashSet::new();
available_locales.insert("de-DE".to_string());
available_locales.insert("en-US".to_string());
// Test fallback chain: de-CH -> de-DE (available, stops here)
assert_eq!(
resolve_with_fallbacks("de-CH", &fallbacks, "en-US", &available_locales),
"de-DE" // de-CH -> de-DE (available, stops)
);
// Test that de-DE is used directly when available
assert_eq!(
resolve_with_fallbacks("de-DE", &fallbacks, "en-US", &available_locales),
"de-DE"
);
// Test that default locale returns itself
assert_eq!(
resolve_with_fallbacks("en-US", &fallbacks, "en-US", &available_locales),
"en-US"
);
// Test single-part locale fallback
// de -> de-DE (available, stops)
assert_eq!(
resolve_with_fallbacks("de", &fallbacks, "en-US", &available_locales),
"de-DE" // de -> de-DE (available, stops)
);
// Test that unavailable locale falls back to default
let mut available_locales_no_de = std::collections::HashSet::new();
available_locales_no_de.insert("en-US".to_string());
assert_eq!(
resolve_with_fallbacks("de-DE", &fallbacks, "en-US", &available_locales_no_de),
"en-US" // de-DE not available, falls back to default
);
}
#[test]
fn test_resolve_with_fallbacks_cycle_detection() {
let mut fallbacks = HashMap::new();
// Create a cycle: a -> b -> c -> a
fallbacks.insert("a".to_string(), "b".to_string());
fallbacks.insert("b".to_string(), "c".to_string());
fallbacks.insert("c".to_string(), "a".to_string());
let available_locales = std::collections::HashSet::new();
// Should detect cycle and return default
let result = resolve_with_fallbacks("a", &fallbacks, "en-US", &available_locales);
assert_eq!(result, "en-US");
}
#[test]
fn test_resolve_with_fallbacks_long_chain() {
let mut fallbacks = HashMap::new();
// Create a long chain
for i in 0..15 {
let next = i + 1;
fallbacks.insert(format!("loc{i}"), format!("loc{next}"));
}
let available_locales = std::collections::HashSet::new();
// Should hit max length limit and return default
let result = resolve_with_fallbacks("loc0", &fallbacks, "en-US", &available_locales);
assert_eq!(result, "en-US");
}
#[test]
fn test_is_valid_locale_format() {
// Valid formats
assert!(is_valid_locale_format("en-US"));
assert!(is_valid_locale_format("de-DE"));
assert!(is_valid_locale_format("zh-Hans-CN"));
assert!(is_valid_locale_format("en"));
assert!(is_valid_locale_format("fr-FR"));
// Invalid formats
assert!(!is_valid_locale_format(""));
assert!(!is_valid_locale_format("-en-US"));
assert!(!is_valid_locale_format("en-US-"));
assert!(!is_valid_locale_format("en--US"));
assert!(!is_valid_locale_format("en US"));
assert!(!is_valid_locale_format("en@US"));
assert!(!is_valid_locale_format(&"x".repeat(21))); // Too long
}
#[test]
fn test_load_fallbacks() {
let temp_dir = TempDir::new().expect("Failed to create temp directory for test");
let config_path = temp_dir.path().join("i18n.yml");
let yaml_content = r"
default_locale: en-US
fallbacks:
de-CH: de-DE
de: de-DE
fr: fr-FR
";
fs::write(&config_path, yaml_content).expect("Failed to write test config file");
let fallbacks = load_fallbacks(&config_path);
assert_eq!(fallbacks.get("de-CH"), Some(&"de-DE".to_string()));
assert_eq!(fallbacks.get("de"), Some(&"de-DE".to_string()));
assert_eq!(fallbacks.get("fr"), Some(&"fr-FR".to_string()));
}
#[test]
fn test_load_default_locale() {
let temp_dir = TempDir::new().expect("Failed to create temp directory for test");
let config_path = temp_dir.path().join("i18n.yml");
let yaml_content = r"
default_locale: de-DE
fallbacks:
de-CH: de-DE
";
fs::write(&config_path, yaml_content).expect("Failed to write test config file");
let default = load_default_locale(&config_path);
assert_eq!(default, "de-DE");
}
#[test]
fn test_load_default_locale_missing() {
let temp_dir = TempDir::new().expect("Failed to create temp directory for test");
let config_path = temp_dir.path().join("i18n.yml");
let yaml_content = r"
fallbacks:
de-CH: de-DE
";
fs::write(&config_path, yaml_content).expect("Failed to write test config file");
let default = load_default_locale(&config_path);
assert_eq!(default, "en-US"); // Should default to en-US
}
#[test]
fn test_resolve_locale_with_settings() {
let temp_dir = TempDir::new().expect("Failed to create temp directory for test");
let config_path = temp_dir.path().join("i18n.yml");
let yaml_content = r"
default_locale: en-US
fallbacks:
de-CH: de-DE
";
fs::write(&config_path, yaml_content).expect("Failed to write test config file");
// Test with explicit locale from settings
// de-CH -> de-DE -> (no fallback) -> en-US (default)
let result = resolve_locale("de-CH", &config_path);
assert_eq!(result, "en-US"); // Should fallback through chain to default
// Test with valid locale that has no fallback
let result = resolve_locale("en-US", &config_path);
assert_eq!(result, "en-US");
// Test with invalid locale format
let result = resolve_locale("invalid-format-", &config_path);
// Should fallback to system/default (may vary based on environment)
assert!(!result.is_empty());
}
#[test]
fn test_resolve_locale_empty_settings() {
let temp_dir = TempDir::new().expect("Failed to create temp directory for test");
let config_path = temp_dir.path().join("i18n.yml");
let yaml_content = r"
default_locale: en-US
fallbacks:
de-CH: de-DE
";
fs::write(&config_path, yaml_content).expect("Failed to write test config file");
// Test with empty settings (should auto-detect or use default)
let result = resolve_locale("", &config_path);
// Result depends on system locale, but should not be empty
assert!(!result.is_empty());
// Test with whitespace-only settings
let result = resolve_locale(" ", &config_path);
assert!(!result.is_empty());
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/i18n/detection.rs | src/i18n/detection.rs | //! System locale detection utilities.
use std::env;
/// What: Detect system locale from environment variables.
///
/// Inputs:
/// - None (reads from environment)
///
/// Output:
/// - `Option<String>` containing locale code (e.g., "de-DE") or None if not detectable
///
/// Details:
/// - Checks `LC_ALL`, `LC_MESSAGES`, and `LANG` environment variables in order
/// - Parses locale strings like "de_DE.UTF-8" -> "de-DE"
/// - Returns None if no valid locale found
#[must_use]
pub fn detect_system_locale() -> Option<String> {
// Check environment variables in priority order
let locale_vars = ["LC_ALL", "LC_MESSAGES", "LANG"];
for var_name in &locale_vars {
if let Ok(locale_str) = env::var(var_name)
&& let Some(parsed) = parse_locale_string(&locale_str)
{
return Some(parsed);
}
}
None
}
/// What: Parse a locale string from environment variables into a standardized format.
///
/// Inputs:
/// - `locale_str`: Locale string like `"de_DE.UTF-8"`, `"de-DE"`, `"en_US.utf8"`
///
/// Output:
/// - `Option<String>` with standardized format (e.g., "de-DE") or None if invalid
///
/// Details:
/// - Converts underscores to hyphens
/// - Removes encoding suffix (.UTF-8, .utf8, etc.)
/// - Handles both `"de_DE"` and `"de-DE"` formats
fn parse_locale_string(locale_str: &str) -> Option<String> {
let trimmed = locale_str.trim();
if trimmed.is_empty() {
return None;
}
// Split on dot to remove encoding (e.g., "de_DE.UTF-8" -> "de_DE")
let locale_part = trimmed.split('.').next()?;
// Convert underscores to hyphens and normalize case
let normalized = locale_part.replace('_', "-");
// Validate format: should be like "en-US" or "de-DE" (2-3 parts separated by hyphens)
let parts: Vec<&str> = normalized.split('-').collect();
if parts.len() >= 2 && parts.len() <= 3 {
// Reconstruct with proper casing: language should be lowercase, region uppercase
let language = parts[0].to_lowercase();
let region = parts[1].to_uppercase();
if parts.len() == 3 {
// Handle script variant (e.g., "zh-Hans-CN")
let script = parts[2];
Some(format!("{language}-{script}-{region}"))
} else {
Some(format!("{language}-{region}"))
}
} else if parts.len() == 1 {
// Single part locale (e.g., "en", "de") - return as-is for fallback handling
Some(parts[0].to_lowercase())
} else {
None
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_parse_locale_string() {
assert_eq!(
parse_locale_string("de_DE.UTF-8"),
Some("de-DE".to_string())
);
assert_eq!(parse_locale_string("en_US.utf8"), Some("en-US".to_string()));
assert_eq!(parse_locale_string("de-DE"), Some("de-DE".to_string()));
assert_eq!(parse_locale_string("en"), Some("en".to_string()));
// Note: zh_Hans_CN parses as zh-HANS-CN (language-script-region)
// The function splits on underscore first, then formats as language-script-region
assert_eq!(
parse_locale_string("zh_Hans_CN.UTF-8"),
Some("zh-CN-HANS".to_string()) // Actually parsed as zh-CN-HANS due to split order
);
assert_eq!(parse_locale_string(""), None);
// "invalid_format" becomes "invalid-FORMAT" after underscore->hyphen conversion
// It's treated as a two-part locale (invalid-FORMAT)
assert_eq!(
parse_locale_string("invalid_format"),
Some("invalid-FORMAT".to_string())
);
}
#[test]
fn test_detect_system_locale_with_env() {
// Save original values
let original_lang = env::var("LANG").ok();
let original_lc_all = env::var("LC_ALL").ok();
let original_lc_messages = env::var("LC_MESSAGES").ok();
unsafe {
// Test with LANG set
env::set_var("LANG", "de_DE.UTF-8");
env::remove_var("LC_ALL");
env::remove_var("LC_MESSAGES");
}
let result = detect_system_locale();
assert_eq!(result, Some("de-DE".to_string()));
unsafe {
// Test with LC_ALL taking priority
env::set_var("LC_ALL", "fr_FR.UTF-8");
env::set_var("LANG", "de_DE.UTF-8");
}
let result = detect_system_locale();
assert_eq!(result, Some("fr-FR".to_string()));
unsafe {
// Test with LC_MESSAGES taking priority over LANG but not LC_ALL
env::set_var("LC_ALL", "es_ES.UTF-8");
env::set_var("LC_MESSAGES", "it_IT.UTF-8");
env::set_var("LANG", "de_DE.UTF-8");
}
let result = detect_system_locale();
assert_eq!(result, Some("es-ES".to_string())); // LC_ALL should win
unsafe {
// Test with no locale set
env::remove_var("LC_ALL");
env::remove_var("LC_MESSAGES");
env::remove_var("LANG");
}
let result = detect_system_locale();
assert_eq!(result, None);
// Restore original values
unsafe {
if let Some(val) = original_lang {
env::set_var("LANG", val);
} else {
env::remove_var("LANG");
}
if let Some(val) = original_lc_all {
env::set_var("LC_ALL", val);
} else {
env::remove_var("LC_ALL");
}
if let Some(val) = original_lc_messages {
env::set_var("LC_MESSAGES", val);
} else {
env::remove_var("LC_MESSAGES");
}
}
}
#[test]
fn test_parse_locale_string_edge_cases() {
// Test various formats
// Single character locales are converted to lowercase
assert_eq!(parse_locale_string("C"), Some("c".to_string()));
// POSIX is converted to lowercase
assert_eq!(parse_locale_string("POSIX"), Some("posix".to_string()));
// Test with different encoding
assert_eq!(
parse_locale_string("en_US.ISO8859-1"),
Some("en-US".to_string())
);
// Test with modifier (@euro) - modifier is preserved in the locale part
// The function doesn't strip modifiers, so de_DE@euro becomes de-DE@EURO
assert_eq!(
parse_locale_string("de_DE@euro"),
Some("de-DE@EURO".to_string())
);
// Test invalid formats
assert_eq!(parse_locale_string(""), None);
assert_eq!(parse_locale_string(" "), None);
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/global.rs | src/events/global.rs | //! Global shortcuts and dropdown menu handling.
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
use tokio::sync::mpsc;
use crate::app::{apply_settings_to_app_state, initialize_locale_system};
use crate::events::mouse::menus::{handle_mode_toggle, handle_news_age_toggle};
use crate::events::utils;
use crate::state::{AppState, PackageItem};
use crate::theme::{reload_theme, settings};
/// What: Close all open dropdown menus when ESC is pressed.
///
/// Inputs:
/// - `app`: Mutable application state
///
/// Output:
/// - `true` if menus were closed, `false` otherwise
///
/// Details:
/// - Closes sort, options, panels, config, and artix filter menus.
#[allow(clippy::missing_const_for_fn)]
fn close_all_dropdowns(app: &mut AppState) -> bool {
let any_open = app.sort_menu_open
|| app.options_menu_open
|| app.panels_menu_open
|| app.config_menu_open
|| app.artix_filter_menu_open;
if any_open {
app.sort_menu_open = false;
app.sort_menu_auto_close_at = None;
app.options_menu_open = false;
app.panels_menu_open = false;
app.config_menu_open = false;
app.artix_filter_menu_open = false;
true
} else {
false
}
}
/// What: Handle installed-only mode toggle from options menu.
///
/// Inputs:
/// - `app`: Mutable application state
/// - `details_tx`: Channel to request package details
///
/// Details:
/// - Toggles between showing all packages and only explicitly installed packages.
/// - When enabling, saves installed packages list to config directory.
fn handle_options_installed_only_toggle(
app: &mut AppState,
details_tx: &mpsc::UnboundedSender<PackageItem>,
) {
use std::collections::HashSet;
if app.installed_only_mode {
if let Some(prev) = app.results_backup_for_toggle.take() {
app.all_results = prev;
}
app.installed_only_mode = false;
app.right_pane_focus = crate::state::RightPaneFocus::Install;
crate::logic::apply_filters_and_sort_preserve_selection(app);
utils::refresh_selected_details(app, details_tx);
} else {
app.results_backup_for_toggle = Some(app.all_results.clone());
let explicit = crate::index::explicit_names();
let mut items: Vec<crate::state::PackageItem> = crate::index::all_official()
.into_iter()
.filter(|p| explicit.contains(&p.name))
.collect();
let official_names: HashSet<String> = items.iter().map(|p| p.name.clone()).collect();
for name in explicit {
if !official_names.contains(&name) {
let is_eos = crate::index::is_eos_name(&name);
let src = if is_eos {
crate::state::Source::Official {
repo: "EOS".to_string(),
arch: String::new(),
}
} else {
crate::state::Source::Aur
};
items.push(crate::state::PackageItem {
name: name.clone(),
version: String::new(),
description: String::new(),
source: src,
popularity: None,
out_of_date: None,
orphaned: false,
});
}
}
app.all_results = items;
app.installed_only_mode = true;
app.right_pane_focus = crate::state::RightPaneFocus::Remove;
crate::logic::apply_filters_and_sort_preserve_selection(app);
utils::refresh_selected_details(app, details_tx);
let path = crate::theme::config_dir().join("installed_packages.txt");
// Query pacman directly with current mode to ensure file reflects the setting
let names = crate::index::query_explicit_packages_sync(app.installed_packages_mode);
let body = names.join("\n");
let _ = std::fs::write(path, body);
}
}
/// What: Handle system update option from options menu.
///
/// Inputs:
/// - `app`: Mutable application state
///
/// Details:
/// - Opens `SystemUpdate` modal with default settings.
fn handle_options_system_update(app: &mut AppState) {
let countries = vec![
"Worldwide".to_string(),
"Germany".to_string(),
"United States".to_string(),
"United Kingdom".to_string(),
"France".to_string(),
"Netherlands".to_string(),
"Sweden".to_string(),
"Canada".to_string(),
"Australia".to_string(),
"Japan".to_string(),
];
let prefs = crate::theme::settings();
let initial_country_idx = {
let sel = prefs
.selected_countries
.split(',')
.next()
.map_or_else(|| "Worldwide".to_string(), |s| s.trim().to_string());
countries.iter().position(|c| c == &sel).unwrap_or(0)
};
app.modal = crate::state::Modal::SystemUpdate {
do_mirrors: false,
do_pacman: true,
force_sync: false,
do_aur: true,
do_cache: false,
country_idx: initial_country_idx,
countries,
mirror_count: prefs.mirror_count,
cursor: 0,
};
}
/// What: Handle optional deps option from options menu.
///
/// Inputs:
/// - `app`: Mutable application state
///
/// Details:
/// - Builds optional dependencies rows and opens `OptionalDeps` modal.
fn handle_options_optional_deps(app: &mut AppState) {
let rows = crate::events::mouse::menu_options::build_optional_deps_rows(app);
app.modal = crate::state::Modal::OptionalDeps { rows, selected: 0 };
}
/// What: Handle panels menu numeric selection.
///
/// Inputs:
/// - `idx`: Selected menu index (0=recent, 1=install, 2=keybinds)
/// - `app`: Mutable application state
///
/// Details:
/// - Toggles visibility of recent pane, install pane, or keybinds footer.
fn handle_panels_menu_selection(idx: usize, app: &mut AppState) {
let news_mode = matches!(app.app_mode, crate::state::types::AppMode::News);
if news_mode {
match idx {
0 => {
app.show_news_history_pane = !app.show_news_history_pane;
if !app.show_news_history_pane && matches!(app.focus, crate::state::Focus::Recent) {
app.focus = crate::state::Focus::Search;
}
}
1 => {
app.show_news_bookmarks_pane = !app.show_news_bookmarks_pane;
if !app.show_news_bookmarks_pane
&& matches!(app.focus, crate::state::Focus::Install)
{
app.focus = crate::state::Focus::Search;
}
}
2 => {
app.show_keybinds_footer = !app.show_keybinds_footer;
crate::theme::save_show_keybinds_footer(app.show_keybinds_footer);
}
_ => {}
}
} else {
match idx {
0 => {
app.show_recent_pane = !app.show_recent_pane;
if !app.show_recent_pane && matches!(app.focus, crate::state::Focus::Recent) {
app.focus = crate::state::Focus::Search;
}
crate::theme::save_show_recent_pane(app.show_recent_pane);
}
1 => {
app.show_install_pane = !app.show_install_pane;
if !app.show_install_pane && matches!(app.focus, crate::state::Focus::Install) {
app.focus = crate::state::Focus::Search;
}
crate::theme::save_show_install_pane(app.show_install_pane);
}
2 => {
app.show_keybinds_footer = !app.show_keybinds_footer;
crate::theme::save_show_keybinds_footer(app.show_keybinds_footer);
}
_ => {}
}
}
}
/// What: Normalize `BackTab` modifiers so that `SHIFT` modifier does not affect matching across terminals.
///
/// Inputs:
/// - `ke`: Key event from crossterm
///
/// Output:
/// - Normalized modifiers (empty for `BackTab`, original modifiers otherwise)
///
/// Details:
/// - `BackTab` normalization ensures consistent keybind matching across different terminal emulators.
const fn normalize_key_modifiers(ke: &KeyEvent) -> KeyModifiers {
if matches!(ke.code, KeyCode::BackTab) {
KeyModifiers::empty()
} else {
ke.modifiers
}
}
/// What: Create a normalized key chord from a key event for keybind matching.
///
/// Inputs:
/// - `ke`: Key event from crossterm
///
/// Output:
/// - Tuple of (`KeyCode`, `KeyModifiers`) suitable for matching against `KeyChord` lists
///
/// Details:
/// - Normalizes `BackTab` modifiers before creating the chord.
const fn create_key_chord(ke: &KeyEvent) -> (KeyCode, KeyModifiers) {
(ke.code, normalize_key_modifiers(ke))
}
/// What: Check if a key event matches any chord in a list of keybinds.
///
/// Inputs:
/// - `ke`: Key event from crossterm
/// - `chords`: List of configured key chords to match against
///
/// Output:
/// - `true` if the key event matches any chord in the list, `false` otherwise
///
/// Details:
/// - Normalizes `BackTab` modifiers before matching.
fn matches_keybind(ke: &KeyEvent, chords: &[crate::theme::KeyChord]) -> bool {
let chord = create_key_chord(ke);
chords.iter().any(|c| (c.code, c.mods) == chord)
}
/// What: Handle escape key press - closes dropdown menus.
///
/// Inputs:
/// - `app`: Mutable application state
///
/// Output:
/// - `Some(false)` if menus were closed, `None` otherwise
///
/// Details:
/// - Closes all open dropdown menus when ESC is pressed.
fn handle_escape(app: &mut AppState) -> Option<bool> {
if close_all_dropdowns(app) {
Some(false)
} else {
None
}
}
/// What: Handle help overlay keybind.
///
/// Inputs:
/// - `app`: Mutable application state
///
/// Output:
/// - `false` if help was opened
///
/// Details:
/// - Opens the Help modal when the help overlay keybind is pressed.
fn handle_help_overlay(app: &mut AppState) -> bool {
app.modal = crate::state::Modal::Help;
false
}
/// What: Handle configuration reload keybind.
///
/// Inputs:
/// - `app`: Mutable application state
/// - `query_tx`: Channel sender for query input (to refresh results when installed mode changes)
///
/// Output:
/// - `false` if config was reloaded
///
/// Details:
/// - Reloads theme, settings, keybinds, and locale configuration from disk.
/// - Shows a toast message on success or error modal on failure.
/// - Updates app state with new settings and reloads translations if locale changed.
/// - If `installed_packages_mode` changed, refreshes the explicit cache in the background
/// and triggers a query refresh after the cache refresh completes (to avoid race conditions).
fn handle_reload_config(
app: &mut AppState,
query_tx: &mpsc::UnboundedSender<crate::state::QueryInput>,
) -> bool {
let mut errors = Vec::new();
// Reload theme
if let Err(msg) = reload_theme() {
errors.push(format!("Theme reload failed: {msg}"));
}
// Reload settings and keybinds
let new_settings = settings();
let old_locale = app.locale.clone();
let old_installed_mode = app.installed_packages_mode;
apply_settings_to_app_state(app, &new_settings);
// Reload locale if it changed
if new_settings.locale != old_locale {
initialize_locale_system(app, &new_settings.locale, &new_settings);
}
// Refresh explicit cache if installed packages mode changed
if app.installed_packages_mode != old_installed_mode {
let new_mode = app.installed_packages_mode;
tracing::info!(
"[Config] installed_packages_mode changed from {:?} to {:?}, refreshing cache",
old_installed_mode,
new_mode
);
// Prepare query input before spawning (to avoid race condition)
let id = app.next_query_id;
app.next_query_id += 1;
app.latest_query_id = id;
let query_input = crate::state::QueryInput {
id,
text: app.input.clone(),
fuzzy: app.fuzzy_search_enabled,
};
// Clone query_tx to send query after cache refresh completes
let query_tx_clone = query_tx.clone();
tokio::spawn(async move {
// Refresh cache first
crate::index::refresh_explicit_cache(new_mode).await;
// Then send query to ensure results use the refreshed cache
let _ = query_tx_clone.send(query_input);
});
}
// Show result
if errors.is_empty() {
app.toast_message = Some(crate::i18n::t(app, "app.toasts.config_reloaded"));
app.toast_expires_at = Some(std::time::Instant::now() + std::time::Duration::from_secs(3));
} else {
app.modal = crate::state::Modal::Alert {
message: errors.join("\n"),
};
}
false
}
/// What: Handle exit keybind.
///
/// Inputs:
/// - None (uses closure pattern)
///
/// Output:
/// - `true` to signal exit
///
/// Details:
/// - Returns exit signal when exit keybind is pressed.
const fn handle_exit() -> bool {
true
}
/// What: Handle PKGBUILD viewer toggle keybind.
///
/// Inputs:
/// - `app`: Mutable application state
/// - `pkgb_tx`: Channel to request PKGBUILD content
///
/// Output:
/// - `false` if PKGBUILD was toggled
///
/// Details:
/// - Toggles PKGBUILD viewer visibility and requests content if opening.
fn handle_toggle_pkgbuild(
app: &mut AppState,
pkgb_tx: &mpsc::UnboundedSender<PackageItem>,
) -> bool {
if app.pkgb_visible {
app.pkgb_visible = false;
app.pkgb_text = None;
app.pkgb_package_name = None;
app.pkgb_scroll = 0;
app.pkgb_rect = None;
} else {
app.pkgb_visible = true;
app.pkgb_text = None;
app.pkgb_package_name = None;
if let Some(item) = app.results.get(app.selected).cloned() {
let _ = pkgb_tx.send(item);
}
}
false
}
/// What: Handle comments toggle keybind.
///
/// Inputs:
/// - `app`: Mutable application state
/// - `comments_tx`: Channel to request comments content
///
/// Output:
/// - `false` (doesn't exit app)
///
/// Details:
/// - Toggles comments viewer visibility
/// - Clears comments when closing
/// - Sends request via channel when opening (only if AUR package)
fn handle_toggle_comments(app: &mut AppState, comments_tx: &mpsc::UnboundedSender<String>) -> bool {
// Only allow for AUR packages
let is_aur = app
.results
.get(app.selected)
.is_some_and(|item| matches!(item.source, crate::state::Source::Aur));
if !is_aur {
return false;
}
if app.comments_visible {
app.comments_visible = false;
app.comments.clear();
app.comments_package_name = None;
app.comments_fetched_at = None;
app.comments_scroll = 0;
app.comments_rect = None;
app.comments_loading = false;
app.comments_error = None;
} else {
app.comments_visible = true;
app.comments_scroll = 0;
app.comments_error = None;
if let Some(item) = app.results.get(app.selected) {
// Check if we have cached comments for this package
if app
.comments_package_name
.as_ref()
.is_some_and(|cached_name| cached_name == &item.name && !app.comments.is_empty())
{
// Use cached comments
app.comments_loading = false;
return false;
}
// Request new comments
app.comments.clear();
app.comments_package_name = None;
app.comments_fetched_at = None;
app.comments_loading = true;
let _ = comments_tx.send(item.name.clone());
}
}
false
}
/// What: Handle sort mode change keybind.
///
/// Inputs:
/// - `app`: Mutable application state
/// - `details_tx`: Channel to request package details
///
/// Output:
/// - `false` if sort mode was changed
///
/// Details:
/// - In News mode: cycles through news sort modes and refreshes news results.
/// - In Package mode: cycles through package sort modes, persists preference, re-sorts results.
fn handle_change_sort(app: &mut AppState, details_tx: &mpsc::UnboundedSender<PackageItem>) -> bool {
if matches!(app.app_mode, crate::state::types::AppMode::News) {
// News mode: cycle through news sort modes
use crate::state::types::NewsSortMode;
app.news_sort_mode = match app.news_sort_mode {
NewsSortMode::DateDesc => NewsSortMode::DateAsc,
NewsSortMode::DateAsc => NewsSortMode::Title,
NewsSortMode::Title => NewsSortMode::SourceThenTitle,
NewsSortMode::SourceThenTitle => NewsSortMode::SeverityThenDate,
NewsSortMode::SeverityThenDate => NewsSortMode::UnreadThenDate,
NewsSortMode::UnreadThenDate => NewsSortMode::DateDesc,
};
app.refresh_news_results();
} else {
// Package mode: cycle through package sort modes in fixed order
app.sort_mode = match app.sort_mode {
crate::state::SortMode::RepoThenName => {
crate::state::SortMode::AurPopularityThenOfficial
}
crate::state::SortMode::AurPopularityThenOfficial => {
crate::state::SortMode::BestMatches
}
crate::state::SortMode::BestMatches => crate::state::SortMode::RepoThenName,
};
// Persist preference and apply immediately
crate::theme::save_sort_mode(app.sort_mode);
crate::logic::sort_results_preserve_selection(app);
// Jump selection to top and refresh details
if app.results.is_empty() {
app.list_state.select(None);
} else {
app.selected = 0;
app.list_state.select(Some(0));
utils::refresh_selected_details(app, details_tx);
}
}
// Show the dropdown so the user sees the current option with a check mark
app.sort_menu_open = true;
false
}
/// What: Handle numeric menu selection for options menu.
///
/// Inputs:
/// - `idx`: Selected menu index (0-based, where '1' key maps to idx 0)
/// - `app`: Mutable application state
/// - `details_tx`: Channel to request package details
///
/// Output:
/// - `Some(false)` if selection was handled, `None` otherwise
///
/// Details:
/// - Package mode display order: List installed (1), Update system (2), TUI Optional Deps (3), News management (4)
/// - News mode display order: Update system (1), TUI Optional Deps (2), Package mode (3)
/// - Closes the options menu when a selection is handled.
/// - Note: News age toggle (idx 3 in News mode) is not displayed in menu but handler remains for compatibility.
fn handle_options_menu_numeric(
idx: usize,
app: &mut AppState,
details_tx: &mpsc::UnboundedSender<PackageItem>,
) -> Option<bool> {
let news_mode = matches!(app.app_mode, crate::state::types::AppMode::News);
let handled = if news_mode {
// News mode display order: Update system (1), TUI Optional Deps (2), Package mode (3)
match idx {
0 => {
handle_options_system_update(app);
true
}
1 => {
handle_options_optional_deps(app);
true
}
2 => {
handle_mode_toggle(app, details_tx);
true
}
3 => {
handle_news_age_toggle(app);
true
}
_ => false,
}
} else {
// Package mode display order: List installed (1), Update system (2), TUI Optional Deps (3), News management (4)
match idx {
0 => {
handle_options_installed_only_toggle(app, details_tx);
true
}
1 => {
handle_options_system_update(app);
true
}
2 => {
handle_options_optional_deps(app);
true
}
3 => {
handle_mode_toggle(app, details_tx);
true
}
_ => false,
}
};
if handled {
app.options_menu_open = false;
Some(false)
} else {
None
}
}
/// What: Handle numeric menu selection for panels menu.
///
/// Inputs:
/// - `idx`: Selected menu index (0=recent, 1=install, 2=keybinds)
/// - `app`: Mutable application state
///
/// Output:
/// - `false` if selection was handled
///
/// Details:
/// - Routes numeric selection to panels menu handler and keeps menu open.
fn handle_panels_menu_numeric(idx: usize, app: &mut AppState) -> bool {
handle_panels_menu_selection(idx, app);
// Keep menu open after toggling panels
false
}
/// What: Handle numeric menu selection for config menu.
///
/// Inputs:
/// - `idx`: Selected menu index (0=settings, 1=theme, 2=keybinds, 3=install, 4=installed, 5=recent)
/// - `app`: Mutable application state
///
/// Output:
/// - `false` if selection was handled
///
/// Details:
/// - Routes numeric selection to config menu handler.
fn handle_config_menu_numeric(idx: usize, app: &mut AppState) -> bool {
handle_config_menu_selection(idx, app);
false
}
/// What: Handle numeric key press when dropdown menus are open.
///
/// Inputs:
/// - `ch`: Character pressed (must be '1'-'9')
/// - `app`: Mutable application state
/// - `details_tx`: Channel to request package details
///
/// Output:
/// - `Some(false)` if a menu selection was handled, `None` otherwise
///
/// Details:
/// - Routes numeric keys to the appropriate open menu handler.
fn handle_menu_numeric_selection(
ch: char,
app: &mut AppState,
details_tx: &mpsc::UnboundedSender<PackageItem>,
) -> Option<bool> {
let idx = (ch as u8 - b'1') as usize; // '1' -> 0
if app.options_menu_open {
handle_options_menu_numeric(idx, app, details_tx)
} else if app.panels_menu_open {
Some(handle_panels_menu_numeric(idx, app))
} else if app.config_menu_open {
Some(handle_config_menu_numeric(idx, app))
} else {
None
}
}
/// What: Handle global keybinds (help, theme reload, exit, PKGBUILD, comments, sort).
///
/// Inputs:
/// - `ke`: Key event from crossterm
/// - `app`: Mutable application state
/// - `details_tx`: Channel to request package details
/// - `pkgb_tx`: Channel to request PKGBUILD content
/// - `comments_tx`: Channel to request comments content
/// - `query_tx`: Channel to send search queries
///
/// Output:
/// - `Some(true)` for exit, `Some(false)` if handled, `None` if not matched
///
/// Details:
/// - Checks key event against all global keybinds using a dispatch pattern.
/// - When a modal is open (except None), only exit keybind works globally.
/// - Other global keybinds are blocked to let modals handle their own keys.
fn handle_global_keybinds(
ke: &KeyEvent,
app: &mut AppState,
details_tx: &mpsc::UnboundedSender<PackageItem>,
pkgb_tx: &mpsc::UnboundedSender<PackageItem>,
comments_tx: &mpsc::UnboundedSender<String>,
query_tx: &mpsc::UnboundedSender<crate::state::QueryInput>,
) -> Option<bool> {
let km = &app.keymap;
// Exit should always work, even in modals (Ctrl+C to quit the app)
if matches_keybind(ke, &km.exit) {
return Some(handle_exit());
}
// When a modal is open, block most global keybinds to let the modal handle keys
// Exceptions: Modal::None (no modal), Preflight (has complex interaction with globals)
if !matches!(
app.modal,
crate::state::Modal::None | crate::state::Modal::Preflight { .. }
) {
return None; // Let modal handler process the key
}
// Log Ctrl+T specifically for debugging
if ke.code == KeyCode::Char('t') && ke.modifiers.contains(KeyModifiers::CONTROL) {
tracing::debug!(
"[Keybind] Ctrl+T detected: code={:?}, mods={:?}, keybind_match={}, comments_toggle_keybinds={:?}",
ke.code,
ke.modifiers,
matches_keybind(ke, &km.comments_toggle),
km.comments_toggle
);
}
// Comments toggle - check FIRST before other keybinds to ensure it's not intercepted
if matches_keybind(ke, &km.comments_toggle) {
tracing::debug!("[Keybind] Comments toggle matched, calling handle_toggle_comments");
return Some(handle_toggle_comments(app, comments_tx));
}
// Help overlay (only if no modal is active, except Preflight which handles its own help)
if !matches!(app.modal, crate::state::Modal::Preflight { .. })
&& matches_keybind(ke, &km.help_overlay)
{
return Some(handle_help_overlay(app));
}
// Configuration reload (only if no modal is active - modals should handle their own keys)
if matches!(app.modal, crate::state::Modal::None) && matches_keybind(ke, &km.reload_config) {
return Some(handle_reload_config(app, query_tx));
}
// Exit (always works, even in modals)
if matches_keybind(ke, &km.exit) {
return Some(handle_exit());
}
// PKGBUILD toggle (only if no modal is active - modals should handle their own keys)
if matches!(app.modal, crate::state::Modal::None) && matches_keybind(ke, &km.show_pkgbuild) {
return Some(handle_toggle_pkgbuild(app, pkgb_tx));
}
// Sort change (only if no modal is active - modals should handle their own keys)
if matches!(app.modal, crate::state::Modal::None) && matches_keybind(ke, &km.change_sort) {
return Some(handle_change_sort(app, details_tx));
}
None
}
/// What: Handle config menu numeric selection.
///
/// Inputs:
/// - `idx`: Selected menu index (0=settings, 1=theme, 2=keybinds)
/// - `app`: Mutable application state
///
/// Details:
/// - Opens the selected config file in a terminal editor.
fn handle_config_menu_selection(idx: usize, app: &mut AppState) {
let settings_path = crate::theme::config_dir().join("settings.conf");
let theme_path = crate::theme::config_dir().join("theme.conf");
let keybinds_path = crate::theme::config_dir().join("keybinds.conf");
let target = match idx {
0 => settings_path,
1 => theme_path,
2 => keybinds_path,
_ => {
app.config_menu_open = false;
app.artix_filter_menu_open = false;
return;
}
};
#[cfg(target_os = "windows")]
{
crate::util::open_file(&target);
}
#[cfg(not(target_os = "windows"))]
{
let path_str = target.display().to_string();
let editor_cmd = format!(
"((command -v nvim >/dev/null 2>&1 || sudo pacman -Qi neovim >/dev/null 2>&1) && nvim '{path_str}') || \\
((command -v vim >/dev/null 2>&1 || sudo pacman -Qi vim >/dev/null 2>&1) && vim '{path_str}') || \\
((command -v hx >/dev/null 2>&1 || sudo pacman -Qi helix >/dev/null 2>&1) && hx '{path_str}') || \\
((command -v helix >/dev/null 2>&1 || sudo pacman -Qi helix >/dev/null 2>&1) && helix '{path_str}') || \\
((command -v emacsclient >/dev/null 2>&1 || sudo pacman -Qi emacs >/dev/null 2>&1) && emacsclient -t '{path_str}') || \\
((command -v emacs >/dev/null 2>&1 || sudo pacman -Qi emacs >/dev/null 2>&1) && emacs -nw '{path_str}') || \\
((command -v nano >/dev/null 2>&1 || sudo pacman -Qi nano >/dev/null 2>&1) && nano '{path_str}') || \\
(echo 'No terminal editor found (nvim/vim/emacsclient/emacs/hx/helix/nano).'; echo 'File: {path_str}'; read -rn1 -s _ || true)",
);
let cmds = vec![editor_cmd];
std::thread::spawn(move || {
crate::install::spawn_shell_commands_in_terminal(&cmds);
});
}
app.config_menu_open = false;
app.artix_filter_menu_open = false;
}
/// What: Handle global shortcuts plus dropdown menus and optionally stop propagation.
///
/// Inputs:
/// - `ke`: Key event received from crossterm (code + modifiers)
/// - `app`: Mutable application state shared across panes and modals
/// - `details_tx`: Channel used to request package detail refreshes
/// - `pkgb_tx`: Channel used to request PKGBUILD content for the focused result
/// - `comments_tx`: Channel used to request comments content for the focused result
/// - `query_tx`: Channel to send search queries
///
/// Output:
/// - `Some(true)` when the caller should exit (e.g., global exit keybind triggered)
/// - `Some(false)` when a global keybind was handled (key should not be processed further)
/// - `None` when the key was not handled by global shortcuts
///
/// Details:
/// - Gives precedence to closing dropdown menus on `Esc` before other bindings.
/// - Routes configured global chords (help overlay, theme reload, exit, PKGBUILD toggle, comments toggle, sort cycle).
/// - When sort mode changes it persists the preference, re-sorts results, and refreshes details.
/// - Supports menu number shortcuts (1-9) for Options/Panels/Config dropdowns while they are open.
pub(super) fn handle_global_key(
ke: KeyEvent,
app: &mut AppState,
details_tx: &mpsc::UnboundedSender<PackageItem>,
pkgb_tx: &mpsc::UnboundedSender<PackageItem>,
comments_tx: &mpsc::UnboundedSender<String>,
query_tx: &mpsc::UnboundedSender<crate::state::QueryInput>,
) -> Option<bool> {
// First: handle ESC to close dropdown menus
if ke.code == KeyCode::Esc
&& let Some(result) = handle_escape(app)
{
return Some(result);
}
// Second: handle global keybinds (help, theme reload, exit, PKGBUILD, comments, sort)
if let Some(result) =
handle_global_keybinds(&ke, app, details_tx, pkgb_tx, comments_tx, query_tx)
{
return Some(result);
}
// Third: handle numeric menu selection when dropdowns are open
// Note: menu toggles (Shift+C/O/P) handled in Search Normal mode and not globally
if let KeyCode::Char(ch) = ke.code
&& ch.is_ascii_digit()
&& ch != '0'
&& let Some(result) = handle_menu_numeric_selection(ch, app, details_tx)
{
return Some(result);
}
None // Key not handled by global shortcuts
}
#[cfg(test)]
mod tests {
use super::*;
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
fn new_app() -> AppState {
AppState::default()
}
#[test]
/// What: Confirm pressing `Esc` while dropdowns are open closes them without exiting.
///
/// Inputs:
/// - App state with Options and Sort menus flagged open.
/// - Synthetic `Esc` key event.
///
/// Output:
/// - Handler returns `false` and menu flags reset to `false`.
///
/// Details:
/// - Ensures the early escape branch short-circuits before other global shortcuts.
fn global_escape_closes_dropdowns() {
let mut app = new_app();
app.sort_menu_open = true;
app.options_menu_open = true;
app.panels_menu_open = true;
app.config_menu_open = true;
let (details_tx, _details_rx) = mpsc::unbounded_channel::<PackageItem>();
let (pkgb_tx, _pkgb_rx) = mpsc::unbounded_channel::<PackageItem>();
let (comments_tx, _comments_rx) = mpsc::unbounded_channel::<String>();
let (query_tx, _query_rx) = mpsc::unbounded_channel::<crate::state::QueryInput>();
let exit = handle_global_key(
KeyEvent::new(KeyCode::Esc, KeyModifiers::empty()),
&mut app,
&details_tx,
&pkgb_tx,
&comments_tx,
&query_tx,
);
assert_eq!(exit, Some(false));
assert!(!app.sort_menu_open);
assert!(!app.options_menu_open);
assert!(!app.panels_menu_open);
assert!(!app.config_menu_open);
}
#[test]
/// What: Verify the help overlay shortcut activates the Help modal.
///
/// Inputs:
/// - Default keymap (F1 assigned to help overlay).
/// - `F1` key event with no modifiers.
///
/// Output:
/// - Handler returns `false` and sets `app.modal` to `Modal::Help`.
///
/// Details:
/// - Confirms `BackTab` normalization does not interfere with regular function keys.
fn global_help_overlay_opens_modal() {
let mut app = new_app();
let (details_tx, _details_rx) = mpsc::unbounded_channel::<PackageItem>();
let (pkgb_tx, _pkgb_rx) = mpsc::unbounded_channel::<PackageItem>();
let (comments_tx, _comments_rx) = mpsc::unbounded_channel::<String>();
let (query_tx, _query_rx) = mpsc::unbounded_channel::<crate::state::QueryInput>();
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | true |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/utils.rs | src/events/utils.rs | use crossterm::event::KeyEvent;
use tokio::sync::mpsc;
use crate::state::{AppState, PackageItem};
use std::time::Instant;
/// What: Check if a key event matches any chord in a list, handling Shift+char edge cases.
///
/// Inputs:
/// - `ke`: Key event from terminal
/// - `list`: List of configured key chords to match against
///
/// Output:
/// - `true` if the key event matches any chord in the list, `false` otherwise
///
/// Details:
/// - Treats Shift+<char> from config as equivalent to uppercase char without Shift from terminal.
/// - Handles cases where terminals report Shift inconsistently.
#[must_use]
pub fn matches_any(ke: &KeyEvent, list: &[crate::theme::KeyChord]) -> bool {
list.iter().any(|c| {
if (c.code, c.mods) == (ke.code, ke.modifiers) {
return true;
}
match (c.code, ke.code) {
(crossterm::event::KeyCode::Char(cfg_ch), crossterm::event::KeyCode::Char(ev_ch)) => {
let cfg_has_shift = c.mods.contains(crossterm::event::KeyModifiers::SHIFT);
if !cfg_has_shift {
return false;
}
// Accept uppercase event regardless of SHIFT flag
if ev_ch == cfg_ch.to_ascii_uppercase() {
return true;
}
// Accept lowercase char if terminal reports SHIFT in modifiers
if ke.modifiers.contains(crossterm::event::KeyModifiers::SHIFT)
&& ev_ch.to_ascii_lowercase() == cfg_ch
{
return true;
}
false
}
_ => false,
}
})
}
/// What: Return the number of Unicode scalar values (characters) in the input.
///
/// Input: `s` string to measure
/// Output: Character count as `usize`
///
/// Details: Counts Unicode scalar values using `s.chars().count()`.
#[must_use]
pub fn char_count(s: &str) -> usize {
s.chars().count()
}
/// What: Convert a character index to a byte index for slicing.
///
/// Input: `s` source string; `ci` character index
/// Output: Byte index into `s` corresponding to `ci`
///
/// Details: Returns 0 for `ci==0`; returns `s.len()` when `ci>=char_count(s)`; otherwise maps
/// the character index to a byte offset via `char_indices()`.
#[must_use]
pub fn byte_index_for_char(s: &str, ci: usize) -> usize {
let cc = char_count(s);
if ci == 0 {
return 0;
}
if ci >= cc {
return s.len();
}
s.char_indices()
.map(|(i, _)| i)
.nth(ci)
.map_or(s.len(), |i| i)
}
/// What: Advance selection in the Recent pane to the next/previous match of the pane-find pattern.
///
/// Input: `app` mutable application state; `forward` when true searches downward, else upward
/// Output: No return value; updates `history_state` selection when a match is found
///
/// Details: Searches within the filtered Recent indices and wraps around the list; matching is
/// case-insensitive against the current pane-find pattern.
pub fn find_in_recent(app: &mut AppState, forward: bool) {
let Some(pattern) = app.pane_find.clone() else {
return;
};
let inds = crate::ui::helpers::filtered_recent_indices(app);
if inds.is_empty() {
return;
}
let start = app.history_state.selected().unwrap_or(0);
let mut vi = start;
let n = inds.len();
for _ in 0..n {
vi = if forward {
(vi + 1) % n
} else if vi == 0 {
n - 1
} else {
vi - 1
};
let i = inds[vi];
if let Some(s) = app.recent_value_at(i)
&& s.to_lowercase().contains(&pattern.to_lowercase())
{
app.history_state.select(Some(vi));
break;
}
}
}
/// What: Advance selection in the Install pane to the next/previous item matching the pane-find pattern.
///
/// Input: `app` mutable application state; `forward` when true searches downward, else upward
/// Output: No return value; updates `install_state` selection when a match is found
///
/// Details: Operates on visible indices and tests case-insensitive matches against package name
/// or description; wraps around the list.
pub fn find_in_install(app: &mut AppState, forward: bool) {
let Some(pattern) = app.pane_find.clone() else {
return;
};
let inds = crate::ui::helpers::filtered_install_indices(app);
if inds.is_empty() {
return;
}
let start = app.install_state.selected().unwrap_or(0);
let mut vi = start;
let n = inds.len();
for _ in 0..n {
vi = if forward {
(vi + 1) % n
} else if vi == 0 {
n - 1
} else {
vi - 1
};
let i = inds[vi];
if let Some(p) = app.install_list.get(i)
&& (p.name.to_lowercase().contains(&pattern.to_lowercase())
|| p.description
.to_lowercase()
.contains(&pattern.to_lowercase()))
{
app.install_state.select(Some(vi));
break;
}
}
}
/// What: Ensure details reflect the currently selected result.
///
/// Input: `app` mutable application state; `details_tx` channel for details requests
/// Output: No return value; uses cache or sends a details request
///
/// Details: If details for the selected item exist in the cache, they are applied immediately;
/// otherwise, the item is sent over `details_tx` to be fetched asynchronously.
pub fn refresh_selected_details(
app: &mut AppState,
details_tx: &mpsc::UnboundedSender<PackageItem>,
) {
if let Some(item) = app.results.get(app.selected).cloned() {
// Reset scroll when package changes
app.details_scroll = 0;
if let Some(cached) = app.details_cache.get(&item.name).cloned() {
app.details = cached;
} else {
let _ = details_tx.send(item);
}
}
}
/// Move news selection by delta, keeping it in view.
pub fn move_news_selection(app: &mut AppState, delta: isize) {
if app.news_results.is_empty() {
app.news_selected = 0;
app.news_list_state.select(None);
app.details.url.clear();
return;
}
let len = app.news_results.len();
if app.news_selected >= len {
app.news_selected = len.saturating_sub(1);
}
app.news_list_state.select(Some(app.news_selected));
let steps = delta.unsigned_abs();
for _ in 0..steps {
if delta.is_negative() {
app.news_list_state.select_previous();
} else {
app.news_list_state.select_next();
}
}
let sel = app.news_list_state.selected().unwrap_or(0);
app.news_selected = std::cmp::min(sel, len.saturating_sub(1));
app.news_list_state.select(Some(app.news_selected));
update_news_url(app);
}
/// Synchronize details URL and content with currently selected news item.
/// Also triggers content fetching if channel is provided and content is not cached.
pub fn update_news_url(app: &mut AppState) {
if let Some(item) = app.news_results.get(app.news_selected)
&& let Some(url) = &item.url
{
app.details.url.clone_from(url);
// Check if content is cached
let mut cached = app.news_content_cache.get(url).cloned();
if let Some(ref c) = cached
&& url.contains("://archlinux.org/packages/")
&& !c.starts_with("Package Info:")
{
// Cached pre-metadata version: force refresh
cached = None;
tracing::debug!(
url,
"news content cache missing package metadata; will refetch"
);
}
app.news_content = cached;
if app.news_content.is_some() {
tracing::debug!(url, "news content served from cache");
} else {
// Content not cached - set debounce timer to wait 0.5 seconds before fetching
app.news_content_debounce_timer = Some(std::time::Instant::now());
tracing::debug!(url, "news content not cached, setting debounce timer");
}
app.news_content_scroll = 0;
} else {
app.details.url.clear();
app.news_content = None;
app.news_content_debounce_timer = None;
}
app.news_content_loading = false;
}
/// Request news content fetch if not cached or loading.
/// Implements 0.5 second debounce - only requests after user stays on item for 0.5 seconds.
pub fn maybe_request_news_content(
app: &mut AppState,
news_content_req_tx: &mpsc::UnboundedSender<String>,
) {
// Only request if in news mode with a selected item that has a URL
if !matches!(app.app_mode, crate::state::types::AppMode::News) {
tracing::trace!("news_content: skip request, not in news mode");
return;
}
if app.news_content_loading {
tracing::debug!(
selected = app.news_selected,
"news_content: skip request, already loading"
);
return;
}
if let Some(item) = app.news_results.get(app.news_selected)
&& let Some(url) = &item.url
&& app.news_content.is_none()
&& !app.news_content_cache.contains_key(url)
{
// Check debounce timer - only request after 0.5 seconds of staying on the item
// 500ms balances user experience with server load: long enough to avoid excessive
// fetches during rapid navigation, short enough to feel responsive.
const DEBOUNCE_DELAY_MS: u64 = 500;
if let Some(timer) = app.news_content_debounce_timer {
// Safe to unwrap: elapsed will be small (well within u64)
#[allow(clippy::cast_possible_truncation)]
let elapsed = timer.elapsed().as_millis() as u64;
if elapsed < DEBOUNCE_DELAY_MS {
// Debounce not expired yet - wait longer
tracing::trace!(
selected = app.news_selected,
url,
elapsed_ms = elapsed,
remaining_ms = DEBOUNCE_DELAY_MS - elapsed,
"news_content: debounce timer not expired, waiting"
);
return;
}
// Debounce expired - clear timer and proceed with request
app.news_content_debounce_timer = None;
} else {
// No debounce timer set - this shouldn't happen, but set it now
app.news_content_debounce_timer = Some(std::time::Instant::now());
tracing::debug!(
selected = app.news_selected,
url,
"news_content: no debounce timer, setting one now"
);
return;
}
app.news_content_loading = true;
app.news_content_loading_since = Some(Instant::now());
tracing::debug!(
selected = app.news_selected,
title = item.title,
url,
"news_content: requesting article content (debounce expired)"
);
if let Err(e) = news_content_req_tx.send(url.clone()) {
tracing::warn!(
error = %e,
selected = app.news_selected,
title = item.title,
url,
"news_content: failed to enqueue content request"
);
app.news_content_loading = false;
app.news_content_loading_since = None;
app.news_content = Some(format!("Failed to load content: {e}"));
app.toast_message = Some("News content request failed".to_string());
app.toast_expires_at = Some(Instant::now() + std::time::Duration::from_secs(3));
}
} else {
tracing::trace!(
selected = app.news_selected,
has_item = app.news_results.get(app.news_selected).is_some(),
has_url = app
.news_results
.get(app.news_selected)
.and_then(|it| it.url.as_ref())
.is_some(),
content_cached = app
.news_results
.get(app.news_selected)
.and_then(|it| it.url.as_ref())
.is_some_and(|u| app.news_content_cache.contains_key(u)),
has_content = app.news_content.is_some(),
"news_content: skip request (cached/absent URL/already loaded)"
);
}
}
/// What: Ensure details reflect the selected item in the Install pane.
///
/// Input: `app` mutable application state; `details_tx` channel for details requests
/// Output: No return value; focuses details on the selected Install item and uses cache or requests fetch
///
/// Details: Sets `details_focus`, populates a placeholder from the selected item, then uses the
/// cache when present; otherwise sends a request over `details_tx`.
pub fn refresh_install_details(
app: &mut AppState,
details_tx: &mpsc::UnboundedSender<PackageItem>,
) {
let Some(vsel) = app.install_state.selected() else {
return;
};
let inds = crate::ui::helpers::filtered_install_indices(app);
if inds.is_empty() || vsel >= inds.len() {
return;
}
let i = inds[vsel];
if let Some(item) = app.install_list.get(i).cloned() {
// Reset scroll when package changes
app.details_scroll = 0;
// Focus details on the install selection
app.details_focus = Some(item.name.clone());
// Provide an immediate placeholder reflecting the selection
app.details.name.clone_from(&item.name);
app.details.version.clone_from(&item.version);
app.details.description.clear();
match &item.source {
crate::state::Source::Official { repo, arch } => {
app.details.repository.clone_from(repo);
app.details.architecture.clone_from(arch);
}
crate::state::Source::Aur => {
app.details.repository = "AUR".to_string();
app.details.architecture = "any".to_string();
}
}
if let Some(cached) = app.details_cache.get(&item.name).cloned() {
app.details = cached;
} else {
let _ = details_tx.send(item);
}
}
}
/// What: Ensure details reflect the selected item in the Remove pane.
///
/// Input: `app` mutable application state; `details_tx` channel for details requests
/// Output: No return value; focuses details on the selected Remove item and uses cache or requests fetch
///
/// Details: Sets `details_focus`, populates a placeholder from the selected item, then uses the
/// cache when present; otherwise sends a request over `details_tx`.
pub fn refresh_remove_details(app: &mut AppState, details_tx: &mpsc::UnboundedSender<PackageItem>) {
let Some(vsel) = app.remove_state.selected() else {
return;
};
if app.remove_list.is_empty() || vsel >= app.remove_list.len() {
return;
}
if let Some(item) = app.remove_list.get(vsel).cloned() {
// Reset scroll when package changes
app.details_scroll = 0;
app.details_focus = Some(item.name.clone());
app.details.name.clone_from(&item.name);
app.details.version.clone_from(&item.version);
app.details.description.clear();
match &item.source {
crate::state::Source::Official { repo, arch } => {
app.details.repository.clone_from(repo);
app.details.architecture.clone_from(arch);
}
crate::state::Source::Aur => {
app.details.repository = "AUR".to_string();
app.details.architecture = "any".to_string();
}
}
if let Some(cached) = app.details_cache.get(&item.name).cloned() {
app.details = cached;
} else {
let _ = details_tx.send(item);
}
}
}
/// What: Ensure details reflect the selected item in the Downgrade pane.
///
/// Input: `app` mutable application state; `details_tx` channel for details requests
/// Output: No return value; focuses details on the selected Downgrade item and uses cache or requests fetch
///
/// Details: Sets `details_focus`, populates a placeholder from the selected item, then uses the
/// cache when present; otherwise sends a request over `details_tx`.
pub fn refresh_downgrade_details(
app: &mut AppState,
details_tx: &mpsc::UnboundedSender<PackageItem>,
) {
let Some(vsel) = app.downgrade_state.selected() else {
return;
};
if app.downgrade_list.is_empty() || vsel >= app.downgrade_list.len() {
return;
}
if let Some(item) = app.downgrade_list.get(vsel).cloned() {
// Reset scroll when package changes
app.details_scroll = 0;
app.details_focus = Some(item.name.clone());
app.details.name.clone_from(&item.name);
app.details.version.clone_from(&item.version);
app.details.description.clear();
match &item.source {
crate::state::Source::Official { repo, arch } => {
app.details.repository.clone_from(repo);
app.details.architecture.clone_from(arch);
}
crate::state::Source::Aur => {
app.details.repository = "AUR".to_string();
app.details.architecture = "any".to_string();
}
}
if let Some(cached) = app.details_cache.get(&item.name).cloned() {
app.details = cached;
} else {
let _ = details_tx.send(item);
}
}
}
#[cfg(test)]
mod tests {
use super::*;
/// What: Produce a baseline `AppState` tailored for utils tests.
///
/// Inputs:
/// - None; relies on `Default::default()` for deterministic state.
///
/// Output:
/// - Fresh `AppState` instance for individual unit tests.
///
/// Details:
/// - Centralizes setup so each test starts from a clean copy without repeated boilerplate.
fn new_app() -> AppState {
AppState::default()
}
#[test]
/// What: Ensure `char_count` returns the number of Unicode scalar values.
///
/// Inputs:
/// - Strings `"abc"`, `"Ο"`, and `"aΟb"`.
///
/// Output:
/// - Counts `3`, `1`, and `3` respectively.
///
/// Details:
/// - Demonstrates correct handling of multi-byte characters.
fn char_count_basic() {
assert_eq!(char_count("abc"), 3);
assert_eq!(char_count("Ο"), 1);
assert_eq!(char_count("aΟb"), 3);
}
#[test]
/// What: Verify `byte_index_for_char` translates character indices to UTF-8 byte offsets.
///
/// Inputs:
/// - String `"aΟb"` with char indices 0 through 3.
///
/// Output:
/// - Returns byte offsets `0`, `1`, `3`, and `len`.
///
/// Details:
/// - Confirms the function respects variable-width encoding.
fn byte_index_for_char_basic() {
let s = "aΟb";
assert_eq!(byte_index_for_char(s, 0), 0);
assert_eq!(byte_index_for_char(s, 1), 1);
assert_eq!(byte_index_for_char(s, 2), 1 + "Ο".len());
assert_eq!(byte_index_for_char(s, 3), s.len());
}
#[test]
/// What: Ensure `find_in_recent` cycles through entries matching the pane filter.
///
/// Inputs:
/// - Recent list `alpha`, `beta`, `gamma` with filter `"a"`.
///
/// Output:
/// - Selection rotates among matching entries without panicking.
///
/// Details:
/// - Provides smoke coverage for the wrap-around logic inside the helper.
fn find_in_recent_basic() {
let mut app = new_app();
app.load_recent_items(&["alpha".to_string(), "beta".to_string(), "gamma".to_string()]);
app.pane_find = Some("a".into());
app.history_state.select(Some(0));
find_in_recent(&mut app, true);
assert!(app.history_state.selected().is_some());
}
#[test]
/// What: Check `find_in_install` advances selection to the next matching entry by name or description.
///
/// Inputs:
/// - Install list with `ripgrep` and `fd`, filter term `"rip"` while selection starts on the second item.
///
/// Output:
/// - Selection wraps to the first item containing the filter term.
///
/// Details:
/// - Protects against regressions in forward search and wrap-around behaviour.
fn find_in_install_basic() {
let mut app = new_app();
app.install_list = vec![
crate::state::PackageItem {
name: "ripgrep".into(),
version: "1".into(),
description: "fast search".into(),
source: crate::state::Source::Aur,
popularity: None,
out_of_date: None,
orphaned: false,
},
crate::state::PackageItem {
name: "fd".into(),
version: "1".into(),
description: "find".into(),
source: crate::state::Source::Aur,
popularity: None,
out_of_date: None,
orphaned: false,
},
];
app.pane_find = Some("rip".into());
// Start from visible selection 1 so advancing wraps to 0 matching "ripgrep"
app.install_state.select(Some(1));
find_in_install(&mut app, true);
assert_eq!(app.install_state.selected(), Some(0));
}
#[test]
/// What: Ensure `refresh_selected_details` dispatches a fetch when cache misses occur.
///
/// Inputs:
/// - Results list with a single entry and an empty details cache.
///
/// Output:
/// - Sends the selected item through `details_tx`, confirming a fetch request.
///
/// Details:
/// - Uses an unbounded channel to observe the request without performing actual I/O.
fn refresh_selected_details_requests_when_missing() {
let mut app = new_app();
app.results = vec![crate::state::PackageItem {
name: "rg".into(),
version: "1".into(),
description: String::new(),
source: crate::state::Source::Aur,
popularity: None,
out_of_date: None,
orphaned: false,
}];
app.selected = 0;
let (tx, mut rx) = mpsc::unbounded_channel();
refresh_selected_details(&mut app, &tx);
let got = rx.try_recv().ok();
assert!(got.is_some());
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/mod.rs | src/events/mod.rs | //! Event handling layer for Pacsea's TUI (modularized).
//!
//! This module re-exports `handle_event` and delegates pane-specific logic
//! and mouse handling to submodules to keep files small and maintainable.
use crossterm::event::{Event as CEvent, KeyCode, KeyEventKind, KeyModifiers};
use tokio::sync::mpsc;
use crate::state::{AppState, Focus, PackageItem, QueryInput};
mod distro;
mod global;
/// Install pane event handling.
mod install;
mod modals;
mod mouse;
mod preflight;
/// Recent packages event handling module.
mod recent;
mod search;
/// Utility functions for event handling.
pub mod utils;
// Re-export open_preflight_modal for use in tests and other modules
pub use search::open_preflight_modal;
/// What: Dispatch a single terminal event (keyboard/mouse) and mutate the [`AppState`].
///
/// Inputs:
/// - `ev`: Terminal event (key or mouse)
/// - `app`: Mutable application state
/// - `query_tx`: Channel to send search queries
/// - `details_tx`: Channel to request package details
/// - `preview_tx`: Channel to request preview details for Recent
/// - `add_tx`: Channel to enqueue items into the install list
/// - `pkgb_tx`: Channel to request PKGBUILD content for the current selection
///
/// Output:
/// - `true` to signal the application should exit; otherwise `false`.
///
/// Details:
/// - Handles active modal interactions first (Alert/SystemUpdate/ConfirmInstall/ConfirmRemove/Help/News).
/// - Supports global shortcuts (help overlay, theme reload, exit, PKGBUILD viewer toggle, change sort).
/// - Delegates pane-specific handling to `search`, `recent`, and `install` submodules.
#[allow(clippy::too_many_arguments)]
pub fn handle_event(
ev: &CEvent,
app: &mut AppState,
query_tx: &mpsc::UnboundedSender<QueryInput>,
details_tx: &mpsc::UnboundedSender<PackageItem>,
preview_tx: &mpsc::UnboundedSender<PackageItem>,
add_tx: &mpsc::UnboundedSender<PackageItem>,
pkgb_tx: &mpsc::UnboundedSender<PackageItem>,
comments_tx: &mpsc::UnboundedSender<String>,
) -> bool {
if let CEvent::Key(ke) = ev {
if ke.kind != KeyEventKind::Press {
return false;
}
// Log Ctrl+T for debugging
if ke.code == KeyCode::Char('t') && ke.modifiers.contains(KeyModifiers::CONTROL) {
tracing::debug!(
"[Event] Ctrl+T key event: code={:?}, mods={:?}, modal={:?}, focus={:?}",
ke.code,
ke.modifiers,
app.modal,
app.focus
);
}
// Check for global keybinds first (even when preflight is open)
// This allows global shortcuts like Ctrl+T to work regardless of modal state
if let Some(should_exit) =
global::handle_global_key(*ke, app, details_tx, pkgb_tx, comments_tx, query_tx)
{
if ke.code == KeyCode::Char('t') && ke.modifiers.contains(KeyModifiers::CONTROL) {
tracing::debug!(
"[Event] Global handler returned should_exit={}",
should_exit
);
}
if should_exit {
return true; // Exit requested
}
// Key was handled by global shortcuts, don't process further
return false;
}
// Log if Ctrl+T wasn't handled by global handler
if ke.code == KeyCode::Char('t') && ke.modifiers.contains(KeyModifiers::CONTROL) {
tracing::warn!(
"[Event] Ctrl+T was NOT handled by global handler, continuing to other handlers"
);
}
// Handle Preflight modal (it's the largest)
if matches!(app.modal, crate::state::Modal::Preflight { .. }) {
return preflight::handle_preflight_key(*ke, app);
}
// Handle all other modals
if modals::handle_modal_key(*ke, app, add_tx) {
return false;
}
// If any modal remains open after handling above, consume the key to prevent main window interaction
if !matches!(app.modal, crate::state::Modal::None) {
return false;
}
// Pane-specific handling (Search, Recent, Install)
// Recent pane focused
if matches!(app.focus, Focus::Recent) {
let should_exit =
recent::handle_recent_key(*ke, app, query_tx, details_tx, preview_tx, add_tx);
return should_exit;
}
// Install pane focused
if matches!(app.focus, Focus::Install) {
let should_exit = install::handle_install_key(*ke, app, details_tx, preview_tx, add_tx);
return should_exit;
}
// Search pane focused (delegated)
if matches!(app.focus, Focus::Search) {
let should_exit = search::handle_search_key(
*ke,
app,
query_tx,
details_tx,
add_tx,
preview_tx,
comments_tx,
);
return should_exit;
}
// Fallback: not handled
return false;
}
// Mouse handling delegated
if let CEvent::Mouse(m) = ev {
return mouse::handle_mouse_event(
*m,
app,
details_tx,
preview_tx,
add_tx,
pkgb_tx,
comments_tx,
query_tx,
);
}
false
}
#[cfg(all(test, not(target_os = "windows")))]
mod tests {
use super::*;
use crossterm::event::{
Event as CEvent, KeyCode, KeyEvent, KeyEventKind, KeyModifiers, MouseButton, MouseEvent,
MouseEventKind,
};
use std::fs;
use std::os::unix::fs::PermissionsExt;
use std::path::PathBuf;
#[test]
/// What: Ensure the system update action invokes `xfce4-terminal` with the expected command separator.
///
/// Inputs:
/// - Shimmed `xfce4-terminal` placed on `PATH`, mouse clicks to open Options β Update System, and `Enter` key event.
///
/// Output:
/// - Captured arguments begin with `--command` followed by `bash -lc ...`.
///
/// Details:
/// - Uses environment overrides plus a fake terminal script to observe the spawn command safely.
fn ui_options_update_system_enter_triggers_xfce4_args_shape() {
let _guard = crate::global_test_mutex_lock();
// fake xfce4-terminal
let mut dir: PathBuf = std::env::temp_dir();
dir.push(format!(
"pacsea_test_term_{}_{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.expect("System time is before UNIX epoch")
.as_nanos()
));
fs::create_dir_all(&dir).expect("create test directory");
let mut out_path = dir.clone();
out_path.push("args.txt");
let mut term_path = dir.clone();
term_path.push("xfce4-terminal");
let script = "#!/bin/sh\n: > \"$PACSEA_TEST_OUT\"\nfor a in \"$@\"; do printf '%s\n' \"$a\" >> \"$PACSEA_TEST_OUT\"; done\n";
fs::write(&term_path, script.as_bytes()).expect("Failed to write test terminal script");
let mut perms = fs::metadata(&term_path)
.expect("Failed to read test terminal script metadata")
.permissions();
perms.set_mode(0o755);
fs::set_permissions(&term_path, perms)
.expect("Failed to set test terminal script permissions");
let orig_path = std::env::var_os("PATH");
// Prepend our fake terminal directory to PATH to ensure xfce4-terminal is found first
let combined_path = std::env::var("PATH").map_or_else(
|_| dir.display().to_string(),
|p| format!("{}:{p}", dir.display()),
);
unsafe {
std::env::set_var("PATH", combined_path);
std::env::set_var("PACSEA_TEST_OUT", out_path.display().to_string());
std::env::set_var("PACSEA_TEST_HEADLESS", "1");
}
let mut app = AppState::default();
let (qtx, _qrx) = mpsc::unbounded_channel();
let (dtx, _drx) = mpsc::unbounded_channel();
let (ptx, _prx) = mpsc::unbounded_channel();
let (atx, _arx) = mpsc::unbounded_channel();
let (pkgb_tx, _pkgb_rx) = mpsc::unbounded_channel();
app.options_button_rect = Some((5, 5, 10, 1));
let click_options = CEvent::Mouse(MouseEvent {
kind: MouseEventKind::Down(MouseButton::Left),
column: 6,
row: 5,
modifiers: KeyModifiers::empty(),
});
let (comments_tx, _comments_rx) = mpsc::unbounded_channel::<String>();
let _ = super::handle_event(
&click_options,
&mut app,
&qtx,
&dtx,
&ptx,
&atx,
&pkgb_tx,
&comments_tx,
);
assert!(app.options_menu_open);
app.options_menu_rect = Some((5, 6, 20, 3));
let click_menu_update = CEvent::Mouse(MouseEvent {
kind: MouseEventKind::Down(MouseButton::Left),
column: 6,
row: 7,
modifiers: KeyModifiers::empty(),
});
let (comments_tx, _comments_rx) = mpsc::unbounded_channel::<String>();
let _ = super::handle_event(
&click_menu_update,
&mut app,
&qtx,
&dtx,
&ptx,
&atx,
&pkgb_tx,
&comments_tx,
);
let enter = CEvent::Key(KeyEvent::new(KeyCode::Enter, KeyModifiers::empty()));
let (comments_tx, _comments_rx) = mpsc::unbounded_channel::<String>();
let _ = super::handle_event(
&enter,
&mut app,
&qtx,
&dtx,
&ptx,
&atx,
&pkgb_tx,
&comments_tx,
);
// Wait for file to be created with retries
let mut attempts = 0;
while !out_path.exists() && attempts < 50 {
std::thread::sleep(std::time::Duration::from_millis(10));
attempts += 1;
}
// Give the process time to complete writing to avoid race conditions with other tests
std::thread::sleep(std::time::Duration::from_millis(100));
let body = fs::read_to_string(&out_path).expect("fake terminal args file written");
let lines: Vec<&str> = body.lines().collect();
// Verify that xfce4-terminal was actually used by checking for --command argument
// (xfce4-terminal is the only terminal that uses --command format)
// Find the last --command to handle cases where multiple spawns might have occurred
let command_idx = lines.iter().rposition(|&l| l == "--command");
if command_idx.is_none() {
// If --command wasn't found, xfce4-terminal wasn't used (another terminal was chosen)
// This can happen when other terminals are on PATH and chosen first
eprintln!(
"Warning: xfce4-terminal was not used (no --command found, got: {lines:?}), skipping xfce4-specific assertion"
);
unsafe {
if let Some(v) = orig_path {
std::env::set_var("PATH", v);
} else {
std::env::remove_var("PATH");
}
std::env::remove_var("PACSEA_TEST_OUT");
}
return;
}
let command_idx = command_idx.expect("command_idx should be Some after is_none() check");
assert!(
command_idx + 1 < lines.len(),
"--command found at index {command_idx} but no following argument. Lines: {lines:?}"
);
assert!(
lines[command_idx + 1].starts_with("bash -lc "),
"Expected argument after --command to start with 'bash -lc ', got: '{}'. All lines: {:?}",
lines[command_idx + 1],
lines
);
unsafe {
if let Some(v) = orig_path {
std::env::set_var("PATH", v);
} else {
std::env::remove_var("PATH");
}
std::env::remove_var("PACSEA_TEST_OUT");
}
}
#[test]
/// What: Validate optional dependency rows reflect installed editors/terminals and X11-specific tooling.
///
/// Inputs:
/// - Temporary `PATH` exposing `nvim` and `kitty`, with `WAYLAND_DISPLAY` cleared to emulate X11.
///
/// Output:
/// - Optional deps list shows installed entries as non-selectable and missing tooling as selectable rows for clipboard/mirror/AUR helpers.
///
/// Details:
/// - Drives the Options menu to render optional dependencies while observing row attributes.
fn optional_deps_rows_reflect_installed_and_x11_and_reflector() {
let _guard = crate::global_test_mutex_lock();
let (dir, orig_path, orig_wl) = setup_test_executables();
let (mut app, channels) = setup_app_with_translations();
open_optional_deps_modal(&mut app, &channels);
verify_optional_deps_rows(&app.modal);
teardown_test_environment(orig_path, orig_wl, &dir);
}
/// What: Setup test executables and environment for optional deps test.
///
/// Inputs: None.
///
/// Output:
/// - Returns (`temp_dir`, `original_path`, `original_wayland_display`) for cleanup.
///
/// Details:
/// - Creates `nvim` and `kitty` executables, sets `PATH`, clears `WAYLAND_DISPLAY`.
fn setup_test_executables() -> (
std::path::PathBuf,
Option<std::ffi::OsString>,
Option<std::ffi::OsString>,
) {
use std::fs;
use std::os::unix::fs::PermissionsExt;
use std::path::PathBuf;
let mut dir: PathBuf = std::env::temp_dir();
dir.push(format!(
"pacsea_test_optional_deps_{}_{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.expect("System time is before UNIX epoch")
.as_nanos()
));
let _ = fs::create_dir_all(&dir);
let make_exec = |name: &str| {
let mut p = dir.clone();
p.push(name);
fs::write(&p, b"#!/bin/sh\nexit 0\n").expect("Failed to write test executable stub");
let mut perms = fs::metadata(&p)
.expect("Failed to read test executable stub metadata")
.permissions();
perms.set_mode(0o755);
fs::set_permissions(&p, perms).expect("Failed to set test executable stub permissions");
};
make_exec("nvim");
make_exec("kitty");
let orig_path = std::env::var_os("PATH");
unsafe {
std::env::set_var("PATH", dir.display().to_string());
std::env::set_var("PACSEA_TEST_HEADLESS", "1");
};
let orig_wl = std::env::var_os("WAYLAND_DISPLAY");
unsafe { std::env::remove_var("WAYLAND_DISPLAY") };
(dir, orig_path, orig_wl)
}
/// Type alias for application communication channels tuple.
///
/// Contains 6 `UnboundedSender` channels for query, details, preview, add, pkgbuild, and comments operations.
type AppChannels = (
tokio::sync::mpsc::UnboundedSender<QueryInput>,
tokio::sync::mpsc::UnboundedSender<PackageItem>,
tokio::sync::mpsc::UnboundedSender<PackageItem>,
tokio::sync::mpsc::UnboundedSender<PackageItem>,
tokio::sync::mpsc::UnboundedSender<PackageItem>,
tokio::sync::mpsc::UnboundedSender<String>,
);
/// Type alias for setup app result tuple.
///
/// Contains `AppState` and `AppChannels`.
type SetupAppResult = (AppState, AppChannels);
/// What: Setup app state with translations and return channels.
///
/// Inputs: None.
///
/// Output:
/// - Returns (`app_state`, `channels` tuple).
///
/// Details:
/// - Initializes translations for optional deps categories.
fn setup_app_with_translations() -> SetupAppResult {
use std::collections::HashMap;
let mut app = AppState::default();
let mut translations = HashMap::new();
translations.insert(
"app.optional_deps.categories.editor".to_string(),
"Editor".to_string(),
);
translations.insert(
"app.optional_deps.categories.terminal".to_string(),
"Terminal".to_string(),
);
translations.insert(
"app.optional_deps.categories.clipboard".to_string(),
"Clipboard".to_string(),
);
translations.insert(
"app.optional_deps.categories.aur_helper".to_string(),
"AUR Helper".to_string(),
);
translations.insert(
"app.optional_deps.categories.security".to_string(),
"Security".to_string(),
);
app.translations.clone_from(&translations);
app.translations_fallback = translations;
let (qtx, _qrx) = mpsc::unbounded_channel();
let (dtx, _drx) = mpsc::unbounded_channel();
let (ptx, _prx) = mpsc::unbounded_channel();
let (atx, _arx) = mpsc::unbounded_channel();
let (pkgb_tx, _pkgb_rx) = mpsc::unbounded_channel();
let (comments_tx, _comments_rx) = mpsc::unbounded_channel();
(app, (qtx, dtx, ptx, atx, pkgb_tx, comments_tx))
}
/// What: Open optional deps modal via UI interactions.
///
/// Inputs:
/// - `app`: Mutable application state
/// - `channels`: Tuple of channel senders for event handling
///
/// Output: None (modifies app state).
///
/// Details:
/// - Clicks options button, then presses '4' to open Optional Deps.
fn open_optional_deps_modal(app: &mut AppState, channels: &AppChannels) {
app.options_button_rect = Some((5, 5, 12, 1));
let click_options = CEvent::Mouse(crossterm::event::MouseEvent {
kind: crossterm::event::MouseEventKind::Down(crossterm::event::MouseButton::Left),
column: 6,
row: 5,
modifiers: KeyModifiers::empty(),
});
let _ = super::handle_event(
&click_options,
app,
&channels.0,
&channels.1,
&channels.2,
&channels.3,
&channels.4,
&channels.5,
);
assert!(app.options_menu_open);
// In Package mode, TUI Optional Deps is at index 3 (key '3')
// In News mode, TUI Optional Deps is at index 2 (key '2')
// Since tests default to Package mode, use '3'
let mut key_three_event =
crossterm::event::KeyEvent::new(KeyCode::Char('3'), KeyModifiers::empty());
key_three_event.kind = KeyEventKind::Press;
let key_three = CEvent::Key(key_three_event);
let _ = super::handle_event(
&key_three,
app,
&channels.0,
&channels.1,
&channels.2,
&channels.3,
&channels.4,
&channels.5,
);
}
/// What: Verify optional deps rows match expected state.
///
/// Inputs:
/// - `modal`: Modal state to verify
///
/// Output: None (panics on assertion failure).
///
/// Details:
/// - Checks editor, terminal, clipboard, mirrors, and AUR helper rows.
fn verify_optional_deps_rows(modal: &crate::state::Modal) {
match modal {
crate::state::Modal::OptionalDeps { rows, .. } => {
let find = |prefix: &str| rows.iter().find(|r| r.label.starts_with(prefix));
let ed = find("Editor: nvim").expect("editor row nvim");
assert!(ed.installed, "nvim should be marked installed");
assert!(!ed.selectable, "installed editor should not be selectable");
let term = find("Terminal: kitty").expect("terminal row kitty");
assert!(term.installed, "kitty should be marked installed");
assert!(
!term.selectable,
"installed terminal should not be selectable"
);
let clip = find("Clipboard: xclip").expect("clipboard xclip row");
assert!(
!clip.installed,
"xclip should not appear installed by default"
);
assert!(
clip.selectable,
"xclip should be selectable when not installed"
);
assert_eq!(clip.note.as_deref(), Some("X11"));
let mirrors = find("Mirrors: reflector").expect("reflector row");
assert!(
!mirrors.installed,
"reflector should not be installed by default"
);
assert!(mirrors.selectable, "reflector should be selectable");
let paru = find("AUR Helper: paru").expect("paru row");
assert!(!paru.installed);
assert!(paru.selectable);
let yay = find("AUR Helper: yay").expect("yay row");
assert!(!yay.installed);
assert!(yay.selectable);
}
other => panic!("Expected OptionalDeps modal, got {other:?}"),
}
}
/// What: Restore environment and cleanup test directory.
///
/// Inputs:
/// - `orig_path`: Original `PATH` value to restore
/// - `orig_wl`: Original `WAYLAND_DISPLAY` value to restore
/// - `dir`: Temporary directory to remove
///
/// Output: None.
///
/// Details:
/// - Restores `PATH` and `WAYLAND_DISPLAY`, removes temp directory.
fn teardown_test_environment(
orig_path: Option<std::ffi::OsString>,
orig_wl: Option<std::ffi::OsString>,
dir: &std::path::PathBuf,
) {
unsafe {
if let Some(v) = orig_path {
std::env::set_var("PATH", v);
} else {
std::env::remove_var("PATH");
}
if let Some(v) = orig_wl {
std::env::set_var("WAYLAND_DISPLAY", v);
} else {
std::env::remove_var("WAYLAND_DISPLAY");
}
}
let _ = std::fs::remove_dir_all(dir);
}
#[test]
/// What: Optional Deps shows Wayland clipboard (`wl-clipboard`) when `WAYLAND_DISPLAY` is set
///
/// - Setup: Empty PATH; set `WAYLAND_DISPLAY`
/// - Expect: A row "Clipboard: wl-clipboard" with note "Wayland", not installed and selectable
fn optional_deps_rows_wayland_shows_wl_clipboard() {
use std::collections::HashMap;
use std::fs;
use std::path::PathBuf;
let _guard = crate::global_test_mutex_lock();
// Temp PATH directory (empty)
let mut dir: PathBuf = std::env::temp_dir();
dir.push(format!(
"pacsea_test_optional_deps_wl_{}_{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.expect("System time is before UNIX epoch")
.as_nanos()
));
let _ = fs::create_dir_all(&dir);
let orig_path = std::env::var_os("PATH");
unsafe {
std::env::set_var("PATH", dir.display().to_string());
std::env::set_var("PACSEA_TEST_HEADLESS", "1");
};
let orig_wl = std::env::var_os("WAYLAND_DISPLAY");
unsafe { std::env::set_var("WAYLAND_DISPLAY", "1") };
let mut app = AppState::default();
// Initialize i18n translations for optional deps
let mut translations = HashMap::new();
translations.insert(
"app.optional_deps.categories.editor".to_string(),
"Editor".to_string(),
);
translations.insert(
"app.optional_deps.categories.terminal".to_string(),
"Terminal".to_string(),
);
translations.insert(
"app.optional_deps.categories.clipboard".to_string(),
"Clipboard".to_string(),
);
translations.insert(
"app.optional_deps.categories.aur_helper".to_string(),
"AUR Helper".to_string(),
);
translations.insert(
"app.optional_deps.categories.security".to_string(),
"Security".to_string(),
);
app.translations.clone_from(&translations);
app.translations_fallback = translations;
let (qtx, _qrx) = mpsc::unbounded_channel();
let (dtx, _drx) = mpsc::unbounded_channel();
let (ptx, _prx) = mpsc::unbounded_channel();
let (atx, _arx) = mpsc::unbounded_channel();
let (pkgb_tx, _pkgb_rx) = mpsc::unbounded_channel();
// Open Options via click
app.options_button_rect = Some((5, 5, 12, 1));
let click_options = CEvent::Mouse(crossterm::event::MouseEvent {
kind: crossterm::event::MouseEventKind::Down(crossterm::event::MouseButton::Left),
column: 6,
row: 5,
modifiers: KeyModifiers::empty(),
});
let (comments_tx, _comments_rx) = mpsc::unbounded_channel::<String>();
let _ = super::handle_event(
&click_options,
&mut app,
&qtx,
&dtx,
&ptx,
&atx,
&pkgb_tx,
&comments_tx,
);
assert!(app.options_menu_open);
// Press '3' to open Optional Deps (Package mode: List installed=1, Update system=2, TUI Optional Deps=3, News management=4)
let mut key_three_event =
crossterm::event::KeyEvent::new(KeyCode::Char('3'), KeyModifiers::empty());
key_three_event.kind = KeyEventKind::Press;
let key_three = CEvent::Key(key_three_event);
let (comments_tx, _comments_rx) = mpsc::unbounded_channel::<String>();
let _ = super::handle_event(
&key_three,
&mut app,
&qtx,
&dtx,
&ptx,
&atx,
&pkgb_tx,
&comments_tx,
);
match &app.modal {
crate::state::Modal::OptionalDeps { rows, .. } => {
let clip = rows
.iter()
.find(|r| r.label.starts_with("Clipboard: wl-clipboard"))
.expect("wl-clipboard row");
assert_eq!(clip.note.as_deref(), Some("Wayland"));
assert!(!clip.installed);
assert!(clip.selectable);
// Ensure xclip is not presented when Wayland is active
assert!(
!rows.iter().any(|r| r.label.starts_with("Clipboard: xclip")),
"xclip should not be listed on Wayland"
);
}
other => panic!("Expected OptionalDeps modal, got {other:?}"),
}
// Restore env and cleanup
unsafe {
if let Some(v) = orig_path {
std::env::set_var("PATH", v);
} else {
std::env::remove_var("PATH");
}
if let Some(v) = orig_wl {
std::env::set_var("WAYLAND_DISPLAY", v);
} else {
std::env::remove_var("WAYLAND_DISPLAY");
}
}
let _ = fs::remove_dir_all(&dir);
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/recent.rs | src/events/recent.rs | use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
use tokio::sync::mpsc;
use crate::logic::send_query;
use crate::state::{AppState, PackageItem, QueryInput};
use super::utils::{char_count, find_in_recent, matches_any, refresh_selected_details};
/// What: Handle key events while in pane-find mode for the Recent pane.
///
/// Inputs:
/// - `ke`: Key event received from the terminal
/// - `app`: Mutable application state
/// - `preview_tx`: Channel to request preview of the selected recent item
///
/// Output:
/// - `true` if the key was handled, `false` otherwise
///
/// Details:
/// - Handles Enter (jump to next match), Esc (exit find mode), Backspace (delete char), and Char (append char).
fn handle_recent_find_mode(
ke: &KeyEvent,
app: &mut AppState,
preview_tx: &mpsc::UnboundedSender<PackageItem>,
) -> bool {
match ke.code {
KeyCode::Enter => {
find_in_recent(app, true);
crate::ui::helpers::trigger_recent_preview(app, preview_tx);
}
KeyCode::Esc => {
app.pane_find = None;
}
KeyCode::Backspace => {
if let Some(buf) = &mut app.pane_find {
buf.pop();
}
}
KeyCode::Char(ch) => {
if let Some(buf) = &mut app.pane_find {
buf.push(ch);
}
}
_ => return false,
}
true
}
/// What: Move selection in the Recent pane up or down.
///
/// Inputs:
/// - `app`: Mutable application state
/// - `down`: `true` to move down, `false` to move up
/// - `preview_tx`: Channel to request preview of the selected recent item
///
/// Output:
/// - `true` if selection was moved, `false` if the list is empty
///
/// Details:
/// - Moves selection within the filtered view and triggers preview.
fn move_recent_selection(
app: &mut AppState,
down: bool,
preview_tx: &mpsc::UnboundedSender<PackageItem>,
) -> bool {
let inds = crate::ui::helpers::filtered_recent_indices(app);
if inds.is_empty() {
return false;
}
let sel = app.history_state.selected().unwrap_or(0);
let max = inds.len().saturating_sub(1);
let new = if down {
std::cmp::min(sel + 1, max)
} else {
sel.saturating_sub(1)
};
app.history_state.select(Some(new));
crate::ui::helpers::trigger_recent_preview(app, preview_tx);
true
}
/// What: Transition focus from Recent pane to Search pane.
///
/// Inputs:
/// - `app`: Mutable application state
/// - `details_tx`: Channel to request details when focus moves back to Search
/// - `activate_normal_mode`: If `true`, activate Search Normal mode
///
/// Output:
/// - None (modifies app state directly)
///
/// Details:
/// - Switches focus to Search and refreshes details for the selected result.
fn transition_to_search(
app: &mut AppState,
details_tx: &mpsc::UnboundedSender<PackageItem>,
activate_normal_mode: bool,
) {
app.focus = crate::state::Focus::Search;
if activate_normal_mode {
app.search_normal_mode = true;
}
if !matches!(app.app_mode, crate::state::types::AppMode::News) {
refresh_selected_details(app, details_tx);
}
}
/// What: Handle wrap-around navigation from Recent (leftmost) to Install (rightmost) pane.
///
/// Inputs:
/// - `app`: Mutable application state
/// - `details_tx`: Channel to request details for the focused item
///
/// Output:
/// - None (modifies app state directly)
///
/// Details:
/// - In installed-only mode, lands on the Remove subpane when wrapping.
/// - Otherwise, lands on the Install list.
fn handle_recent_to_install_wrap(
app: &mut AppState,
details_tx: &mpsc::UnboundedSender<PackageItem>,
) {
if matches!(app.app_mode, crate::state::types::AppMode::News) {
app.focus = crate::state::Focus::Install;
} else if app.installed_only_mode {
// In installed-only mode, land on the Remove subpane when wrapping
app.right_pane_focus = crate::state::RightPaneFocus::Remove;
if app.remove_state.selected().is_none() && !app.remove_list.is_empty() {
app.remove_state.select(Some(0));
}
app.focus = crate::state::Focus::Install;
super::utils::refresh_remove_details(app, details_tx);
} else {
if app.install_state.selected().is_none() && !app.install_list.is_empty() {
app.install_state.select(Some(0));
}
app.focus = crate::state::Focus::Install;
super::utils::refresh_install_details(app, details_tx);
}
}
/// What: Clear all entries from the Recent list.
///
/// Inputs:
/// - `app`: Mutable application state
///
/// Output:
/// - None (modifies app state directly)
///
/// Details:
/// - Clears the recent list, deselects any item, and marks the list as dirty.
fn clear_recent_list(app: &mut AppState) {
if matches!(app.app_mode, crate::state::types::AppMode::News) {
app.news_recent.clear();
app.history_state.select(None);
app.news_recent_dirty = true;
} else {
app.recent.clear();
app.history_state.select(None);
app.recent_dirty = true;
}
}
/// What: Remove the currently selected item from the Recent list.
///
/// Inputs:
/// - `app`: Mutable application state
/// - `preview_tx`: Channel to request preview of the selected recent item
///
/// Output:
/// - `true` if an item was removed, `false` if the list is empty or no item is selected
///
/// Details:
/// - Removes the selected item and adjusts selection to remain valid.
fn remove_recent_item(app: &mut AppState, preview_tx: &mpsc::UnboundedSender<PackageItem>) -> bool {
let inds = crate::ui::helpers::filtered_recent_indices(app);
if inds.is_empty() {
return false;
}
let Some(vsel) = app.history_state.selected() else {
return false;
};
let i = inds.get(vsel).copied().unwrap_or(0);
let removed = if matches!(app.app_mode, crate::state::types::AppMode::News) {
let res = app.remove_news_recent_at(i).is_some();
if res {
app.news_recent_dirty = true;
}
res
} else {
let res = app.remove_recent_at(i).is_some();
if res {
app.recent_dirty = true;
}
res
};
if !removed {
return false;
}
let vis_len = inds.len().saturating_sub(1); // now one less visible
if vis_len == 0 {
app.history_state.select(None);
} else {
let new_sel = if vsel >= vis_len { vis_len - 1 } else { vsel };
app.history_state.select(Some(new_sel));
if !matches!(app.app_mode, crate::state::types::AppMode::News) {
crate::ui::helpers::trigger_recent_preview(app, preview_tx);
}
}
true
}
/// What: Get the selected recent query string.
///
/// Inputs:
/// - `app`: Application state
///
/// Output:
/// - `Some(String)` if a valid selection exists, `None` otherwise
///
/// Details:
/// - Returns the query string at the currently selected visible index.
fn get_selected_recent_query(app: &AppState) -> Option<String> {
let inds = crate::ui::helpers::filtered_recent_indices(app);
if inds.is_empty() {
return None;
}
let vsel = app.history_state.selected()?;
let i = inds.get(vsel).copied()?;
if matches!(app.app_mode, crate::state::types::AppMode::News) {
app.news_recent_value_at(i)
} else {
app.recent_value_at(i)
}
}
/// What: Handle Enter key to use the selected recent query.
///
/// Inputs:
/// - `app`: Mutable application state
/// - `query_tx`: Channel to send a new query to Search
///
/// Output:
/// - `true` if a query was used, `false` if no valid selection exists
///
/// Details:
/// - Copies the selected recent query into Search, positions caret at end, and triggers a new search.
fn handle_recent_enter(app: &mut AppState, query_tx: &mpsc::UnboundedSender<QueryInput>) -> bool {
let Some(q) = get_selected_recent_query(app) else {
return false;
};
app.focus = crate::state::Focus::Search;
app.last_input_change = std::time::Instant::now();
app.last_saved_value = None;
if matches!(app.app_mode, crate::state::types::AppMode::News) {
app.news_search_input = q;
app.news_search_caret = char_count(&app.news_search_input);
app.news_search_select_anchor = None;
app.refresh_news_results();
} else {
app.input = q;
// Position caret at end and clear selection
app.search_caret = char_count(&app.input);
app.search_select_anchor = None;
send_query(app, query_tx);
}
true
}
/// What: Handle Space key to add the selected recent query as a best-effort match to install list.
///
/// Inputs:
/// - `app`: Application state
/// - `add_tx`: Channel to enqueue adding a best-effort match to the install list
///
/// Output:
/// - `true` if a task was spawned, `false` if no valid selection exists
///
/// Details:
/// - Asynchronously resolves a best-effort match and enqueues it to the install list.
fn handle_recent_space(app: &AppState, add_tx: &mpsc::UnboundedSender<PackageItem>) -> bool {
if matches!(app.app_mode, crate::state::types::AppMode::News) {
return false;
}
let Some(q) = get_selected_recent_query(app) else {
return false;
};
let tx = add_tx.clone();
tokio::spawn(async move {
if let Some(item) = crate::ui::helpers::fetch_first_match_for_query(q).await {
let _ = tx.send(item);
}
});
true
}
/// What: Handle key events while the Recent pane (left column) is focused.
///
/// Inputs:
/// - `ke`: Key event received from the terminal
/// - `app`: Mutable application state (recent list, selection, find pattern)
/// - `query_tx`: Channel to send a new query to Search when Enter is pressed
/// - `details_tx`: Channel to request details when focus moves back to Search
/// - `preview_tx`: Channel to request preview of the selected recent item
/// - `add_tx`: Channel to enqueue adding a best-effort match to the install list
///
/// Output:
/// - `true` to request application exit (e.g., Ctrl+C); `false` to continue.
///
/// Details:
/// - In-pane find: `/` enters find mode; typing edits the pattern; Enter jumps to next match;
/// Esc cancels. Matches are case-insensitive on recent query strings.
/// - Navigation: `j/k` or `Down/Up` move selection within the filtered view and trigger preview.
/// - Use item: `Enter` copies the selected recent query into Search and triggers a new search.
/// - Add item: Space resolves a best-effort match asynchronously and enqueues it to install list.
/// - Removal: Configured keys (`recent_remove`/`recent_clear`) remove one/all entries.
pub fn handle_recent_key(
ke: KeyEvent,
app: &mut AppState,
query_tx: &mpsc::UnboundedSender<QueryInput>,
details_tx: &mpsc::UnboundedSender<PackageItem>,
preview_tx: &mpsc::UnboundedSender<PackageItem>,
add_tx: &mpsc::UnboundedSender<PackageItem>,
) -> bool {
// Allow exiting with Ctrl+C while in Recent pane
if ke.code == KeyCode::Char('c') && ke.modifiers.contains(KeyModifiers::CONTROL) {
return true;
}
// Pane-search mode first
if app.pane_find.is_some() && handle_recent_find_mode(&ke, app, preview_tx) {
return false; // Key was handled in find mode
}
// Handle Shift+char keybinds (menus, import, export, updates, status) that work in all modes
if crate::events::search::handle_shift_keybinds(&ke, app) {
return false;
}
let km = &app.keymap;
match ke.code {
KeyCode::Char('j') | KeyCode::Down => {
move_recent_selection(app, true, preview_tx);
}
KeyCode::Char('k') | KeyCode::Up => {
move_recent_selection(app, false, preview_tx);
}
KeyCode::Char('/') => {
app.pane_find = Some(String::new());
}
KeyCode::Esc => {
transition_to_search(app, details_tx, true);
}
code if matches_any(&ke, &km.pane_next) && code == ke.code => {
transition_to_search(app, details_tx, false);
}
KeyCode::Left => {
handle_recent_to_install_wrap(app, details_tx);
}
KeyCode::Right => {
transition_to_search(app, details_tx, false);
}
code if matches_any(&ke, &km.recent_clear) && code == ke.code => {
clear_recent_list(app);
}
code if matches_any(&ke, &km.recent_remove) && code == ke.code => {
remove_recent_item(app, preview_tx);
}
KeyCode::Char(' ') => {
handle_recent_space(app, add_tx);
}
KeyCode::Enter => {
handle_recent_enter(app, query_tx);
}
_ => {}
}
false
}
#[cfg(test)]
mod tests {
use super::*;
/// What: Provide a fresh `AppState` tailored for recent-pane tests without repeated boilerplate.
///
/// Inputs:
/// - None (relies on `Default::default()` for deterministic initial state).
///
/// Output:
/// - New `AppState` ready for mutating within individual recent-pane scenarios.
///
/// Details:
/// - Keeps tests concise by centralizing setup of the baseline application state.
fn new_app() -> AppState {
AppState::default()
}
#[test]
/// What: Exercise recent-pane find mode from entry through exit.
///
/// Inputs:
/// - Key sequence `'/ '`, `'a'`, `Enter`, `Esc` routed through the handler.
///
/// Output:
/// - `pane_find` initialises, captures search text, Enter triggers preview, and Escape clears the mode.
///
/// Details:
/// - Verifies the state transitions without asserting on query side-effects.
fn recent_pane_find_flow() {
let mut app = new_app();
let (qtx, _qrx) = mpsc::unbounded_channel::<QueryInput>();
let (dtx, _drx) = mpsc::unbounded_channel::<PackageItem>();
let (ptx, _prx) = mpsc::unbounded_channel::<PackageItem>();
let (atx, _arx) = mpsc::unbounded_channel::<PackageItem>();
// Enter find mode
let _ = handle_recent_key(
KeyEvent::new(KeyCode::Char('/'), KeyModifiers::empty()),
&mut app,
&qtx,
&dtx,
&ptx,
&atx,
);
assert_eq!(app.pane_find.as_deref(), Some(""));
// Type 'a'
let _ = handle_recent_key(
KeyEvent::new(KeyCode::Char('a'), KeyModifiers::empty()),
&mut app,
&qtx,
&dtx,
&ptx,
&atx,
);
assert_eq!(app.pane_find.as_deref(), Some("a"));
// Press Enter
let _ = handle_recent_key(
KeyEvent::new(KeyCode::Enter, KeyModifiers::empty()),
&mut app,
&qtx,
&dtx,
&ptx,
&atx,
);
// Exit find with Esc
let _ = handle_recent_key(
KeyEvent::new(KeyCode::Esc, KeyModifiers::empty()),
&mut app,
&qtx,
&dtx,
&ptx,
&atx,
);
assert!(app.pane_find.is_none());
}
#[test]
/// What: Confirm Enter on a recent entry restores the search query and emits a request.
///
/// Inputs:
/// - Recent list with a single item selected and an `Enter` key event.
///
/// Output:
/// - Focus switches to `Search`, the input field reflects the selection, and a query message is queued.
///
/// Details:
/// - Uses unbounded channels to capture the emitted query without running async tasks.
fn recent_enter_uses_query() {
let mut app = new_app();
app.load_recent_items(&["ripgrep".to_string()]);
app.history_state.select(Some(0));
let (qtx, mut qrx) = mpsc::unbounded_channel::<QueryInput>();
let (dtx, _drx) = mpsc::unbounded_channel::<PackageItem>();
let (ptx, _prx) = mpsc::unbounded_channel::<PackageItem>();
let (atx, _arx) = mpsc::unbounded_channel::<PackageItem>();
let _ = handle_recent_key(
KeyEvent::new(KeyCode::Enter, KeyModifiers::empty()),
&mut app,
&qtx,
&dtx,
&ptx,
&atx,
);
assert!(matches!(app.focus, crate::state::Focus::Search));
let msg = qrx.try_recv().ok();
assert!(msg.is_some());
assert_eq!(app.input, "ripgrep");
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/distro.rs | src/events/distro.rs | //! Distro-specific helpers for events layer.
/// What: Build a shell snippet to refresh pacman mirrors depending on the detected distro.
///
/// Inputs:
/// - `countries`: Either "Worldwide" to auto-rank mirrors, or a comma-separated list used by the underlying tool
/// - `count`: Mirror count used by Manjaro fasttrack when `countries` is "Worldwide", or top mirrors number for Artix rate-mirrors
///
/// Output:
/// - Shell command string suitable to run in a terminal
///
/// Details:
/// - On Manjaro (detected via /etc/os-release), ensures pacman-mirrors exists, then:
/// - Worldwide: `pacman-mirrors --fasttrack {count}`
/// - Countries: `pacman-mirrors --method rank --country '{countries}'`
/// - On `Artix` (detected via /etc/os-release), checks for rate-mirrors and `AUR` helper (`yay`/`paru`), prompts for installation if needed, creates backup of mirrorlist, then runs rate-mirrors with country filtering using --entry-country option (only one country allowed, global option must come before the artix command).
/// - On `EndeavourOS`, ensures `eos-rankmirrors` is installed, runs it, then runs `reflector`.
/// - On `CachyOS`, ensures `cachyos-rate-mirrors` is installed, runs it, then runs `reflector`.
/// - Otherwise, attempts to use `reflector` to write `/etc/pacman.d/mirrorlist`; if not found, prints a notice.
pub fn mirror_update_command(countries: &str, count: u16) -> String {
if countries.eq("Worldwide") {
format!(
"(if grep -q 'Manjaro' /etc/os-release 2>/dev/null; then \
((command -v pacman-mirrors >/dev/null 2>&1) || sudo pacman -Qi pacman-mirrors >/dev/null 2>&1 || sudo pacman -S --needed --noconfirm pacman-mirrors) && \
sudo pacman-mirrors --fasttrack {count}; \
elif grep -q 'EndeavourOS' /etc/os-release 2>/dev/null; then \
((command -v eos-rankmirrors >/dev/null 2>&1) || sudo pacman -Qi eos-rankmirrors >/dev/null 2>&1 || sudo pacman -S --needed --noconfirm eos-rankmirrors) && sudo eos-rankmirrors || echo 'eos-rankmirrors failed'; \
(command -v reflector >/dev/null 2>&1 && sudo reflector --verbose --protocol https --sort rate --latest 20 --download-timeout 6 --save /etc/pacman.d/mirrorlist) || echo 'reflector not found; skipping mirror update'; \
elif grep -q 'CachyOS' /etc/os-release 2>/dev/null; then \
((command -v cachyos-rate-mirrors >/dev/null 2>&1) || sudo pacman -Qi cachyos-rate-mirrors >/dev/null 2>&1 || sudo pacman -S --needed --noconfirm cachyos-rate-mirrors) && sudo cachyos-rate-mirrors || echo 'cachyos-rate-mirrors failed'; \
(command -v reflector >/dev/null 2>&1 && sudo reflector --verbose --protocol https --sort rate --latest 20 --download-timeout 6 --save /etc/pacman.d/mirrorlist) || echo 'reflector not found; skipping mirror update'; \
elif grep -q 'Artix' /etc/os-release 2>/dev/null; then \
if ! (sudo pacman -Qi rate-mirrors >/dev/null 2>&1 || command -v rate-mirrors >/dev/null 2>&1); then \
if ! (sudo pacman -Qi paru >/dev/null 2>&1 || command -v paru >/dev/null 2>&1) && ! (sudo pacman -Qi yay >/dev/null 2>&1 || command -v yay >/dev/null 2>&1); then \
echo 'Error: rate-mirrors is not installed and no AUR helper (yay/paru) found.'; \
echo 'Please install yay or paru first, or install rate-mirrors manually.'; \
exit 1; \
fi; \
echo 'rate-mirrors is not installed.'; \
read -rp 'Do you want to install rate-mirrors from AUR? (y/n): ' install_choice; \
if [ \"$install_choice\" != \"y\" ] && [ \"$install_choice\" != \"Y\" ]; then \
echo 'Mirror update cancelled.'; \
exit 1; \
fi; \
if sudo pacman -Qi paru >/dev/null 2>&1 || command -v paru >/dev/null 2>&1; then \
paru -S --needed --noconfirm rate-mirrors || exit 1; \
elif sudo pacman -Qi yay >/dev/null 2>&1 || command -v yay >/dev/null 2>&1; then \
yay -S --needed --noconfirm rate-mirrors || exit 1; \
fi; \
fi; \
sudo cp /etc/pacman.d/mirrorlist /etc/pacman.d/mirrorlist.backup.$(date +%Y%m%d_%H%M%S) || exit 1; \
if [ \"{countries}\" = \"Worldwide\" ]; then \
rate-mirrors --protocol=https --allow-root --country-neighbors-per-country=3 --top-mirrors-number-to-retest={count} --max-jumps=10 artix | sudo tee /etc/pacman.d/mirrorlist || exit 1; \
else \
country_count=$(echo '{countries}' | tr ',' '\\n' | wc -l); \
if [ \"$country_count\" -ne 1 ]; then \
echo 'Error: Only one country is allowed for Artix mirror update.'; \
echo 'Please select a single country.'; \
exit 1; \
fi; \
rate-mirrors --protocol=https --allow-root --entry-country='{countries}' --country-neighbors-per-country=3 --top-mirrors-number-to-retest={count} --max-jumps=10 artix | sudo tee /etc/pacman.d/mirrorlist || exit 1; \
fi; \
else \
(command -v reflector >/dev/null 2>&1 && sudo reflector --verbose --protocol https --sort rate --latest 20 --download-timeout 6 --save /etc/pacman.d/mirrorlist) || echo 'reflector not found; skipping mirror update'; \
fi)"
)
} else {
format!(
"(if grep -q 'Manjaro' /etc/os-release 2>/dev/null; then \
((command -v pacman-mirrors >/dev/null 2>&1) || sudo pacman -Qi pacman-mirrors >/dev/null 2>&1 || sudo pacman -S --needed --noconfirm pacman-mirrors) && \
sudo pacman-mirrors --method rank --country '{countries}'; \
elif grep -q 'EndeavourOS' /etc/os-release 2>/dev/null; then \
((command -v eos-rankmirrors >/dev/null 2>&1) || sudo pacman -Qi eos-rankmirrors >/dev/null 2>&1 || sudo pacman -S --needed --noconfirm eos-rankmirrors) && sudo eos-rankmirrors || echo 'eos-rankmirrors failed'; \
(command -v reflector >/dev/null 2>&1 && sudo reflector --verbose --country '{countries}' --protocol https --sort rate --latest 20 --download-timeout 6 --save /etc/pacman.d/mirrorlist) || echo 'reflector not found; skipping mirror update'; \
elif grep -q 'CachyOS' /etc/os-release 2>/dev/null; then \
((command -v cachyos-rate-mirrors >/dev/null 2>&1) || sudo pacman -Qi cachyos-rate-mirrors >/dev/null 2>&1 || sudo pacman -S --needed --noconfirm cachyos-rate-mirrors) && sudo cachyos-rate-mirrors || echo 'cachyos-rate-mirrors failed'; \
(command -v reflector >/dev/null 2>&1 && sudo reflector --verbose --country '{countries}' --protocol https --sort rate --latest 20 --download-timeout 6 --save /etc/pacman.d/mirrorlist) || echo 'reflector not found; skipping mirror update'; \
elif grep -q 'Artix' /etc/os-release 2>/dev/null; then \
country_count=$(echo '{countries}' | tr ',' '\\n' | wc -l); \
if [ \"$country_count\" -ne 1 ]; then \
echo 'Error: Only one country is allowed for Artix mirror update.'; \
echo 'Please select a single country.'; \
exit 1; \
fi; \
if ! (sudo pacman -Qi rate-mirrors >/dev/null 2>&1 || command -v rate-mirrors >/dev/null 2>&1); then \
if ! (sudo pacman -Qi paru >/dev/null 2>&1 || command -v paru >/dev/null 2>&1) && ! (sudo pacman -Qi yay >/dev/null 2>&1 || command -v yay >/dev/null 2>&1); then \
echo 'Error: rate-mirrors is not installed and no AUR helper (yay/paru) found.'; \
echo 'Please install yay or paru first, or install rate-mirrors manually.'; \
exit 1; \
fi; \
echo 'rate-mirrors is not installed.'; \
read -rp 'Do you want to install rate-mirrors from AUR? (y/n): ' install_choice; \
if [ \"$install_choice\" != \"y\" ] && [ \"$install_choice\" != \"Y\" ]; then \
echo 'Mirror update cancelled.'; \
exit 1; \
fi; \
if sudo pacman -Qi paru >/dev/null 2>&1 || command -v paru >/dev/null 2>&1; then \
paru -S --needed --noconfirm rate-mirrors || exit 1; \
elif sudo pacman -Qi yay >/dev/null 2>&1 || command -v yay >/dev/null 2>&1; then \
yay -S --needed --noconfirm rate-mirrors || exit 1; \
fi; \
fi; \
sudo cp /etc/pacman.d/mirrorlist /etc/pacman.d/mirrorlist.backup.$(date +%Y%m%d_%H%M%S) || exit 1; \
rate-mirrors --protocol=https --allow-root --entry-country='{countries}' --country-neighbors-per-country=3 --top-mirrors-number-to-retest={count} --max-jumps=10 artix | sudo tee /etc/pacman.d/mirrorlist || exit 1; \
else \
(command -v reflector >/dev/null 2>&1 && sudo reflector --verbose --country '{countries}' --protocol https --sort rate --latest 20 --download-timeout 6 --save /etc/pacman.d/mirrorlist) || echo 'reflector not found; skipping mirror update'; \
fi)"
)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
/// What: Ensure the Worldwide variant embeds the Manjaro fasttrack workflow.
///
/// Inputs:
/// - `countries`: `"Worldwide"` to trigger the fasttrack branch.
/// - `count`: `8` mirror entries requested.
///
/// Output:
/// - Command string contains the Manjaro detection guard plus the fasttrack invocation with the requested count.
///
/// Details:
/// - Verifies the script includes the fasttrack invocation with the requested count.
fn mirror_update_worldwide_includes_fasttrack_path() {
let cmd = mirror_update_command("Worldwide", 8);
assert!(cmd.contains("grep -q 'Manjaro' /etc/os-release"));
assert!(cmd.contains("pacman-mirrors --fasttrack 8"));
}
#[test]
/// What: Verify region-specific invocation propagates the provided country list to reflector helpers.
///
/// Inputs:
/// - `countries`: `"Germany,France"` representing a comma-separated selection.
/// - `count`: Arbitrary `5`, unused in the non-Worldwide branch.
///
/// Output:
/// - Command string includes the quoted country list for both Manjaro rank and reflector fallback branches.
///
/// Details:
/// - Confirms the `EndeavourOS` clause still emits the reflector call with the customized country list.
fn mirror_update_regional_propagates_country_argument() {
let countries = "Germany,France";
let cmd = mirror_update_command(countries, 5);
assert!(cmd.contains("--country 'Germany,France'"));
assert!(cmd.contains("grep -q 'EndeavourOS' /etc/os-release"));
assert!(cmd.contains("sudo reflector --verbose --country 'Germany,France'"));
}
#[test]
/// What: Confirm `EndeavourOS` and `CachyOS` branches retain their helper invocations and fallback messaging.
///
/// Inputs:
/// - `countries`: `"Worldwide"` to pass through every branch without country filtering.
/// - `count`: `3`, checking the value does not affect non-Manjaro logic.
///
/// Output:
/// - Command string references both `eos-rankmirrors` and `cachyos-rate-mirrors` along with their retry echo messages.
///
/// Details:
/// - Guards against accidental removal of distro-specific tooling when modifying the mirrored script.
fn mirror_update_includes_distro_specific_helpers() {
let cmd = mirror_update_command("Worldwide", 3);
assert!(cmd.contains("sudo eos-rankmirrors"));
assert!(cmd.contains("cachyos-rate-mirrors"));
assert!(cmd.contains("echo 'reflector not found; skipping mirror update'"));
}
#[test]
/// What: Ensure Artix detection and rate-mirrors workflow is included in Worldwide variant.
///
/// Inputs:
/// - `countries`: `"Worldwide"` to trigger the Worldwide branch.
/// - `count`: `10` top mirrors number for rate-mirrors.
///
/// Output:
/// - Command string contains Artix detection guard and rate-mirrors invocation without --entry-country.
///
/// Details:
/// - Verifies Artix branch uses rate-mirrors without --entry-country for Worldwide selection.
fn mirror_update_worldwide_includes_artix_path() {
let cmd = mirror_update_command("Worldwide", 10);
assert!(cmd.contains("grep -q 'Artix' /etc/os-release"));
assert!(cmd.contains("rate-mirrors"));
assert!(cmd.contains("--top-mirrors-number-to-retest=10"));
assert!(cmd.contains("--allow-root"));
assert!(cmd.contains(" artix"));
}
#[test]
/// What: Verify Artix regional invocation includes country validation and rate-mirrors with --entry-country.
///
/// Inputs:
/// - `countries`: `"Germany"` representing a single country selection.
/// - `count`: `5` top mirrors number for rate-mirrors.
///
/// Output:
/// - Command string includes Artix detection, country count validation, and rate-mirrors with --entry-country.
///
/// Details:
/// - Confirms the Artix clause validates single country and uses --entry-country parameter.
fn mirror_update_artix_regional_includes_country_validation() {
let cmd = mirror_update_command("Germany", 5);
assert!(cmd.contains("grep -q 'Artix' /etc/os-release"));
assert!(cmd.contains("--entry-country='Germany'"));
assert!(cmd.contains("Only one country is allowed"));
assert!(cmd.contains("country_count=$(echo 'Germany'"));
assert!(cmd.contains("--top-mirrors-number-to-retest=5"));
}
#[test]
/// What: Confirm Artix branch includes rate-mirrors installation check and AUR helper detection.
///
/// Inputs:
/// - `countries`: `"Germany"` to trigger Artix branch.
/// - `count`: `8` top mirrors number.
///
/// Output:
/// - Command string includes checks for rate-mirrors, yay, and paru, plus installation prompt.
///
/// Details:
/// - Validates that the script checks for rate-mirrors and AUR helpers before proceeding.
fn mirror_update_artix_includes_installation_checks() {
let cmd = mirror_update_command("Germany", 8);
assert!(cmd.contains("sudo pacman -Qi rate-mirrors"));
assert!(cmd.contains("sudo pacman -Qi paru"));
assert!(cmd.contains("sudo pacman -Qi yay"));
assert!(cmd.contains("command -v rate-mirrors"));
assert!(cmd.contains("command -v paru"));
assert!(cmd.contains("command -v yay"));
assert!(cmd.contains("Do you want to install rate-mirrors from AUR?"));
assert!(cmd.contains("Mirror update cancelled"));
}
#[test]
/// What: Verify Artix branch creates backup of mirrorlist before updating.
///
/// Inputs:
/// - `countries`: `"Germany"` to trigger Artix branch.
/// - `count`: `5` top mirrors number.
///
/// Output:
/// - Command string includes backup creation with timestamp.
///
/// Details:
/// - Ensures mirrorlist backup is created before rate-mirrors execution.
fn mirror_update_artix_includes_backup() {
let cmd = mirror_update_command("Germany", 5);
assert!(cmd.contains("sudo cp /etc/pacman.d/mirrorlist"));
assert!(cmd.contains("mirrorlist.backup"));
assert!(cmd.contains("date +%Y%m%d_%H%M%S"));
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/modals/password.rs | src/events/modals/password.rs | //! Password prompt modal event handling.
use crossterm::event::{KeyCode, KeyEvent};
use crate::state::AppState;
/// What: Handle key events for password prompt modal.
///
/// Inputs:
/// - `ke`: Key event
/// - `app`: Mutable application state
/// - `input`: Mutable reference to password input buffer
/// - `cursor`: Mutable reference to cursor position
///
/// Output:
/// - `true` if Enter was pressed (password submitted), `false` otherwise
///
/// Details:
/// - Handles text input, navigation, and Enter/Esc keys.
/// - Returns `true` on Enter to indicate password should be submitted.
pub(super) fn handle_password_prompt(
ke: KeyEvent,
app: &mut AppState,
input: &mut String,
cursor: &mut usize,
) -> bool {
match ke.code {
KeyCode::Esc => {
app.modal = crate::state::Modal::None;
false
}
KeyCode::Enter => {
// Password submitted - caller will handle transition
true
}
KeyCode::Backspace => {
if *cursor > 0 && *cursor <= input.len() {
input.remove(*cursor - 1);
*cursor -= 1;
}
false
}
KeyCode::Left => {
if *cursor > 0 {
*cursor -= 1;
}
false
}
KeyCode::Right => {
if *cursor < input.len() {
*cursor += 1;
}
false
}
KeyCode::Home => {
*cursor = 0;
false
}
KeyCode::End => {
*cursor = input.len();
false
}
KeyCode::Char(ch) => {
if !ch.is_control() {
if *cursor <= input.len() {
input.insert(*cursor, ch);
*cursor += 1;
} else {
input.push(ch);
*cursor = input.len();
}
}
false
}
_ => false,
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/modals/system_update.rs | src/events/modals/system_update.rs | //! System update modal handling.
use crossterm::event::{KeyCode, KeyEvent};
use crate::events::distro;
use crate::state::AppState;
/// What: Handle key events for `SystemUpdate` modal.
///
/// Inputs:
/// - `ke`: Key event
/// - `app`: Mutable application state
/// - `do_mirrors`: Mutable reference to mirrors flag
/// - `do_pacman`: Mutable reference to pacman flag
/// - `force_sync`: Mutable reference to force sync flag (toggled with Left/Right on pacman row)
/// - `do_aur`: Mutable reference to AUR flag
/// - `do_cache`: Mutable reference to cache flag
/// - `country_idx`: Mutable reference to selected country index
/// - `countries`: Available countries list
/// - `mirror_count`: Mutable reference to mirror count
/// - `cursor`: Mutable reference to cursor position
///
/// Output:
/// - `Some(true)` if Enter was pressed and commands were executed, `Some(false)` otherwise, `None` if not handled
///
/// Details:
/// - Handles Esc/q to close, navigation, toggles, and Enter to execute update commands
/// - Left/Right on row 1 (pacman) toggles between Normal (-Syu) and Force Sync (-Syyu)
/// - Left/Right on row 4 (country) cycles through countries
#[allow(clippy::too_many_arguments)]
pub(super) fn handle_system_update(
ke: KeyEvent,
app: &mut AppState,
do_mirrors: &mut bool,
do_pacman: &mut bool,
force_sync: &mut bool,
do_aur: &mut bool,
do_cache: &mut bool,
country_idx: &mut usize,
countries: &[String],
mirror_count: &mut u16,
cursor: &mut usize,
) -> Option<bool> {
match ke.code {
KeyCode::Esc | KeyCode::Char('q') => {
app.modal = crate::state::Modal::None;
Some(false)
}
KeyCode::Up | KeyCode::Char('k') => {
if *cursor > 0 {
*cursor -= 1;
}
Some(false)
}
KeyCode::Down | KeyCode::Char('j') => {
let max = 4; // 4 options (0..3) + country row (index 4)
if *cursor < max {
*cursor += 1;
}
Some(false)
}
KeyCode::Left => {
match *cursor {
// Toggle sync mode on pacman row
1 => *force_sync = !*force_sync,
// Cycle countries on country row
4 if !countries.is_empty() => {
if *country_idx == 0 {
*country_idx = countries.len() - 1;
} else {
*country_idx -= 1;
}
}
_ => {}
}
Some(false)
}
KeyCode::Right | KeyCode::Tab => {
match *cursor {
// Toggle sync mode on pacman row
1 => *force_sync = !*force_sync,
// Cycle countries on country row
4 if !countries.is_empty() => {
*country_idx = (*country_idx + 1) % countries.len();
}
_ => {}
}
Some(false)
}
KeyCode::Char(' ') => {
match *cursor {
0 => *do_mirrors = !*do_mirrors,
1 => *do_pacman = !*do_pacman,
2 => *do_aur = !*do_aur,
3 => *do_cache = !*do_cache,
_ => {}
}
Some(false)
}
KeyCode::Char('-') => {
// Decrease mirror count when focused on the country/count row
if *cursor == 4 && *mirror_count > 1 {
*mirror_count -= 1;
crate::theme::save_mirror_count(*mirror_count);
}
Some(false)
}
KeyCode::Char('+') => {
// Increase mirror count when focused on the country/count row
if *cursor == 4 && *mirror_count < 200 {
*mirror_count += 1;
crate::theme::save_mirror_count(*mirror_count);
}
Some(false)
}
KeyCode::Enter => {
handle_system_update_enter(
app,
*do_mirrors,
*do_pacman,
*force_sync,
*do_aur,
*do_cache,
*country_idx,
countries,
*mirror_count,
);
Some(true)
}
_ => None,
}
}
#[cfg(test)]
mod tests;
/// What: Build and execute system update commands using executor pattern.
///
/// Inputs:
/// - `app`: Mutable application state
/// - `do_mirrors`: Whether to update mirrors
/// - `do_pacman`: Whether to update pacman packages
/// - `force_sync`: Whether to force sync databases (use -Syyu instead of -Syu)
/// - `do_aur`: Whether to update AUR packages
/// - `do_cache`: Whether to clean cache
/// - `country_idx`: Selected country index
/// - `countries`: Available countries list
/// - `mirror_count`: Number of mirrors to use
///
/// Output:
/// - Stores commands in `pending_update_commands` and transitions to `PasswordPrompt` modal,
/// or `Modal::Alert` if no actions selected
///
/// Details:
/// - Builds command list based on selected options
/// - Shows `PasswordPrompt` modal to get sudo password
/// - Actual execution happens after password is validated in password handler
#[allow(clippy::too_many_arguments, clippy::fn_params_excessive_bools)]
fn handle_system_update_enter(
app: &mut AppState,
do_mirrors: bool,
do_pacman: bool,
force_sync: bool,
do_aur: bool,
do_cache: bool,
country_idx: usize,
countries: &[String],
mirror_count: u16,
) {
let mut cmds: Vec<String> = Vec::new();
if do_mirrors {
let sel = if country_idx < countries.len() {
countries[country_idx].as_str()
} else {
"Worldwide"
};
let prefs = crate::theme::settings();
let countries_arg = if sel == "Worldwide" {
prefs.selected_countries.as_str()
} else {
sel
};
crate::theme::save_selected_countries(countries_arg);
crate::theme::save_mirror_count(mirror_count);
cmds.push(distro::mirror_update_command(countries_arg, mirror_count));
}
if do_pacman {
// Use -Syyu (force sync) or -Syu (normal sync) based on user selection
let sync_flag = if force_sync { "-Syyu" } else { "-Syu" };
cmds.push(format!("sudo pacman {sync_flag} --noconfirm"));
}
// Build AUR command separately - will be executed conditionally if pacman fails
let aur_command = if do_aur {
// Always use -Sua (AUR only) to update only AUR packages
// AUR helpers (paru/yay) will automatically handle dependency resolution:
// - If AUR packages require newer official packages, the helper will report this
// - Users can then also select pacman update if dependency issues occur
// - This follows Arch Linux best practices: update official packages first, then AUR
let sync_flag = "-Sua";
Some(format!(
"if command -v paru >/dev/null 2>&1; then \
paru {sync_flag} --noconfirm; \
elif command -v yay >/dev/null 2>&1; then \
yay {sync_flag} --noconfirm; \
else \
echo 'No AUR helper (paru/yay) found.'; \
fi"
))
} else {
None
};
// If both pacman and AUR are selected, store AUR command separately for conditional execution
// If only AUR is selected, add it to the main command list
if let Some(aur_cmd) = aur_command {
if do_pacman {
// Store AUR command separately - will be executed after pacman if user confirms
app.pending_aur_update_command = Some(aur_cmd);
} else {
// Only AUR selected, add to main command list
cmds.push(aur_cmd);
}
}
if do_cache {
cmds.push("sudo pacman -Sc --noconfirm".to_string());
cmds.push("((command -v paru >/dev/null 2>&1 || sudo pacman -Qi paru >/dev/null 2>&1) && paru -Sc --noconfirm) || ((command -v yay >/dev/null 2>&1 || sudo pacman -Qi yay >/dev/null 2>&1) && yay -Sc --noconfirm) || true".to_string());
}
if cmds.is_empty() {
app.modal = crate::state::Modal::Alert {
message: "No actions selected".to_string(),
};
return;
}
// In test mode with PACSEA_TEST_OUT, spawn terminal directly to allow tests to verify terminal argument shapes
// This bypasses the executor pattern which runs commands in PTY
if std::env::var("PACSEA_TEST_OUT").is_ok() {
crate::install::spawn_shell_commands_in_terminal(&cmds);
app.modal = crate::state::Modal::None;
return;
}
// Store update commands for processing after password prompt
app.pending_update_commands = Some(cmds);
// Show password prompt - user can press Enter if passwordless sudo is configured
app.modal = crate::state::Modal::PasswordPrompt {
purpose: crate::state::modal::PasswordPurpose::Update,
items: Vec::new(), // System update doesn't have package items
input: String::new(),
cursor: 0,
error: None,
};
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/modals/handlers.rs | src/events/modals/handlers.rs | //! Individual modal handler functions that encapsulate field extraction and restoration.
use crossterm::event::{KeyCode, KeyEvent};
use tokio::sync::mpsc;
use super::restore;
use crate::install::ExecutorRequest;
use crate::state::{AppState, Modal, PackageItem};
/// What: Handle key events for Alert modal, including restoration logic.
///
/// Inputs:
/// - `ke`: Key event
/// - `app`: Mutable application state
/// - `modal`: Alert modal variant with message
///
/// Output:
/// - `true` if Esc was pressed (to stop propagation), otherwise `false`
///
/// Details:
/// - Delegates to common handler and handles restoration
/// - Returns the result from common handler to prevent event propagation when Esc is pressed
pub(super) fn handle_alert_modal(ke: KeyEvent, app: &mut AppState, modal: &Modal) -> bool {
if let Modal::Alert { message } = modal {
super::common::handle_alert(ke, app, message)
} else {
false
}
}
/// What: Handle key events for `PreflightExec` modal, including restoration logic.
///
/// Inputs:
/// - `ke`: Key event
/// - `app`: Mutable application state
/// - `modal`: `PreflightExec` modal variant
///
/// Output:
/// - `false` (never stops propagation)
///
/// Details:
/// - Delegates to common handler, updates verbose flag, and restores modal if needed
/// - Returns `true` when modal is closed/transitioned to stop key propagation
pub(super) fn handle_preflight_exec_modal(
ke: KeyEvent,
app: &mut AppState,
mut modal: Modal,
) -> bool {
if let Modal::PreflightExec {
ref mut verbose,
ref log_lines,
ref abortable,
ref items,
ref action,
ref tab,
ref header_chips,
ref success,
} = modal
{
// Pass success to the handler since app.modal is taken during dispatch
let should_stop =
super::common::handle_preflight_exec(ke, app, verbose, *abortable, items, *success);
if should_stop {
return true; // Modal was closed or transitioned, stop propagation
}
restore::restore_if_not_closed_with_excluded_keys(
app,
&ke,
&[KeyCode::Esc, KeyCode::Char('q')],
Modal::PreflightExec {
verbose: *verbose,
log_lines: log_lines.clone(),
abortable: *abortable,
items: items.clone(),
action: *action,
tab: *tab,
success: *success,
header_chips: header_chips.clone(),
},
);
}
false
}
/// What: Handle key events for `PostSummary` modal, including restoration logic.
///
/// Inputs:
/// - `ke`: Key event
/// - `app`: Mutable application state
/// - `modal`: `PostSummary` modal variant
///
/// Output:
/// - `false` (never stops propagation)
///
/// Details:
/// - Delegates to common handler and restores modal if needed
/// - Returns `true` when modal is closed to stop key propagation
pub(super) fn handle_post_summary_modal(ke: KeyEvent, app: &mut AppState, modal: &Modal) -> bool {
if let Modal::PostSummary {
success,
changed_files,
pacnew_count,
pacsave_count,
services_pending,
snapshot_label,
} = modal
{
let should_stop = super::common::handle_post_summary(ke, app, services_pending);
if should_stop {
return true; // Modal was closed, stop propagation
}
restore::restore_if_not_closed_with_excluded_keys(
app,
&ke,
&[KeyCode::Esc, KeyCode::Enter, KeyCode::Char('q')],
Modal::PostSummary {
success: *success,
changed_files: *changed_files,
pacnew_count: *pacnew_count,
pacsave_count: *pacsave_count,
services_pending: services_pending.clone(),
snapshot_label: snapshot_label.clone(),
},
);
}
false
}
/// What: Handle key events for `SystemUpdate` modal, including restoration logic.
///
/// Inputs:
/// - `ke`: Key event
/// - `app`: Mutable application state
/// - `modal`: `SystemUpdate` modal variant
///
/// Output:
/// - `true` if event propagation should stop, otherwise `false`
///
/// Details:
/// - Delegates to `system_update` handler and restores modal if needed
pub(super) fn handle_system_update_modal(
ke: KeyEvent,
app: &mut AppState,
mut modal: Modal,
) -> bool {
if let Modal::SystemUpdate {
ref mut do_mirrors,
ref mut do_pacman,
ref mut force_sync,
ref mut do_aur,
ref mut do_cache,
ref mut country_idx,
ref countries,
ref mut mirror_count,
ref mut cursor,
} = modal
{
let should_stop = super::system_update::handle_system_update(
ke,
app,
do_mirrors,
do_pacman,
force_sync,
do_aur,
do_cache,
country_idx,
countries,
mirror_count,
cursor,
);
return restore::restore_if_not_closed_with_option_result(
app,
&ke,
should_stop,
Modal::SystemUpdate {
do_mirrors: *do_mirrors,
do_pacman: *do_pacman,
force_sync: *force_sync,
do_aur: *do_aur,
do_cache: *do_cache,
country_idx: *country_idx,
countries: countries.clone(),
mirror_count: *mirror_count,
cursor: *cursor,
},
);
}
false
}
/// What: Handle key events for `ConfirmInstall` modal.
///
/// Inputs:
/// - `ke`: Key event
/// - `app`: Mutable application state
/// - `modal`: `ConfirmInstall` modal variant
///
/// Output:
/// - `false` (never stops propagation)
///
/// Details:
/// - Delegates to install handler
pub(super) fn handle_confirm_install_modal(
ke: KeyEvent,
app: &mut AppState,
modal: &Modal,
) -> bool {
if let Modal::ConfirmInstall { items } = modal {
super::install::handle_confirm_install(ke, app, items);
}
false
}
/// What: Handle key events for `ConfirmRemove` modal.
///
/// Inputs:
/// - `ke`: Key event
/// - `app`: Mutable application state
/// - `modal`: `ConfirmRemove` modal variant
///
/// Output:
/// - `false` (never stops propagation)
///
/// Details:
/// - Delegates to install handler
pub(super) fn handle_confirm_remove_modal(ke: KeyEvent, app: &mut AppState, modal: &Modal) -> bool {
if let Modal::ConfirmRemove { items } = modal {
super::install::handle_confirm_remove(ke, app, items);
}
false
}
/// What: Handle key events for `ConfirmBatchUpdate` modal.
///
/// Inputs:
/// - `ke`: Key event
/// - `app`: Mutable application state
/// - `modal`: `ConfirmBatchUpdate` modal variant
///
/// Output:
/// - `true` if Esc/q was pressed (to stop propagation), otherwise `false`
///
/// Details:
/// - Handles Esc/q to cancel, Enter to continue with batch update
/// - Uses executor pattern (PTY-based execution) instead of spawning terminal
pub(super) fn handle_confirm_batch_update_modal(
ke: KeyEvent,
app: &mut AppState,
modal: &Modal,
) -> bool {
if let Modal::ConfirmBatchUpdate { items, dry_run } = modal {
match ke.code {
KeyCode::Esc | KeyCode::Char('q' | 'Q') => {
// Cancel update
app.modal = crate::state::Modal::None;
return true;
}
KeyCode::Enter => {
// Continue with batch update - use executor pattern instead of spawning terminal
let items_clone = items.clone();
let dry_run_clone = *dry_run;
app.dry_run = dry_run_clone;
// Get header_chips if available from pending_exec_header_chips, otherwise use default
let header_chips = app.pending_exec_header_chips.take().unwrap_or_default();
// Check if password is needed (same logic as handle_proceed_install)
// All installs need password (official and AUR both need sudo)
// Show password prompt - user can press Enter if passwordless sudo is configured
app.modal = crate::state::Modal::PasswordPrompt {
purpose: crate::state::modal::PasswordPurpose::Install,
items: items_clone,
input: String::new(),
cursor: 0,
error: None,
};
app.pending_exec_header_chips = Some(header_chips);
return true;
}
_ => {}
}
}
false
}
/// What: Handle key events for `ConfirmAurUpdate` modal.
///
/// Inputs:
/// - `ke`: Key event
/// - `app`: Mutable application state
/// - `modal`: `ConfirmAurUpdate` modal variant
///
/// Output:
/// - `true` if modal was closed/transitioned, `false` otherwise
///
/// Details:
/// - Enter (Y) continues with AUR update
/// - Esc/q (N) cancels and closes modal
pub(super) fn handle_confirm_aur_update_modal(
ke: KeyEvent,
app: &mut AppState,
modal: &Modal,
) -> bool {
if let Modal::ConfirmAurUpdate { .. } = modal {
match ke.code {
KeyCode::Esc | KeyCode::Char('q' | 'Q' | 'n' | 'N') => {
// Cancel AUR update
app.pending_aur_update_command = None;
app.modal = crate::state::Modal::None;
return true;
}
KeyCode::Enter | KeyCode::Char('y' | 'Y') => {
// Continue with AUR update
if let Some(aur_command) = app.pending_aur_update_command.take() {
let password = app.pending_executor_password.clone();
let dry_run = app.dry_run;
// Transition back to PreflightExec for AUR update
app.modal = Modal::PreflightExec {
items: Vec::new(),
action: crate::state::PreflightAction::Install,
tab: crate::state::PreflightTab::Summary,
verbose: false,
log_lines: Vec::new(),
abortable: true,
header_chips: app.pending_exec_header_chips.take().unwrap_or_default(),
success: None,
};
// Execute AUR update command
app.pending_executor_request = Some(ExecutorRequest::Update {
commands: vec![aur_command],
password,
dry_run,
});
} else {
app.modal = crate::state::Modal::None;
}
return true;
}
_ => {}
}
}
false
}
/// What: Handle key events for `ConfirmReinstall` modal.
///
/// Inputs:
/// - `ke`: Key event
/// - `app`: Mutable application state
/// - `modal`: `ConfirmReinstall` modal variant
///
/// Output:
/// - `true` if modal was closed/transitioned, `false` otherwise
///
/// Details:
/// - Handles Esc/q to cancel, Enter to proceed with reinstall
pub(super) fn handle_confirm_reinstall_modal(
ke: KeyEvent,
app: &mut AppState,
modal: &Modal,
) -> bool {
if let Modal::ConfirmReinstall {
items: _installed_items,
all_items,
header_chips,
} = modal
{
match ke.code {
KeyCode::Esc | KeyCode::Char('q' | 'Q') => {
// Cancel reinstall
app.modal = crate::state::Modal::None;
return true;
}
KeyCode::Enter => {
// Proceed with reinstall - use executor pattern
// Use all_items (all packages) instead of just installed ones
let items_clone = all_items.clone();
let header_chips_clone = header_chips.clone();
// Retrieve password that was stored when reinstall confirmation was shown
let password = app.pending_executor_password.take();
// All installs need password (official and AUR both need sudo)
if password.is_none() {
// Check faillock status before showing password prompt
let username = std::env::var("USER").unwrap_or_else(|_| "user".to_string());
if let Some(lockout_msg) =
crate::logic::faillock::get_lockout_message_if_locked(&username, app)
{
// User is locked out - show warning and don't show password prompt
app.modal = crate::state::Modal::Alert {
message: lockout_msg,
};
return true;
}
// Show password prompt (password wasn't provided yet)
app.modal = crate::state::Modal::PasswordPrompt {
purpose: crate::state::modal::PasswordPurpose::Install,
items: items_clone,
input: String::new(),
cursor: 0,
error: None,
};
app.pending_exec_header_chips = Some(header_chips_clone);
} else {
// Password already obtained or not needed, go directly to execution
use crate::events::preflight::keys;
keys::start_execution(
app,
&items_clone,
crate::state::PreflightAction::Install,
header_chips_clone,
password,
);
}
return true;
}
_ => {}
}
}
false
}
/// What: Handle key events for Help modal.
///
/// Inputs:
/// - `ke`: Key event
/// - `app`: Mutable application state
/// - `modal`: Help modal variant (unit type)
///
/// Output:
/// - `true` if Esc was pressed (to stop propagation), otherwise `false`
///
/// Details:
/// - Delegates to common handler
pub(super) fn handle_help_modal(ke: KeyEvent, app: &mut AppState, _modal: Modal) -> bool {
super::common::handle_help(ke, app)
}
/// What: Handle key events for News modal, including restoration logic.
///
/// Inputs:
/// - `ke`: Key event
/// - `app`: Mutable application state
/// - `modal`: News modal variant
///
/// Output:
/// - `true` if Esc was pressed (to stop propagation), otherwise `false`
///
/// Details:
/// - Delegates to common handler and restores modal if needed
pub(super) fn handle_news_modal(ke: KeyEvent, app: &mut AppState, mut modal: Modal) -> bool {
if let Modal::News {
ref items,
ref mut selected,
ref mut scroll,
} = modal
{
let result = super::common::handle_news(ke, app, items, selected, scroll);
return restore::restore_if_not_closed_with_bool_result(
app,
result,
Modal::News {
items: items.clone(),
selected: *selected,
scroll: *scroll,
},
);
}
false
}
/// What: Handle key events for Announcement modal, including restoration logic.
///
/// Inputs:
/// - `ke`: Key event
/// - `app`: Mutable application state
/// - `modal`: Announcement modal variant
///
/// Output:
/// - `true` if Esc was pressed (to stop propagation), otherwise `false`
///
/// Details:
/// - Delegates to common handler and restores modal if needed
pub(super) fn handle_announcement_modal(
ke: KeyEvent,
app: &mut AppState,
mut modal: Modal,
) -> bool {
if let Modal::Announcement {
ref title,
ref content,
ref id,
ref mut scroll,
} = modal
{
let old_id = id.clone();
let result = super::common::handle_announcement(ke, app, id, scroll);
// Only restore if modal wasn't closed AND it's still the same announcement
// (don't restore if a new pending announcement was shown)
match &app.modal {
Modal::Announcement { id: new_id, .. } if *new_id == old_id => {
// Same announcement, restore scroll state
app.modal = Modal::Announcement {
title: title.clone(),
content: content.clone(),
id: old_id,
scroll: *scroll,
};
}
_ => {
// Modal was closed or different modal (e.g., pending announcement was shown), don't restore
}
}
return result;
}
false
}
/// What: Handle key events for Updates modal, including restoration logic.
///
/// Inputs:
/// - `ke`: Key event
/// - `app`: Mutable application state
/// - `modal`: Updates modal variant
///
/// Output:
/// - `true` if Esc was pressed (to stop propagation), otherwise `false`
///
/// Details:
/// - Delegates to common handler and restores modal if needed
pub(super) fn handle_updates_modal(ke: KeyEvent, app: &mut AppState, mut modal: Modal) -> bool {
if let Modal::Updates {
ref entries,
ref mut scroll,
ref mut selected,
} = modal
{
let result = super::common::handle_updates(ke, app, entries, scroll, selected);
return restore::restore_if_not_closed_with_bool_result(
app,
result,
Modal::Updates {
entries: entries.clone(),
scroll: *scroll,
selected: *selected,
},
);
}
false
}
/// What: Handle key events for `OptionalDeps` modal, including restoration logic.
///
/// Inputs:
/// - `ke`: Key event
/// - `app`: Mutable application state
/// - `modal`: `OptionalDeps` modal variant
///
/// Output:
/// - `true` if event propagation should stop, otherwise `false`
///
/// Details:
/// - Delegates to `optional_deps` handler and restores modal if needed
pub(super) fn handle_optional_deps_modal(
ke: KeyEvent,
app: &mut AppState,
mut modal: Modal,
) -> bool {
if let Modal::OptionalDeps {
ref rows,
ref mut selected,
} = modal
{
let should_stop = super::optional_deps::handle_optional_deps(ke, app, rows, selected);
return restore::restore_if_not_closed_with_option_result(
app,
&ke,
should_stop,
Modal::OptionalDeps {
rows: rows.clone(),
selected: *selected,
},
);
}
false
}
/// What: Handle key events for `ScanConfig` modal, including restoration logic.
///
/// Inputs:
/// - `ke`: Key event
/// - `app`: Mutable application state
/// - `modal`: `ScanConfig` modal variant
///
/// Output:
/// - `false` (never stops propagation)
///
/// Details:
/// - Delegates to scan handler and restores modal if needed
pub(super) fn handle_scan_config_modal(ke: KeyEvent, app: &mut AppState, mut modal: Modal) -> bool {
if let Modal::ScanConfig {
ref mut do_clamav,
ref mut do_trivy,
ref mut do_semgrep,
ref mut do_shellcheck,
ref mut do_virustotal,
ref mut do_custom,
ref mut do_sleuth,
ref mut cursor,
} = modal
{
super::scan::handle_scan_config(
ke,
app,
do_clamav,
do_trivy,
do_semgrep,
do_shellcheck,
do_virustotal,
do_custom,
do_sleuth,
cursor,
);
restore::restore_if_not_closed_with_esc(
app,
&ke,
Modal::ScanConfig {
do_clamav: *do_clamav,
do_trivy: *do_trivy,
do_semgrep: *do_semgrep,
do_shellcheck: *do_shellcheck,
do_virustotal: *do_virustotal,
do_custom: *do_custom,
do_sleuth: *do_sleuth,
cursor: *cursor,
},
);
}
false
}
/// What: Handle key events for `NewsSetup` modal, including restoration logic.
///
/// Inputs:
/// - `ke`: Key event
/// - `app`: Mutable application state
/// - `modal`: `NewsSetup` modal variant
///
/// Output:
/// - `true` if modal was closed (to stop propagation), otherwise `false`
///
/// Details:
/// - Handles navigation, toggles, date selection, and Enter to save settings
/// - On save, persists settings and triggers startup news fetch
pub(super) fn handle_news_setup_modal(ke: KeyEvent, app: &mut AppState, mut modal: Modal) -> bool {
if let Modal::NewsSetup {
ref mut show_arch_news,
ref mut show_advisories,
ref mut show_aur_updates,
ref mut show_aur_comments,
ref mut show_pkg_updates,
ref mut max_age_days,
ref mut cursor,
} = modal
{
match ke.code {
KeyCode::Esc => {
// Cancel - restore previous modal or close
if let Some(prev_modal) = app.previous_modal.take() {
app.modal = prev_modal;
} else {
app.modal = crate::state::Modal::None;
}
return true;
}
KeyCode::Up => {
if *cursor > 0 {
*cursor -= 1;
}
}
KeyCode::Down => {
// Max cursor is 7 (0-4 for toggles, 5-7 for date buttons)
if *cursor < 7 {
*cursor += 1;
}
}
KeyCode::Left => {
// Navigate between date buttons when on date row (cursor 5-7)
if *cursor >= 5 && *cursor <= 7 && *cursor > 5 {
*cursor -= 1;
}
}
KeyCode::Right => {
// Navigate between date buttons when on date row (cursor 5-7)
if *cursor >= 5 && *cursor <= 7 && *cursor < 7 {
*cursor += 1;
}
}
KeyCode::Char(' ') => match *cursor {
0 => *show_arch_news = !*show_arch_news,
1 => *show_advisories = !*show_advisories,
2 => *show_aur_updates = !*show_aur_updates,
3 => *show_aur_comments = !*show_aur_comments,
4 => *show_pkg_updates = !*show_pkg_updates,
5 => *max_age_days = Some(7),
6 => *max_age_days = Some(30),
7 => *max_age_days = Some(90),
_ => {}
},
KeyCode::Enter => {
// Save all settings
crate::theme::save_startup_news_show_arch_news(*show_arch_news);
crate::theme::save_startup_news_show_advisories(*show_advisories);
crate::theme::save_startup_news_show_aur_updates(*show_aur_updates);
crate::theme::save_startup_news_show_aur_comments(*show_aur_comments);
crate::theme::save_startup_news_show_pkg_updates(*show_pkg_updates);
crate::theme::save_startup_news_max_age_days(*max_age_days);
crate::theme::save_startup_news_configured(true);
// Mark that we need to trigger startup news fetch
app.trigger_startup_news_fetch = true;
// Close modal
app.modal = crate::state::Modal::None;
return true;
}
_ => {}
}
restore::restore_if_not_closed_with_esc(
app,
&ke,
Modal::NewsSetup {
show_arch_news: *show_arch_news,
show_advisories: *show_advisories,
show_aur_updates: *show_aur_updates,
show_aur_comments: *show_aur_comments,
show_pkg_updates: *show_pkg_updates,
max_age_days: *max_age_days,
cursor: *cursor,
},
);
}
false
}
/// What: Handle key events for `VirusTotalSetup` modal, including restoration logic.
///
/// Inputs:
/// - `ke`: Key event
/// - `app`: Mutable application state
/// - `modal`: `VirusTotalSetup` modal variant
///
/// Output:
/// - `false` (never stops propagation)
///
/// Details:
/// - Delegates to scan handler and restores modal if needed
pub(super) fn handle_virustotal_setup_modal(
ke: KeyEvent,
app: &mut AppState,
mut modal: Modal,
) -> bool {
if let Modal::VirusTotalSetup {
ref mut input,
ref mut cursor,
} = modal
{
super::scan::handle_virustotal_setup(ke, app, input, cursor);
restore::restore_if_not_closed_with_esc(
app,
&ke,
Modal::VirusTotalSetup {
input: input.clone(),
cursor: *cursor,
},
);
}
false
}
/// What: Handle key events for `GnomeTerminalPrompt` modal.
///
/// Inputs:
/// - `ke`: Key event
/// - `app`: Mutable application state
/// - `modal`: `GnomeTerminalPrompt` modal variant (unit type)
///
/// Output:
/// - `false` (never stops propagation)
///
/// Details:
/// - Delegates to common handler
pub(super) fn handle_gnome_terminal_prompt_modal(
ke: KeyEvent,
app: &mut AppState,
_modal: Modal,
) -> bool {
super::common::handle_gnome_terminal_prompt(ke, app);
false
}
/// What: Handle key events for `PasswordPrompt` modal, including restoration logic.
///
/// Inputs:
/// - `ke`: Key event
/// - `app`: Mutable application state
/// - `modal`: `PasswordPrompt` modal variant
///
/// Output:
/// - `true` if Enter was pressed (password submitted), `false` otherwise
///
/// Details:
/// - Delegates to password handler and restores modal if needed
/// - Returns `true` on Enter to indicate password should be submitted
#[allow(clippy::too_many_lines)] // Complex password validation and execution flow requires many lines (function has 327 lines)
pub(super) fn handle_password_prompt_modal(
ke: KeyEvent,
app: &mut AppState,
mut modal: Modal,
) -> bool {
if let Modal::PasswordPrompt {
ref mut input,
ref mut cursor,
ref purpose,
ref items,
ref mut error,
} = modal
{
let submitted = super::password::handle_password_prompt(ke, app, input, cursor);
if submitted {
// Password submitted - validate before starting execution
let password = if input.trim().is_empty() {
None
} else {
Some(input.clone())
};
// Validate password if provided (skip validation for passwordless sudo)
if let Some(ref pass) = password {
// Validate password before starting execution
// Always validate - don't skip even if passwordless sudo might be configured
match crate::logic::password::validate_sudo_password(pass) {
Ok(true) => {
// Password is valid, continue with execution
}
Ok(false) => {
// Password is invalid - check faillock status and show error
let username = std::env::var("USER").unwrap_or_else(|_| "user".to_string());
// Check if user is now locked out (this may have just happened)
let (is_locked, lockout_until, remaining_minutes) =
crate::logic::faillock::get_lockout_info(&username);
// Update AppState immediately with lockout status
app.faillock_locked = is_locked;
app.faillock_lockout_until = lockout_until;
app.faillock_remaining_minutes = remaining_minutes;
if is_locked {
// User is locked out - show alert modal with lockout message
let lockout_msg = remaining_minutes.map_or_else(
|| {
crate::i18n::t_fmt1(
app,
"app.modals.alert.account_locked",
&username,
)
},
|remaining| {
if remaining > 0 {
crate::i18n::t_fmt(
app,
"app.modals.alert.account_locked_with_time",
&[&username as &dyn std::fmt::Display, &remaining],
)
} else {
crate::i18n::t_fmt1(
app,
"app.modals.alert.account_locked",
&username,
)
}
},
);
// Close password prompt and show alert
// Clear any pending executor state to abort the process
app.pending_executor_password = None;
app.pending_exec_header_chips = None;
app.pending_executor_request = None;
app.modal = crate::state::Modal::Alert {
message: lockout_msg,
};
return true;
}
// Not locked out, check status for remaining attempts
let error_msg = crate::logic::faillock::check_faillock_status(&username)
.map_or_else(
|_| {
// Couldn't check faillock status, just show generic error
crate::i18n::t(
app,
"app.modals.password_prompt.incorrect_password",
)
},
|status| {
let remaining =
status.max_attempts.saturating_sub(status.attempts_used);
crate::i18n::t_fmt1(
app,
"app.modals.password_prompt.incorrect_password_attempts",
remaining,
)
},
);
// Update modal with error message and keep it open for retry
// Clear the input field so user can immediately type a new password
app.modal = crate::state::Modal::PasswordPrompt {
purpose: *purpose,
items: items.clone(),
input: String::new(), // Clear input field
cursor: 0, // Reset cursor position
error: Some(error_msg),
};
// Don't start execution, keep modal open for retry
// Return true to stop event propagation and prevent restore from overwriting
return true;
}
Err(e) => {
// Error validating password (e.g., sudo not available)
// Update modal with error message and keep it open
app.modal = crate::state::Modal::PasswordPrompt {
purpose: *purpose,
items: items.clone(),
input: input.clone(),
cursor: *cursor,
error: Some(crate::i18n::t_fmt1(
app,
"app.modals.password_prompt.validation_failed",
&e,
)),
};
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | true |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/modals/optional_deps.rs | src/events/modals/optional_deps.rs | //! Optional dependencies modal handling.
use crossterm::event::{KeyCode, KeyEvent};
use crate::state::AppState;
/// What: Handle key events for `OptionalDeps` modal.
///
/// Inputs:
/// - `ke`: Key event
/// - `app`: Mutable application state
/// - `rows`: Optional dependency rows
/// - `selected`: Currently selected row index
///
/// Output:
/// - `Some(true)` if Enter was pressed and should stop propagation, `Some(false)` otherwise, `None` if not handled
///
/// Details:
/// - Handles Esc/q to close, navigation and Enter to install/setup optional dependencies
pub(super) fn handle_optional_deps(
ke: KeyEvent,
app: &mut AppState,
rows: &[crate::state::types::OptionalDepRow],
selected: &mut usize,
) -> Option<bool> {
match ke.code {
KeyCode::Esc | KeyCode::Char('q') => {
app.modal = crate::state::Modal::None;
Some(false)
}
KeyCode::Up | KeyCode::Char('k') => {
if *selected > 0 {
*selected -= 1;
}
Some(false)
}
KeyCode::Down | KeyCode::Char('j') => {
if *selected + 1 < rows.len() {
*selected += 1;
}
Some(false)
}
KeyCode::Enter => {
if let Some(row) = rows.get(*selected) {
match handle_optional_deps_enter(app, row) {
(new_modal, true) => {
app.modal = new_modal;
Some(true)
}
(new_modal, false) => {
app.modal = new_modal;
Some(false)
}
}
} else {
Some(false)
}
}
_ => None,
}
}
/// What: Handle Enter key in `OptionalDeps` modal.
///
/// Inputs:
/// - `app`: Mutable application state
/// - `row`: Selected optional dependency row
///
/// Output:
/// - `(new_modal, should_stop_propagation)` tuple
///
/// Details:
/// - Handles setup for virustotal/aur-sleuth (keeps terminal spawn for interactive setup)
/// - Shows reinstall confirmation for already installed dependencies
/// - Installs optional dependencies using executor pattern
#[allow(clippy::too_many_lines)] // Complex function handling multiple installation paths (function has 227 lines)
fn handle_optional_deps_enter(
app: &mut AppState,
row: &crate::state::types::OptionalDepRow,
) -> (crate::state::Modal, bool) {
use crate::install::ExecutorRequest;
use crate::state::{PackageItem, Source};
// Setup flows need interactive terminal, keep as-is
if row.package == "virustotal-setup" {
let current = crate::theme::settings().virustotal_api_key;
let cur_len = current.len();
return (
crate::state::Modal::VirusTotalSetup {
input: current,
cursor: cur_len,
},
false,
);
}
if row.package == "aur-sleuth-setup" {
let cmd = r##"(set -e
if ! command -v aur-sleuth >/dev/null 2>&1; then
echo "aur-sleuth not found."
echo
echo "Install aur-sleuth:"
echo " 1) system (/usr/local) requires sudo"
echo " 2) user (~/.local)"
echo " 3) cancel"
read -rp "Choose [1/2/3]: " choice
case "$choice" in
1)
tmp="$(mktemp -d)"; cd "$tmp"
git clone https://github.com/mgalgs/aur-sleuth.git
cd aur-sleuth
sudo make install
;;
2)
tmp="$(mktemp -d)"; cd "$tmp"
git clone https://github.com/mgalgs/aur-sleuth.git
cd aur-sleuth
make install PREFIX="$HOME/.local"
;;
*)
echo "Cancelled."; echo "Press any key to close..."; read -rn1 -s _; exit 0;;
esac
else
echo "aur-sleuth already installed; continuing to setup"
fi
conf="${XDG_CONFIG_HOME:-$HOME/.config}/aur-sleuth.conf"
mkdir -p "$(dirname "$conf")"
echo "# aur-sleuth configuration" > "$conf"
echo "[default]" >> "$conf"
read -rp "OPENAI_BASE_URL (e.g. https://openrouter.ai/api/v1 or http://localhost:11434/v1): " base
read -rp "OPENAI_MODEL (e.g. qwen/qwen3-30b-a3b-instruct-2507 or llama3.1:8b): " model
read -rp "OPENAI_API_KEY: " key
read -rp "MAX_LLM_JOBS (default 3): " jobs
read -rp "AUDIT_FAILURE_FATAL (true/false) [true]: " fatal
jobs=${jobs:-3}
fatal=${fatal:-true}
[ -n "$base" ] && echo "OPENAI_BASE_URL = $base" >> "$conf"
[ -n "$model" ] && echo "OPENAI_MODEL = $model" >> "$conf"
echo "OPENAI_API_KEY = $key" >> "$conf"
echo "MAX_LLM_JOBS = $jobs" >> "$conf"
echo "AUDIT_FAILURE_FATAL = $fatal" >> "$conf"
echo; echo "Wrote $conf"
echo "Tip: You can run 'aur-sleuth package-name' or audit a local pkgdir with '--pkgdir .'"
echo; echo "Press any key to close..."; read -rn1 -s _)"##
.to_string();
let to_run = if app.dry_run {
// Properly quote the command to avoid syntax errors with complex shell constructs
use crate::install::shell_single_quote;
let quoted = shell_single_quote(&cmd);
vec![format!("echo DRY RUN: {quoted}")]
} else {
vec![cmd]
};
crate::install::spawn_shell_commands_in_terminal(&to_run);
return (crate::state::Modal::None, true);
}
// Handle reinstall for already installed dependencies
if row.installed {
let pkg = row.package.clone();
// Determine if official or AUR to create proper PackageItem
let package_item = crate::index::find_package_by_name(&pkg).unwrap_or_else(|| {
// Assume AUR if not found in official index
PackageItem {
name: pkg.clone(),
version: String::new(),
description: String::new(),
source: Source::Aur,
popularity: None,
out_of_date: None,
orphaned: false,
}
});
// Show reinstall confirmation modal
// For optional deps, it's a single package, so items and all_items are the same
return (
crate::state::Modal::ConfirmReinstall {
items: vec![package_item.clone()],
all_items: vec![package_item],
header_chips: crate::state::modal::PreflightHeaderChips::default(),
},
false,
);
}
// Install optional dependencies using executor pattern
if !row.installed && row.selectable {
let pkg = row.package.clone();
// Special packages that need custom installation commands (can't use AUR helpers)
// paru and yay can't install themselves via AUR helpers (chicken-and-egg problem)
if pkg == "paru" || pkg == "yay" {
let cmd = if pkg == "paru" {
// Use temporary directory to avoid conflicts with existing directories
"tmp=$(mktemp -d) && cd \"$tmp\" && git clone https://aur.archlinux.org/paru.git && cd paru && makepkg -si"
.to_string()
} else {
// yay
// Use temporary directory to avoid conflicts with existing directories
"tmp=$(mktemp -d) && cd \"$tmp\" && git clone https://aur.archlinux.org/yay.git && cd yay && makepkg -si"
.to_string()
};
// Create a dummy PackageItem for display in PreflightExec modal
let item = PackageItem {
name: pkg,
version: String::new(),
description: String::new(),
source: Source::Aur,
popularity: None,
out_of_date: None,
orphaned: false,
};
// These commands need sudo (makepkg -si), so prompt for password first
// Check faillock status before showing password prompt
let username = std::env::var("USER").unwrap_or_else(|_| "user".to_string());
if let Some(lockout_msg) =
crate::logic::faillock::get_lockout_message_if_locked(&username, app)
{
// User is locked out - show warning and don't show password prompt
app.modal = crate::state::Modal::Alert {
message: lockout_msg,
};
return (crate::state::Modal::None, false);
}
app.modal = crate::state::Modal::PasswordPrompt {
purpose: crate::state::modal::PasswordPurpose::Install,
items: vec![item],
input: String::new(),
cursor: 0,
error: None,
};
// Store the custom command and header chips for after password prompt
app.pending_custom_command = Some(cmd);
app.pending_exec_header_chips = Some(crate::state::modal::PreflightHeaderChips {
package_count: 1,
download_bytes: 0,
install_delta_bytes: 0,
aur_count: 1,
risk_score: 0,
risk_level: crate::state::modal::RiskLevel::Low,
});
return (app.modal.clone(), false);
}
// Regular packages: determine if official or AUR
let (package_item, is_aur) = crate::index::find_package_by_name(&pkg).map_or_else(
|| {
// Assume AUR if not found in official index
(
PackageItem {
name: pkg.clone(),
version: String::new(),
description: String::new(),
source: Source::Aur,
popularity: None,
out_of_date: None,
orphaned: false,
},
true,
)
},
|official_item| (official_item, false),
);
// For rate-mirrors and semgrep-bin, use AUR helper if available
let use_aur_helper = is_aur || pkg == "rate-mirrors" || pkg == "semgrep-bin";
// Transition to PreflightExec modal
app.modal = crate::state::Modal::PreflightExec {
items: vec![package_item.clone()],
action: crate::state::PreflightAction::Install,
tab: crate::state::PreflightTab::Summary,
verbose: false,
log_lines: Vec::new(),
success: None,
abortable: false,
header_chips: crate::state::modal::PreflightHeaderChips {
package_count: 1,
download_bytes: 0,
install_delta_bytes: 0,
aur_count: usize::from(use_aur_helper),
risk_score: 0,
risk_level: crate::state::modal::RiskLevel::Low,
},
};
// Store executor request for processing in tick handler
app.pending_executor_request = Some(ExecutorRequest::Install {
items: vec![package_item],
password: None, // Password will be prompted if needed for official packages
dry_run: app.dry_run,
});
return (app.modal.clone(), true);
}
(crate::state::Modal::None, false)
}
#[cfg(test)]
mod tests;
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/modals/install.rs | src/events/modals/install.rs | //! Install and remove modal handling.
use crossterm::event::{KeyCode, KeyEvent};
use crate::state::{AppState, PackageItem};
/// What: Handle key events for `ConfirmInstall` modal.
///
/// Inputs:
/// - `ke`: Key event
/// - `app`: Mutable application state
/// - `items`: Package items to install
///
/// Output:
/// - `false` (never stops propagation)
///
/// Details:
/// - Handles Esc to close, Enter to install, s to scan
pub(super) fn handle_confirm_install(
ke: KeyEvent,
app: &mut AppState,
items: &[PackageItem],
) -> bool {
match ke.code {
KeyCode::Esc => {
app.modal = crate::state::Modal::None;
}
KeyCode::Enter => {
let new_modal = handle_confirm_install_enter(
&mut app.refresh_installed_until,
&mut app.next_installed_refresh_at,
&mut app.pending_install_names,
app.dry_run,
items,
);
app.modal = new_modal;
}
KeyCode::Char('s' | 'S') => {
let new_modal = handle_confirm_install_scan(&mut app.pending_install_names, items);
app.modal = new_modal;
}
_ => {}
}
false
}
/// What: Handle key events for `ConfirmRemove` modal.
///
/// Inputs:
/// - `ke`: Key event
/// - `app`: Mutable application state
/// - `items`: Package items to remove
///
/// Output:
/// - `false` (never stops propagation)
///
/// Details:
/// - Handles Esc/Enter to cancel (defaults to No)
/// - Only proceeds with removal if user explicitly presses 'y' or 'Y'
pub(super) fn handle_confirm_remove(
ke: KeyEvent,
app: &mut AppState,
items: &[PackageItem],
) -> bool {
match ke.code {
KeyCode::Esc | KeyCode::Enter => {
// Cancel removal (defaults to No)
app.modal = crate::state::Modal::None;
}
KeyCode::Char('y' | 'Y') => {
// Explicit confirmation required - proceed with removal using integrated process
let names: Vec<String> = items.iter().map(|p| p.name.clone()).collect();
crate::install::start_integrated_remove_all(
app,
&names,
app.dry_run,
app.remove_cascade_mode,
);
// Clear remove list and state
app.remove_list
.retain(|p| !names.iter().any(|n| n == &p.name));
app.remove_state.select(None);
// Set up refresh tracking for non-dry-run
if !app.dry_run {
app.refresh_installed_until =
Some(std::time::Instant::now() + std::time::Duration::from_secs(8));
app.next_installed_refresh_at = None;
app.pending_remove_names = Some(names);
}
app.modal = crate::state::Modal::None;
}
_ => {}
}
false
}
/// What: Execute package installation.
///
/// Inputs:
/// - `refresh_installed_until`: Mutable reference to refresh timer
/// - `next_installed_refresh_at`: Mutable reference to next refresh time
/// - `pending_install_names`: Mutable reference to pending install names
/// - `dry_run`: Whether to run in dry-run mode
/// - `items`: Package items to install
///
/// Output: New modal state (always None after install)
///
/// Details:
/// - Spawns install command(s) and sets up refresh tracking
fn handle_confirm_install_enter(
refresh_installed_until: &mut Option<std::time::Instant>,
next_installed_refresh_at: &mut Option<std::time::Instant>,
pending_install_names: &mut Option<Vec<String>>,
dry_run: bool,
items: &[PackageItem],
) -> crate::state::Modal {
let list = items.to_vec();
// Note: This function is called from ConfirmInstall modal which doesn't have AppState access
// We need to use the old terminal spawning functions here since we can't transition to PreflightExec
// without AppState. The integrated process functions require AppState to set modals.
// TODO: Refactor ConfirmInstall modal to have AppState access or pass it as parameter
if list.len() <= 1 {
if let Some(it) = list.first() {
crate::install::spawn_install(it, None, dry_run);
if !dry_run {
*refresh_installed_until =
Some(std::time::Instant::now() + std::time::Duration::from_secs(12));
*next_installed_refresh_at = None;
*pending_install_names = Some(vec![it.name.clone()]);
}
}
} else {
// Note: batch updates confirmation is handled in preflight or install handlers
// This path is for ConfirmInstall modal which doesn't have AppState access
crate::install::spawn_install_all(&list, dry_run);
if !dry_run {
*refresh_installed_until =
Some(std::time::Instant::now() + std::time::Duration::from_secs(12));
*next_installed_refresh_at = None;
*pending_install_names = Some(list.iter().map(|p| p.name.clone()).collect());
}
}
crate::state::Modal::None
}
/// What: Setup scan configuration for AUR packages.
///
/// Inputs:
/// - `pending_install_names`: Mutable reference to pending install names
/// - `items`: Package items to scan
///
/// Output: New modal state (Alert or `ScanConfig`)
///
/// Details:
/// - Filters AUR packages and opens scan configuration modal
fn handle_confirm_install_scan(
pending_install_names: &mut Option<Vec<String>>,
items: &[PackageItem],
) -> crate::state::Modal {
let list = items.to_vec();
let mut names: Vec<String> = Vec::new();
for it in &list {
if matches!(it.source, crate::state::Source::Aur) {
names.push(it.name.clone());
}
}
if names.is_empty() {
crate::state::Modal::Alert {
message: "No AUR packages selected to scan.\nSelect AUR results or add AUR packages to the Install list, then press 's'.".into(),
}
} else {
*pending_install_names = Some(names);
let prefs = crate::theme::settings();
crate::state::Modal::ScanConfig {
do_clamav: prefs.scan_do_clamav,
do_trivy: prefs.scan_do_trivy,
do_semgrep: prefs.scan_do_semgrep,
do_shellcheck: prefs.scan_do_shellcheck,
do_virustotal: prefs.scan_do_virustotal,
do_custom: prefs.scan_do_custom,
do_sleuth: prefs.scan_do_sleuth,
cursor: 0,
}
}
}
// Removed handle_confirm_remove_execute - now handled inline in handle_confirm_remove
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/modals/mod.rs | src/events/modals/mod.rs | //! Modal event handling module (excluding Preflight which is in preflight.rs).
mod common;
mod handlers;
mod import;
mod install;
mod optional_deps;
mod password;
mod restore;
mod scan;
mod system_update;
#[cfg(test)]
mod tests;
use crossterm::event::KeyEvent;
use tokio::sync::mpsc;
use crate::state::{AppState, Modal, PackageItem};
/// What: Handle key events for every modal except Preflight, mutating UI state as needed.
///
/// Inputs:
/// - `ke`: Key event delivered while a non-Preflight modal is active
/// - `app`: Mutable application state holding the active modal and related data
/// - `add_tx`: Channel used to enqueue packages into the install list from modal actions
///
/// Output:
/// - `true` if the event is fully handled and should not propagate to other handlers; otherwise `false`.
///
/// Details:
/// - Covers Alert, `PreflightExec`, `PostSummary`, `SystemUpdate`, `ConfirmInstall`/`Remove`, Help, News,
/// `OptionalDeps`, `VirusTotalSetup`, `ScanConfig`, `ImportHelp`, and other lightweight modals.
/// - Each branch performs modal-specific mutations (toggles, list navigation, spawning commands) and
/// is responsible for clearing or restoring `app.modal` when exiting.
/// - When a modal should block further processing this function returns `true`, allowing callers to
/// short-circuit additional event handling.
pub(super) fn handle_modal_key(
ke: KeyEvent,
app: &mut AppState,
add_tx: &mpsc::UnboundedSender<PackageItem>,
) -> bool {
// Use a temporary to avoid borrow checker issues
let modal = std::mem::take(&mut app.modal);
match modal {
Modal::Alert { .. } => handlers::handle_alert_modal(ke, app, &modal),
Modal::PreflightExec { .. } => handlers::handle_preflight_exec_modal(ke, app, modal),
Modal::PostSummary { .. } => handlers::handle_post_summary_modal(ke, app, &modal),
Modal::SystemUpdate { .. } => handlers::handle_system_update_modal(ke, app, modal),
Modal::ConfirmInstall { .. } => handlers::handle_confirm_install_modal(ke, app, &modal),
Modal::ConfirmRemove { .. } => handlers::handle_confirm_remove_modal(ke, app, &modal),
Modal::ConfirmReinstall { .. } => handlers::handle_confirm_reinstall_modal(ke, app, &modal),
Modal::ConfirmBatchUpdate { .. } => {
handlers::handle_confirm_batch_update_modal(ke, app, &modal)
}
Modal::ConfirmAurUpdate { .. } => {
handlers::handle_confirm_aur_update_modal(ke, app, &modal)
}
Modal::Help => handlers::handle_help_modal(ke, app, modal),
Modal::News { .. } => handlers::handle_news_modal(ke, app, modal),
Modal::Announcement { .. } => handlers::handle_announcement_modal(ke, app, modal),
Modal::Updates { .. } => handlers::handle_updates_modal(ke, app, modal),
Modal::OptionalDeps { .. } => handlers::handle_optional_deps_modal(ke, app, modal),
Modal::ScanConfig { .. } => handlers::handle_scan_config_modal(ke, app, modal),
Modal::VirusTotalSetup { .. } => handlers::handle_virustotal_setup_modal(ke, app, modal),
Modal::NewsSetup { .. } => handlers::handle_news_setup_modal(ke, app, modal),
Modal::PasswordPrompt { .. } => handlers::handle_password_prompt_modal(ke, app, modal),
Modal::GnomeTerminalPrompt => handlers::handle_gnome_terminal_prompt_modal(ke, app, modal),
Modal::ImportHelp => handlers::handle_import_help_modal(ke, app, add_tx, modal),
Modal::None => false,
Modal::Loading { .. } => {
// Loading modal - ignore key input while waiting for background task
app.modal = modal;
true // Consume key to prevent propagation
}
Modal::Preflight { .. } => {
// Preflight is handled separately in preflight.rs
// Restore it - we shouldn't have gotten here, but be safe
app.modal = modal;
false
}
}
}
#[cfg(test)]
/// Test-only public wrapper for `handle_modal_key` to allow tests to access it
pub fn handle_modal_key_test(
ke: KeyEvent,
app: &mut AppState,
add_tx: &mpsc::UnboundedSender<PackageItem>,
) -> bool {
handle_modal_key(ke, app, add_tx)
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/modals/common.rs | src/events/modals/common.rs | //! Common modal handlers (Alert, Help, News, `PreflightExec`, `PostSummary`, `GnomeTerminalPrompt`).
use crossterm::event::{KeyCode, KeyEvent};
use crate::state::{AppState, PackageItem, Source};
/// What: Show next pending announcement from queue if available.
///
/// Inputs:
/// - `app`: Application state to update
///
/// Output: None (modifies app state in place)
///
/// Details:
/// - Checks if there are pending announcements in the queue
/// - Shows the first valid announcement if modal is currently None
fn show_next_pending_announcement(app: &mut AppState) {
const CURRENT_VERSION: &str = env!("CARGO_PKG_VERSION");
// Only show if no modal is currently displayed
if !matches!(app.modal, crate::state::Modal::None) {
tracing::debug!("skipping pending announcement check (modal still open)");
return;
}
tracing::debug!(
queue_size = app.pending_announcements.len(),
"checking for pending announcements"
);
// Find next valid announcement in queue
while let Some(announcement) = app.pending_announcements.first() {
// Check version range
if !crate::announcements::version_matches(
CURRENT_VERSION,
announcement.min_version.as_deref(),
announcement.max_version.as_deref(),
) {
tracing::debug!(
id = %announcement.id,
"pending announcement version range mismatch, removing from queue"
);
app.pending_announcements.remove(0);
continue;
}
// Check expiration
if crate::announcements::is_expired(announcement.expires.as_deref()) {
tracing::debug!(
id = %announcement.id,
"pending announcement expired, removing from queue"
);
app.pending_announcements.remove(0);
continue;
}
// Check if already read
if app.announcements_read_ids.contains(&announcement.id) {
tracing::debug!(
id = %announcement.id,
"pending announcement already read, removing from queue"
);
app.pending_announcements.remove(0);
continue;
}
// Show this announcement
let announcement = app.pending_announcements.remove(0);
let announcement_id = announcement.id.clone();
app.modal = crate::state::Modal::Announcement {
title: announcement.title,
content: announcement.content,
id: announcement_id.clone(),
scroll: 0,
};
tracing::info!(id = %announcement_id, "showing pending announcement");
return;
}
tracing::debug!(
queue_empty = app.pending_announcements.is_empty(),
"no more pending announcements"
);
// After all announcements are shown, check for pending news
tracing::debug!(
pending_news_exists = app.pending_news.is_some(),
news_loading = app.news_loading,
"checking for pending news after announcements"
);
if let Some(news_items) = app.pending_news.take()
&& !news_items.is_empty()
{
tracing::info!(
news_items_count = news_items.len(),
news_loading_before = app.news_loading,
"showing pending news after announcements"
);
// Clear loading flag when news modal is actually shown
app.news_loading = false;
// Convert NewsItem to NewsFeedItem for the modal, filtering out read items
let feed_items: Vec<crate::state::types::NewsFeedItem> = news_items
.into_iter()
.filter(|item| {
// Filter out items marked as read by ID or URL
!app.news_read_ids.contains(&item.url) && !app.news_read_urls.contains(&item.url)
})
.map(|item| crate::state::types::NewsFeedItem {
id: item.url.clone(),
date: item.date,
title: item.title,
summary: None,
url: Some(item.url),
source: crate::state::types::NewsFeedSource::ArchNews,
severity: None,
packages: Vec::new(),
})
.collect();
// Only show modal if there are unread items
if feed_items.is_empty() {
tracing::debug!("all pending news items have been read, not showing modal");
} else {
app.modal = crate::state::Modal::News {
items: feed_items,
selected: 0,
scroll: 0,
};
tracing::info!(
news_loading_after = app.news_loading,
"pending news modal set, loading flag cleared"
);
}
} else if app.pending_news.is_some() {
tracing::debug!("pending news exists but is empty, not showing");
}
}
/// What: Handle key events for Alert modal.
///
/// Inputs:
/// - `ke`: Key event
/// - `app`: Mutable application state
/// - `message`: Alert message content
///
/// Output:
/// - `true` if Esc was pressed (to stop propagation), `false` otherwise
///
/// Details:
/// - Handles Enter/Esc to close, Up/Down for help scrolling
/// - Returns `true` for Esc to prevent mode toggling in search handler
pub(super) fn handle_alert(ke: KeyEvent, app: &mut AppState, message: &str) -> bool {
let is_help = message.contains("Help") || message.contains("Tab Help");
let is_lockout = message.contains("locked") || message.contains("lockout");
match ke.code {
KeyCode::Esc => {
if is_help {
app.help_scroll = 0; // Reset scroll when closing
}
// For lockout alerts, clear any pending executor state to abort the process
if is_lockout {
app.pending_executor_password = None;
app.pending_exec_header_chips = None;
app.pending_executor_request = None;
}
// Restore previous modal if it was Preflight, otherwise close
if let Some(prev_modal) = app.previous_modal.take() {
app.modal = prev_modal;
} else {
app.modal = crate::state::Modal::None;
}
true // Stop propagation to prevent mode toggle
}
KeyCode::Enter => {
if is_help {
app.help_scroll = 0; // Reset scroll when closing
}
// For lockout alerts, clear any pending executor state to abort the process
if is_lockout {
app.pending_executor_password = None;
app.pending_exec_header_chips = None;
app.pending_executor_request = None;
}
// Restore previous modal if it was Preflight, otherwise close
if let Some(prev_modal) = app.previous_modal.take() {
app.modal = prev_modal;
} else {
app.modal = crate::state::Modal::None;
}
// Return true for lockout alerts to stop propagation and abort the process
is_lockout
}
KeyCode::Up if is_help => {
app.help_scroll = app.help_scroll.saturating_sub(1);
false
}
KeyCode::Down if is_help => {
app.help_scroll = app.help_scroll.saturating_add(1);
false
}
_ => false,
}
}
/// What: Handle key events for `PreflightExec` modal.
///
/// Inputs:
/// - `ke`: Key event
/// - `app`: Mutable application state
/// - `verbose`: Mutable reference to verbose flag
/// - `abortable`: Whether execution can be aborted
/// - `items`: Package items being processed
/// - `success`: Execution success status from the modal
///
/// Output:
/// - `true` when modal is closed/transitioned to stop propagation, `false` otherwise
///
/// Details:
/// - Handles Esc/q to close, Enter to show summary, l to toggle verbose, x to abort
/// - Success must be passed in since app.modal is taken during dispatch
pub(super) fn handle_preflight_exec(
ke: KeyEvent,
app: &mut AppState,
verbose: &mut bool,
abortable: bool,
items: &[crate::state::PackageItem],
success: Option<bool>,
) -> bool {
match ke.code {
KeyCode::Esc | KeyCode::Char('q') => {
app.modal = crate::state::Modal::None;
true // Stop propagation
}
KeyCode::Enter => {
// Check if this is a scan (items have names starting with "scan:")
let is_scan = items.iter().any(|item| item.name.starts_with("scan:"));
if is_scan {
// For scans, skip PostSummary and go directly back to Preflight
if let Some(prev_modal) = app.previous_modal.take() {
if matches!(prev_modal, crate::state::Modal::Preflight { .. }) {
app.modal = prev_modal;
return true; // Stop propagation
}
// If it's not Preflight, put it back and close normally
app.previous_modal = Some(prev_modal);
}
app.modal = crate::state::Modal::None;
return true; // Stop propagation
}
// For regular installs, show loading modal and queue background computation
// Use the success flag passed in from the modal (app.modal is taken during dispatch)
app.pending_post_summary_items = Some((items.to_vec(), success));
app.modal = crate::state::Modal::Loading {
message: "Computing summary...".to_string(),
};
true // Stop propagation - transitioning to Loading
}
KeyCode::Char('l') => {
*verbose = !*verbose;
let verbose_status = if *verbose { "ON" } else { "OFF" };
app.toast_message = Some(format!("Verbose: {verbose_status}"));
false
}
// TODO: implement Logic for aborting the transaction
KeyCode::Char('x') => {
if abortable {
app.toast_message = Some(crate::i18n::t(app, "app.toasts.abort_requested"));
}
false
}
_ => false,
}
}
/// What: Handle key events for `PostSummary` modal.
///
/// Inputs:
/// - `ke`: Key event
/// - `app`: Mutable application state
/// - `services_pending`: List of services pending restart
///
/// Output:
/// - `false` (never stops propagation)
///
/// Details:
/// - Handles Esc/Enter/q to close, r for rollback, s for service restart
/// - Returns `true` when closing modal to stop key propagation
pub(super) fn handle_post_summary(
ke: KeyEvent,
app: &mut AppState,
services_pending: &[String],
) -> bool {
match ke.code {
// Close modal and stop propagation to prevent key from reaching other handlers
KeyCode::Esc | KeyCode::Enter | KeyCode::Char('q') => {
app.modal = crate::state::Modal::None;
true // Stop propagation - prevents Enter from opening preflight again
}
KeyCode::Char('r') => {
app.toast_message = Some(crate::i18n::t(app, "app.toasts.rollback"));
false
}
// TODO: implement Logic for restarting the services
KeyCode::Char('s') => {
if services_pending.is_empty() {
app.toast_message = Some(crate::i18n::t(app, "app.toasts.no_services_to_restart"));
} else {
app.toast_message = Some(crate::i18n::t(app, "app.toasts.restart_services"));
}
false
}
_ => false,
}
}
/// What: Handle key events for Help modal.
///
/// Inputs:
/// - `ke`: Key event
/// - `app`: Mutable application state
///
/// Output:
/// - `true` if Esc was pressed (to stop propagation), otherwise `false`
///
/// Details:
/// - Handles Esc/Enter to close
/// - Returns `true` for Esc to prevent mode toggling in search handler
pub(super) fn handle_help(ke: KeyEvent, app: &mut AppState) -> bool {
match ke.code {
KeyCode::Esc => {
app.modal = crate::state::Modal::None;
true // Stop propagation to prevent mode toggle
}
KeyCode::Enter => {
app.modal = crate::state::Modal::None;
false
}
_ => false,
}
}
/// What: Calculate scroll offset to keep the selected item in the middle of the viewport.
///
/// Inputs:
/// - `selected`: Currently selected item index
/// - `total_items`: Total number of items in the list
/// - `visible_height`: Height of the visible content area (in lines)
///
/// Output:
/// - Scroll offset (lines) that centers the selected item
///
/// Details:
/// - Calculates scroll so selected item is in the middle of visible area
/// - Ensures scroll doesn't go negative or past the end
#[cfg_attr(test, allow(dead_code))]
fn calculate_news_scroll_for_selection(
selected: usize,
total_items: usize,
visible_height: u16,
) -> u16 {
if total_items == 0 || visible_height == 0 {
return 0;
}
// Clamp values to u16::MAX to prevent overflow in calculations.
// Note: If selected or total_items exceeds u16::MAX, the scroll calculation will be
// performed for the clamped values, which may not match the actual selected item.
// This is acceptable since u16::MAX (65535) is far beyond practical UI list sizes.
let selected_line = u16::try_from(selected).unwrap_or(u16::MAX);
let total_lines = u16::try_from(total_items).unwrap_or(u16::MAX);
// Ensure selected doesn't exceed total after clamping to maintain valid calculations
let selected_line = selected_line.min(total_lines);
// Calculate middle position: we want selected item to be at visible_height / 2
let middle_offset = visible_height / 2;
// Calculate desired scroll to center the selection
let desired_scroll = selected_line.saturating_sub(middle_offset);
// Calculate maximum scroll (when last item is at the bottom)
let max_scroll = total_lines.saturating_sub(visible_height);
// Clamp scroll to valid range
desired_scroll.min(max_scroll)
}
#[cfg(test)]
mod news_tests {
use super::*;
use crate::state::{AppState, types::NewsFeedItem, types::NewsFeedSource};
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
#[test]
/// What: Test `calculate_news_scroll_for_selection` centers selected item.
///
/// Inputs:
/// - Selected index, total items, visible height.
///
/// Output:
/// - Scroll offset that centers selection within viewport bounds.
///
/// Details:
/// - Verifies scroll calculation clamps to valid range.
fn test_calculate_news_scroll_for_selection() {
// Test: center item in middle of list
let scroll = calculate_news_scroll_for_selection(5, 10, 5);
assert!(scroll <= 5, "Scroll should not exceed max");
// Test: first item (should scroll to 0)
let scroll = calculate_news_scroll_for_selection(0, 10, 5);
assert_eq!(scroll, 0, "First item should have scroll 0");
// Test: empty list
let scroll = calculate_news_scroll_for_selection(0, 0, 5);
assert_eq!(scroll, 0, "Empty list should return 0");
// Test: zero height
let scroll = calculate_news_scroll_for_selection(5, 10, 0);
assert_eq!(scroll, 0, "Zero height should return 0");
}
#[test]
/// What: Test `handle_news` marks item as read when keymap chord is pressed.
///
/// Inputs:
/// - News modal with items, keymap chord for mark-read.
///
/// Output:
/// - Selected item added to `news_read_ids` and `news_read_urls`, dirty flags set.
///
/// Details:
/// - Verifies read-state mutation and dirty flag handling.
/// - Only works in normal mode.
#[allow(clippy::field_reassign_with_default)] // Field assignment in tests is acceptable for test setup
fn test_handle_news_mark_read() {
let mut app = AppState::default();
app.search_normal_mode = true; // Must be in normal mode
app.keymap.news_mark_read = [crate::theme::KeyChord {
code: KeyCode::Char('r'),
mods: KeyModifiers::empty(),
}]
.into();
let items = vec![NewsFeedItem {
id: "test-id-1".to_string(),
date: "2025-01-01".to_string(),
title: "Test News".to_string(),
summary: None,
url: Some("https://example.com/news/1".to_string()),
source: NewsFeedSource::ArchNews,
severity: None,
packages: Vec::new(),
}];
let mut selected = 0;
let mut scroll = 0;
let mut ke = KeyEvent::new(KeyCode::Char('r'), KeyModifiers::empty());
ke.kind = crossterm::event::KeyEventKind::Press;
let _ = handle_news(ke, &mut app, &items, &mut selected, &mut scroll);
assert!(app.news_read_ids.contains("test-id-1"));
assert!(app.news_read_urls.contains("https://example.com/news/1"));
assert!(app.news_read_ids_dirty);
assert!(app.news_read_dirty);
}
#[test]
/// What: Test `handle_news` marks all items as read when mark-all-read chord is pressed.
///
/// Inputs:
/// - News modal with multiple items, keymap chord for mark-all-read.
///
/// Output:
/// - All items added to read sets, dirty flags set.
///
/// Details:
/// - Verifies bulk read-state mutation.
/// - Only works in normal mode.
#[allow(clippy::field_reassign_with_default)] // Field assignment in tests is acceptable for test setup
fn test_handle_news_mark_all_read() {
let mut app = AppState::default();
app.search_normal_mode = true; // Must be in normal mode
app.keymap.news_mark_all_read = [crate::theme::KeyChord {
code: KeyCode::Char('r'),
mods: KeyModifiers::CONTROL,
}]
.into();
let items = vec![
NewsFeedItem {
id: "test-id-1".to_string(),
date: "2025-01-01".to_string(),
title: "Test News 1".to_string(),
summary: None,
url: Some("https://example.com/news/1".to_string()),
source: NewsFeedSource::ArchNews,
severity: None,
packages: Vec::new(),
},
NewsFeedItem {
id: "test-id-2".to_string(),
date: "2025-01-02".to_string(),
title: "Test News 2".to_string(),
summary: None,
url: Some("https://example.com/news/2".to_string()),
source: NewsFeedSource::ArchNews,
severity: None,
packages: Vec::new(),
},
];
let mut selected = 0;
let mut scroll = 0;
let mut ke = KeyEvent::new(KeyCode::Char('r'), KeyModifiers::CONTROL);
ke.kind = crossterm::event::KeyEventKind::Press;
let _ = handle_news(ke, &mut app, &items, &mut selected, &mut scroll);
assert!(app.news_read_ids.contains("test-id-1"));
assert!(app.news_read_ids.contains("test-id-2"));
assert!(app.news_read_urls.contains("https://example.com/news/1"));
assert!(app.news_read_urls.contains("https://example.com/news/2"));
assert!(app.news_read_ids_dirty);
assert!(app.news_read_dirty);
}
#[test]
/// What: Test `handle_news` navigation updates selection and scroll.
///
/// Inputs:
/// - News modal with items, navigation keys (Up/Down).
///
/// Output:
/// - Selection index updated, scroll recalculated.
///
/// Details:
/// - Verifies navigation updates selection and scroll centering.
#[allow(clippy::field_reassign_with_default)] // Field assignment in tests is acceptable for test setup
fn test_handle_news_navigation() {
let mut app = AppState::default();
app.news_list_rect = Some((0, 0, 50, 10)); // visible height = 10
let items = vec![
NewsFeedItem {
id: "test-id-1".to_string(),
date: "2025-01-01".to_string(),
title: "Test News 1".to_string(),
summary: None,
url: None,
source: NewsFeedSource::ArchNews,
severity: None,
packages: Vec::new(),
},
NewsFeedItem {
id: "test-id-2".to_string(),
date: "2025-01-02".to_string(),
title: "Test News 2".to_string(),
summary: None,
url: None,
source: NewsFeedSource::ArchNews,
severity: None,
packages: Vec::new(),
},
];
let mut selected = 0;
let mut scroll = 0;
// Test Down key
let mut ke = KeyEvent::new(KeyCode::Down, KeyModifiers::empty());
ke.kind = crossterm::event::KeyEventKind::Press;
let _ = handle_news(ke, &mut app, &items, &mut selected, &mut scroll);
assert_eq!(selected, 1, "Down should increment selection");
// Test Up key
let mut ke = KeyEvent::new(KeyCode::Up, KeyModifiers::empty());
ke.kind = crossterm::event::KeyEventKind::Press;
let _ = handle_news(ke, &mut app, &items, &mut selected, &mut scroll);
assert_eq!(selected, 0, "Up should decrement selection");
}
#[test]
/// What: Test `handle_news` does not mark item as read when in insert mode.
///
/// Inputs:
/// - News modal with items, keymap chord for mark-read, but in insert mode.
///
/// Output:
/// - Item should NOT be added to read sets when in insert mode.
///
/// Details:
/// - Verifies that mark read only works in normal mode, not insert mode.
#[allow(clippy::field_reassign_with_default)] // Field assignment in tests is acceptable for test setup
fn test_handle_news_mark_read_insert_mode() {
let mut app = AppState::default();
app.search_normal_mode = false; // Insert mode
app.keymap.news_mark_read = [crate::theme::KeyChord {
code: KeyCode::Char('r'),
mods: KeyModifiers::empty(),
}]
.into();
let items = vec![NewsFeedItem {
id: "test-id-1".to_string(),
date: "2025-01-01".to_string(),
title: "Test News".to_string(),
summary: None,
url: Some("https://example.com/news/1".to_string()),
source: NewsFeedSource::ArchNews,
severity: None,
packages: Vec::new(),
}];
let mut selected = 0;
let mut scroll = 0;
let mut ke = KeyEvent::new(KeyCode::Char('r'), KeyModifiers::empty());
ke.kind = crossterm::event::KeyEventKind::Press;
let _ = handle_news(ke, &mut app, &items, &mut selected, &mut scroll);
// In insert mode, 'r' should not mark as read
assert!(!app.news_read_ids.contains("test-id-1"));
assert!(!app.news_read_urls.contains("https://example.com/news/1"));
assert!(!app.news_read_ids_dirty);
assert!(!app.news_read_dirty);
}
#[test]
/// What: Test `handle_news` does not mark all items as read when in insert mode.
///
/// Inputs:
/// - News modal with multiple items, keymap chord for mark-all-read, but in insert mode.
///
/// Output:
/// - Items should NOT be added to read sets when in insert mode.
///
/// Details:
/// - Verifies that mark all read only works in normal mode, not insert mode.
#[allow(clippy::field_reassign_with_default)] // Field assignment in tests is acceptable for test setup
fn test_handle_news_mark_all_read_insert_mode() {
let mut app = AppState::default();
app.search_normal_mode = false; // Insert mode
app.keymap.news_mark_all_read = [crate::theme::KeyChord {
code: KeyCode::Char('r'),
mods: KeyModifiers::CONTROL,
}]
.into();
let items = vec![
NewsFeedItem {
id: "test-id-1".to_string(),
date: "2025-01-01".to_string(),
title: "Test News 1".to_string(),
summary: None,
url: Some("https://example.com/news/1".to_string()),
source: NewsFeedSource::ArchNews,
severity: None,
packages: Vec::new(),
},
NewsFeedItem {
id: "test-id-2".to_string(),
date: "2025-01-02".to_string(),
title: "Test News 2".to_string(),
summary: None,
url: Some("https://example.com/news/2".to_string()),
source: NewsFeedSource::ArchNews,
severity: None,
packages: Vec::new(),
},
];
let mut selected = 0;
let mut scroll = 0;
let mut ke = KeyEvent::new(KeyCode::Char('r'), KeyModifiers::CONTROL);
ke.kind = crossterm::event::KeyEventKind::Press;
let _ = handle_news(ke, &mut app, &items, &mut selected, &mut scroll);
// In insert mode, Ctrl+R should not mark as read
assert!(!app.news_read_ids.contains("test-id-1"));
assert!(!app.news_read_ids.contains("test-id-2"));
assert!(!app.news_read_urls.contains("https://example.com/news/1"));
assert!(!app.news_read_urls.contains("https://example.com/news/2"));
assert!(!app.news_read_ids_dirty);
assert!(!app.news_read_dirty);
}
}
/// What: Handle key events for News modal.
///
/// Inputs:
/// - `ke`: Key event
/// - `app`: Mutable application state
/// - `items`: News feed items
/// - `selected`: Currently selected item index
/// - `scroll`: Mutable scroll offset
///
/// Output:
/// - `true` if Esc was pressed (to stop propagation), otherwise `false`
///
/// Details:
/// - Handles Esc/q to close, navigation, Enter to open URL, keymap shortcuts for marking read
/// - Updates scroll to keep selection centered
/// - Mark read actions only work in normal mode (not insert mode)
pub(super) fn handle_news(
ke: KeyEvent,
app: &mut AppState,
items: &[crate::state::types::NewsFeedItem],
selected: &mut usize,
scroll: &mut u16,
) -> bool {
let km = &app.keymap;
if crate::events::utils::matches_any(&ke, &km.news_mark_read) {
// Mark as read only works in normal mode
if !app.search_normal_mode {
return false;
}
if let Some(it) = items.get(*selected) {
// Mark as read using id (primary) and url if available
app.news_read_ids.insert(it.id.clone());
app.news_read_ids_dirty = true;
if let Some(url) = &it.url {
app.news_read_urls.insert(url.clone());
app.news_read_dirty = true;
}
}
return false;
}
if crate::events::utils::matches_any(&ke, &km.news_mark_all_read) {
// Mark all as read only works in normal mode
if !app.search_normal_mode {
return false;
}
for it in items {
app.news_read_ids.insert(it.id.clone());
if let Some(url) = &it.url {
app.news_read_urls.insert(url.clone());
}
}
app.news_read_ids_dirty = true;
app.news_read_dirty = true;
return false;
}
match ke.code {
KeyCode::Esc | KeyCode::Char('q') => {
app.modal = crate::state::Modal::None;
return true; // Stop propagation to prevent global Esc handler from running
}
KeyCode::Up | KeyCode::Char('k') => {
if *selected > 0 {
*selected -= 1;
// Update scroll to keep selection centered
if let Some((_, _, _, visible_h)) = app.news_list_rect {
*scroll =
calculate_news_scroll_for_selection(*selected, items.len(), visible_h);
}
}
}
KeyCode::Down | KeyCode::Char('j') => {
if *selected + 1 < items.len() {
*selected += 1;
// Update scroll to keep selection centered
if let Some((_, _, _, visible_h)) = app.news_list_rect {
*scroll =
calculate_news_scroll_for_selection(*selected, items.len(), visible_h);
}
}
}
KeyCode::PageUp => {
if *selected >= 10 {
*selected -= 10;
} else {
*selected = 0;
}
if let Some((_, _, _, visible_h)) = app.news_list_rect {
*scroll = calculate_news_scroll_for_selection(*selected, items.len(), visible_h);
}
}
KeyCode::PageDown => {
let max_idx = items.len().saturating_sub(1);
*selected = (*selected + 10).min(max_idx);
if let Some((_, _, _, visible_h)) = app.news_list_rect {
*scroll = calculate_news_scroll_for_selection(*selected, items.len(), visible_h);
}
}
KeyCode::Char('d')
if ke
.modifiers
.contains(crossterm::event::KeyModifiers::CONTROL) =>
{
// Ctrl+D: page down (25 lines)
let max_idx = items.len().saturating_sub(1);
*selected = (*selected + 25).min(max_idx);
if let Some((_, _, _, visible_h)) = app.news_list_rect {
*scroll = calculate_news_scroll_for_selection(*selected, items.len(), visible_h);
}
}
KeyCode::Char('u')
if ke
.modifiers
.contains(crossterm::event::KeyModifiers::CONTROL) =>
{
// Ctrl+U: page up (20 lines)
if *selected >= 20 {
*selected -= 20;
} else {
*selected = 0;
}
if let Some((_, _, _, visible_h)) = app.news_list_rect {
*scroll = calculate_news_scroll_for_selection(*selected, items.len(), visible_h);
}
}
KeyCode::Enter => {
if let Some(it) = items.get(*selected)
&& let Some(url) = &it.url
{
crate::util::open_url(url);
}
}
_ => {}
}
false
}
/// What: Handle key events for Announcement modal.
///
/// Inputs:
/// - `ke`: Key event
/// - `app`: Mutable application state
/// - `id`: Unique identifier for this announcement (version string or remote ID)
/// - `scroll`: Mutable scroll offset
///
/// Output:
/// - `true` if Esc was pressed (to stop propagation), otherwise `false`
///
/// Details:
/// - "r" key: Mark as read (store ID, set dirty flag, close modal - won't show again)
/// - Enter/Esc/q: Dismiss temporarily (close modal without marking read - will show again)
/// - Arrow keys: Scroll content
pub(super) fn handle_announcement(
ke: crossterm::event::KeyEvent,
app: &mut AppState,
id: &str,
scroll: &mut u16,
) -> bool {
match ke.code {
crossterm::event::KeyCode::Char('r') => {
// Mark as read - won't show again
app.announcements_read_ids.insert(id.to_string());
app.announcement_dirty = true;
tracing::debug!(id = %id, "marked announcement as read, closing modal");
app.modal = crate::state::Modal::None;
// Show next pending announcement if any
show_next_pending_announcement(app);
return true; // Stop propagation
}
crossterm::event::KeyCode::Enter | crossterm::event::KeyCode::Esc => {
// Dismiss temporarily - will show again on next startup
tracing::debug!(id = %id, "dismissed announcement temporarily, closing modal");
app.modal = crate::state::Modal::None;
// Show next pending announcement if any
show_next_pending_announcement(app);
return true; // Stop propagation for both Enter and Esc
}
crossterm::event::KeyCode::Char('q') => {
// Dismiss temporarily
tracing::debug!(id = %id, "dismissed announcement temporarily, closing modal");
app.modal = crate::state::Modal::None;
// Show next pending announcement if any
show_next_pending_announcement(app);
return true; // Stop propagation
}
crossterm::event::KeyCode::Up | crossterm::event::KeyCode::Char('k') => {
if *scroll > 0 {
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | true |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/modals/import.rs | src/events/modals/import.rs | //! Import help modal handling.
use crossterm::event::{KeyCode, KeyEvent};
use tokio::sync::mpsc;
use crate::state::{AppState, PackageItem};
/// What: Handle key events for `ImportHelp` modal.
///
/// Inputs:
/// - `ke`: Key event
/// - `app`: Mutable application state
/// - `add_tx`: Channel for adding packages
///
/// Output:
/// - `false` (never stops propagation)
///
/// Details:
/// - Handles Esc to close, Enter to open file picker and import packages
pub(super) fn handle_import_help(
ke: KeyEvent,
app: &mut AppState,
add_tx: &mpsc::UnboundedSender<PackageItem>,
) -> bool {
match ke.code {
KeyCode::Enter => {
app.modal = crate::state::Modal::None;
handle_import_help_enter(add_tx);
}
KeyCode::Esc => app.modal = crate::state::Modal::None,
_ => {}
}
false
}
/// What: Handle Enter key in `ImportHelp` modal - open file picker and import packages.
///
/// Inputs:
/// - `add_tx`: Channel for adding packages
///
/// Output: None (spawns background thread)
///
/// Details:
/// - Opens file picker dialog and imports package names from selected file
/// - During tests, this is a no-op to avoid opening real file picker dialogs
#[allow(clippy::missing_const_for_fn)]
fn handle_import_help_enter(add_tx: &mpsc::UnboundedSender<PackageItem>) {
// Skip actual file picker during tests
// Note: add_tx is only used in non-test builds, but we acknowledge it for static analysis
#[cfg(test)]
let _ = add_tx;
#[cfg(not(test))]
{
tracing::info!("import: Enter pressed in ImportHelp modal");
let add_tx_clone = add_tx.clone();
std::thread::spawn(move || {
tracing::info!("import: thread started, opening file picker");
#[cfg(target_os = "windows")]
let path_opt: Option<String> = {
let script = r"
Add-Type -AssemblyName System.Windows.Forms
$ofd = New-Object System.Windows.Forms.OpenFileDialog
$ofd.Filter = 'Text Files (*.txt)|*.txt|All Files (*.*)|*.*'
$ofd.Multiselect = $false
if ($ofd.ShowDialog() -eq [System.Windows.Forms.DialogResult]::OK) { Write-Output $ofd.FileName }
";
let output = std::process::Command::new("powershell")
.args(["-NoProfile", "-Command", script])
.stdin(std::process::Stdio::null())
.output()
.ok();
output.and_then(|o| {
let s = String::from_utf8_lossy(&o.stdout).trim().to_string();
if s.is_empty() { None } else { Some(s) }
})
};
#[cfg(not(target_os = "windows"))]
let path_opt: Option<String> = {
let try_cmd = |prog: &str, args: &[&str]| -> Option<String> {
tracing::debug!(prog = %prog, "import: trying file picker");
let res = std::process::Command::new(prog)
.args(args)
.stdin(std::process::Stdio::null())
.output()
.ok()?;
let s = String::from_utf8_lossy(&res.stdout).trim().to_string();
if s.is_empty() {
tracing::debug!(prog = %prog, "import: file picker returned empty");
None
} else {
tracing::debug!(prog = %prog, path = %s, "import: file picker returned path");
Some(s)
}
};
try_cmd(
"zenity",
&[
"--file-selection",
"--title=Import packages",
"--file-filter=*.txt",
],
)
.or_else(|| {
tracing::debug!("import: zenity failed, trying kdialog");
try_cmd("kdialog", &["--getopenfilename", ".", "*.txt"])
})
};
if let Some(path) = path_opt {
let path = path.trim().to_string();
tracing::info!(path = %path, "import: selected file");
if let Ok(body) = std::fs::read_to_string(&path) {
use std::collections::HashSet;
let mut official_names: HashSet<String> = HashSet::new();
for it in &crate::index::all_official() {
official_names.insert(it.name.to_lowercase());
}
let mut imported: usize = 0;
for line in body.lines() {
let name = line.trim();
if name.is_empty() || name.starts_with('#') {
continue;
}
let src = if official_names.contains(&name.to_lowercase()) {
crate::state::Source::Official {
repo: String::new(),
arch: String::new(),
}
} else {
crate::state::Source::Aur
};
let item = crate::state::PackageItem {
name: name.to_string(),
version: String::new(),
description: String::new(),
source: src,
popularity: None,
out_of_date: None,
orphaned: false,
};
let _ = add_tx_clone.send(item);
imported += 1;
}
tracing::info!(path = %path, imported, "import: queued items from list");
} else {
tracing::warn!(path = %path, "import: failed to read file");
}
} else {
tracing::info!("import: canceled by user");
}
});
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/modals/restore.rs | src/events/modals/restore.rs | //! Helper functions for restoring modal state after event handling.
use crate::state::{AppState, Modal};
use crossterm::event::{KeyCode, KeyEvent};
/// What: Restore a modal if it wasn't closed by the handler and the key event
/// doesn't match any excluded keys.
///
/// Inputs:
/// - `app`: Mutable application state to check and restore modal in
/// - `ke`: Key event to check against excluded keys
/// - `excluded_keys`: Slice of key codes that should prevent restoration
/// - `modal`: Modal variant to restore if conditions are met
///
/// Output:
/// - None (mutates `app.modal` directly)
///
/// Details:
/// - Checks if `app.modal` is `None` (indicating handler closed it)
/// - If modal is still `None` and key doesn't match excluded keys, restores the modal
/// - Used for modals like `PreflightExec` and `PostSummary` that exclude Esc/q or Esc/Enter/q
pub(super) fn restore_if_not_closed_with_excluded_keys(
app: &mut AppState,
ke: &KeyEvent,
excluded_keys: &[KeyCode],
modal: Modal,
) {
if matches!(app.modal, Modal::None) && !excluded_keys.contains(&ke.code) {
app.modal = modal;
}
}
/// What: Restore a modal if it wasn't closed by the handler, considering an
/// Option<bool> result and excluding Esc/q keys.
///
/// Inputs:
/// - `app`: Mutable application state to check and restore modal in
/// - `ke`: Key event to check against Esc/q keys
/// - `should_stop`: Optional boolean indicating if event propagation should stop
/// - `modal`: Modal variant to restore if conditions are met
///
/// Output:
/// - The boolean value from `should_stop`, or `false` if `None`
/// - Returns `true` if Esc or 'q' was pressed and modal was closed (to stop propagation)
///
/// Details:
/// - Used for modals like `SystemUpdate` and `OptionalDeps` that return `Option<bool>`
/// - Restores modal if handler didn't close it and Esc/q wasn't pressed
/// - Esc/q keys close modal even if `should_stop` is `Some(false)`
/// - When Esc/q closes the modal, returns `true` to stop event propagation
pub(super) fn restore_if_not_closed_with_option_result(
app: &mut AppState,
ke: &KeyEvent,
should_stop: Option<bool>,
modal: Modal,
) -> bool {
if matches!(app.modal, Modal::None) {
// If Esc or 'q' was pressed and modal was closed, stop propagation
if matches!(ke.code, KeyCode::Esc | KeyCode::Char('q')) {
return true;
}
// Only restore if handler didn't intentionally close (Esc/q returns Some(false) but closes modal)
// For navigation/toggle keys, handler returns Some(false) but doesn't close, so we restore
if should_stop.is_none() || should_stop == Some(false) {
app.modal = modal;
}
}
should_stop.unwrap_or(false)
}
/// What: Restore a modal if it wasn't closed by the handler and Esc wasn't pressed.
///
/// Inputs:
/// - `app`: Mutable application state to check and restore modal in
/// - `ke`: Key event to check against Esc key
/// - `modal`: Modal variant to restore if conditions are met
///
/// Output:
/// - None (mutates `app.modal` directly)
///
/// Details:
/// - Checks if `app.modal` is `None` (indicating handler closed it)
/// - If modal is still `None` and key is not Esc, restores the modal
/// - Used for modals like `ScanConfig` and `VirusTotalSetup` that only exclude Esc
pub(super) fn restore_if_not_closed_with_esc(app: &mut AppState, ke: &KeyEvent, modal: Modal) {
if matches!(app.modal, Modal::None) && !matches!(ke.code, KeyCode::Esc) {
app.modal = modal;
}
}
/// What: Restore a modal if it wasn't closed by the handler and the boolean
/// result indicates the event wasn't fully handled.
///
/// Inputs:
/// - `app`: Mutable application state to check and restore modal in
/// - `result`: Boolean indicating if event was fully handled (true = don't restore)
/// - `modal`: Modal variant to restore if conditions are met
///
/// Output:
/// - The boolean result value
///
/// Details:
/// - Used for modals like News that return a boolean indicating if propagation should stop
/// - If result is `false` (event not fully handled) and modal is `None`, restores the modal
pub(super) fn restore_if_not_closed_with_bool_result(
app: &mut AppState,
result: bool,
modal: Modal,
) -> bool {
// Restore modal if handler didn't change it and Esc wasn't pressed (result != true)
// Esc returns true to stop propagation, so we shouldn't restore in that case
if !result && matches!(app.modal, Modal::None) {
app.modal = modal;
}
result
}
#[cfg(test)]
mod tests {
use super::*;
use crossterm::event::{KeyCode, KeyEvent, KeyEventKind, KeyEventState, KeyModifiers};
fn create_key_event(code: KeyCode) -> KeyEvent {
KeyEvent {
code,
kind: KeyEventKind::Press,
state: KeyEventState::NONE,
modifiers: KeyModifiers::NONE,
}
}
fn create_app_state_with_modal(modal: Modal) -> AppState {
AppState {
modal,
..Default::default()
}
}
#[test]
fn test_restore_if_not_closed_with_excluded_keys_restores_when_not_excluded() {
let mut app = create_app_state_with_modal(Modal::None);
let ke = create_key_event(KeyCode::Char('a'));
let modal = Modal::Help;
let excluded = [KeyCode::Esc, KeyCode::Char('q')];
restore_if_not_closed_with_excluded_keys(&mut app, &ke, &excluded, modal);
assert!(matches!(app.modal, Modal::Help));
}
#[test]
fn test_restore_if_not_closed_with_excluded_keys_doesnt_restore_when_excluded() {
let mut app = create_app_state_with_modal(Modal::None);
let ke = create_key_event(KeyCode::Esc);
let modal = Modal::Help;
let excluded = [KeyCode::Esc, KeyCode::Char('q')];
restore_if_not_closed_with_excluded_keys(&mut app, &ke, &excluded, modal);
assert!(matches!(app.modal, Modal::None));
}
#[test]
fn test_restore_if_not_closed_with_excluded_keys_doesnt_restore_when_modal_not_none() {
let mut app = create_app_state_with_modal(Modal::Help);
let ke = create_key_event(KeyCode::Char('a'));
let modal = Modal::News {
items: vec![],
selected: 0,
scroll: 0,
};
let excluded = [KeyCode::Esc];
restore_if_not_closed_with_excluded_keys(&mut app, &ke, &excluded, modal);
assert!(matches!(app.modal, Modal::Help));
}
#[test]
fn test_restore_if_not_closed_with_option_result_restores_when_none() {
let mut app = create_app_state_with_modal(Modal::None);
let ke = create_key_event(KeyCode::Char('a'));
let modal = Modal::Help;
let result = restore_if_not_closed_with_option_result(&mut app, &ke, None, modal);
assert!(matches!(app.modal, Modal::Help));
assert!(!result);
}
#[test]
fn test_restore_if_not_closed_with_option_result_restores_when_false_and_not_esc() {
let mut app = create_app_state_with_modal(Modal::None);
let ke = create_key_event(KeyCode::Char('a'));
let modal = Modal::Help;
let result = restore_if_not_closed_with_option_result(&mut app, &ke, Some(false), modal);
assert!(matches!(app.modal, Modal::Help));
assert!(!result);
}
#[test]
fn test_restore_if_not_closed_with_option_result_doesnt_restore_when_esc() {
let mut app = create_app_state_with_modal(Modal::None);
let ke = create_key_event(KeyCode::Esc);
let modal = Modal::Help;
let result = restore_if_not_closed_with_option_result(&mut app, &ke, Some(false), modal);
assert!(matches!(app.modal, Modal::None));
assert!(result); // Esc returns true to stop propagation
}
#[test]
fn test_restore_if_not_closed_with_option_result_doesnt_restore_when_q() {
let mut app = create_app_state_with_modal(Modal::None);
let ke = create_key_event(KeyCode::Char('q'));
let modal = Modal::Help;
let result = restore_if_not_closed_with_option_result(&mut app, &ke, Some(false), modal);
assert!(matches!(app.modal, Modal::None));
assert!(result); // 'q' returns true to stop propagation
}
#[test]
fn test_restore_if_not_closed_with_option_result_returns_true_when_some_true() {
let mut app = create_app_state_with_modal(Modal::None);
let ke = create_key_event(KeyCode::Char('a'));
let modal = Modal::Help;
let result = restore_if_not_closed_with_option_result(&mut app, &ke, Some(true), modal);
assert!(matches!(app.modal, Modal::None));
assert!(result);
}
#[test]
fn test_restore_if_not_closed_with_esc_restores_when_not_esc() {
let mut app = create_app_state_with_modal(Modal::None);
let ke = create_key_event(KeyCode::Char('a'));
let modal = Modal::Help;
restore_if_not_closed_with_esc(&mut app, &ke, modal);
assert!(matches!(app.modal, Modal::Help));
}
#[test]
fn test_restore_if_not_closed_with_esc_doesnt_restore_when_esc() {
let mut app = create_app_state_with_modal(Modal::None);
let ke = create_key_event(KeyCode::Esc);
let modal = Modal::Help;
restore_if_not_closed_with_esc(&mut app, &ke, modal);
assert!(matches!(app.modal, Modal::None));
}
#[test]
fn test_restore_if_not_closed_with_esc_doesnt_restore_when_modal_not_none() {
let mut app = create_app_state_with_modal(Modal::Help);
let ke = create_key_event(KeyCode::Char('a'));
let modal = Modal::News {
items: vec![],
selected: 0,
scroll: 0,
};
restore_if_not_closed_with_esc(&mut app, &ke, modal);
assert!(matches!(app.modal, Modal::Help));
}
#[test]
fn test_restore_if_not_closed_with_bool_result_restores_when_false() {
let mut app = create_app_state_with_modal(Modal::None);
let modal = Modal::Help;
let result = restore_if_not_closed_with_bool_result(&mut app, false, modal);
assert!(matches!(app.modal, Modal::Help));
assert!(!result);
}
#[test]
fn test_restore_if_not_closed_with_bool_result_doesnt_restore_when_true() {
let mut app = create_app_state_with_modal(Modal::None);
let modal = Modal::Help;
let result = restore_if_not_closed_with_bool_result(&mut app, true, modal);
assert!(matches!(app.modal, Modal::None));
assert!(result);
}
#[test]
fn test_restore_if_not_closed_with_bool_result_doesnt_restore_when_modal_not_none() {
let mut app = create_app_state_with_modal(Modal::Help);
let modal = Modal::News {
items: vec![],
selected: 0,
scroll: 0,
};
let result = restore_if_not_closed_with_bool_result(&mut app, false, modal);
assert!(matches!(app.modal, Modal::Help));
assert!(!result);
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/modals/scan.rs | src/events/modals/scan.rs | //! Scan configuration and `VirusTotal` setup modal handling.
use crossterm::event::{KeyCode, KeyEvent};
#[cfg(not(target_os = "windows"))]
use crate::install::ExecutorRequest;
use crate::state::AppState;
#[cfg(not(target_os = "windows"))]
use crate::state::{PackageItem, Source};
/// What: Handle key events for `ScanConfig` modal.
///
/// Inputs:
/// - `ke`: Key event
/// - `app`: Mutable application state
/// - `do_clamav`: Mutable reference to `ClamAV` flag
/// - `do_trivy`: Mutable reference to Trivy flag
/// - `do_semgrep`: Mutable reference to Semgrep flag
/// - `do_shellcheck`: Mutable reference to `Shellcheck` flag
/// - `do_virustotal`: Mutable reference to `VirusTotal` flag
/// - `do_custom`: Mutable reference to custom scan flag
/// - `do_sleuth`: Mutable reference to sleuth flag
/// - `cursor`: Mutable reference to cursor position
///
/// Output:
/// - `false` (never stops propagation)
///
/// Details:
/// - Handles navigation, toggles, and Enter to confirm scan configuration
#[allow(clippy::too_many_arguments)]
pub(super) fn handle_scan_config(
ke: KeyEvent,
app: &mut AppState,
do_clamav: &mut bool,
do_trivy: &mut bool,
do_semgrep: &mut bool,
do_shellcheck: &mut bool,
do_virustotal: &mut bool,
do_custom: &mut bool,
do_sleuth: &mut bool,
cursor: &mut usize,
) -> bool {
match ke.code {
KeyCode::Esc => {
// Restore previous modal if it was Preflight, otherwise close
if let Some(prev_modal) = app.previous_modal.take() {
app.modal = prev_modal;
} else {
app.modal = crate::state::Modal::None;
}
}
KeyCode::Up => {
if *cursor > 0 {
*cursor -= 1;
}
}
KeyCode::Down => {
if *cursor < 6 {
*cursor += 1;
}
}
KeyCode::Char(' ') => match *cursor {
0 => *do_clamav = !*do_clamav,
1 => *do_trivy = !*do_trivy,
2 => *do_semgrep = !*do_semgrep,
3 => *do_shellcheck = !*do_shellcheck,
4 => *do_virustotal = !*do_virustotal,
5 => *do_custom = !*do_custom,
6 => *do_sleuth = !*do_sleuth,
_ => {}
},
#[cfg(not(target_os = "windows"))]
KeyCode::Enter => {
let pending_names = app.pending_install_names.clone();
let new_modal = handle_scan_config_confirm(
app,
pending_names.as_ref(),
app.dry_run,
*do_clamav,
*do_trivy,
*do_semgrep,
*do_shellcheck,
*do_virustotal,
*do_custom,
*do_sleuth,
);
app.modal = new_modal;
}
_ => {}
}
false
}
/// What: Handle key events for `VirusTotalSetup` modal.
///
/// Inputs:
/// - `ke`: Key event
/// - `app`: Mutable application state
/// - `input`: Mutable reference to input string
/// - `cursor`: Mutable reference to cursor position
///
/// Output:
/// - `false` (never stops propagation)
///
/// Details:
/// - Handles text input, navigation, and Enter to save API key
pub(super) fn handle_virustotal_setup(
ke: KeyEvent,
app: &mut AppState,
input: &mut String,
cursor: &mut usize,
) -> bool {
match ke.code {
KeyCode::Esc => {
app.modal = crate::state::Modal::None;
}
KeyCode::Enter => {
let key = input.trim().to_string();
if key.is_empty() {
let url = "https://www.virustotal.com/gui/my-apikey";
crate::util::open_url(url);
// Keep the setup modal open so the user can paste the key after opening the link
} else {
crate::theme::save_virustotal_api_key(&key);
app.modal = crate::state::Modal::None;
}
}
KeyCode::Backspace => {
if *cursor > 0 && *cursor <= input.len() {
input.remove(*cursor - 1);
*cursor -= 1;
}
}
KeyCode::Left => {
if *cursor > 0 {
*cursor -= 1;
}
}
KeyCode::Right => {
if *cursor < input.len() {
*cursor += 1;
}
}
KeyCode::Home => {
*cursor = 0;
}
KeyCode::End => {
*cursor = input.len();
}
KeyCode::Char(ch) => {
if !ch.is_control() {
if *cursor <= input.len() {
input.insert(*cursor, ch);
*cursor += 1;
} else {
input.push(ch);
*cursor = input.len();
}
}
}
_ => {}
}
false
}
/// What: Confirm and execute scan configuration.
///
/// Inputs:
/// - `app`: Mutable application state
/// - `pending_install_names`: Mutable reference to pending install names
/// - `dry_run`: Whether to run in dry-run mode
/// - `do_clamav`: `ClamAV` scan flag
/// - `do_trivy`: Trivy scan flag
/// - `do_semgrep`: Semgrep scan flag
/// - `do_shellcheck`: `Shellcheck` scan flag
/// - `do_virustotal`: `VirusTotal` scan flag
/// - `do_custom`: Custom scan flag
/// - `do_sleuth`: Sleuth scan flag
///
/// Output: New modal state (`PreflightExec` for first package, `None` for subsequent)
///
/// Details:
/// - Persists scan settings and launches AUR scans via integrated process
/// - aur-sleuth runs in separate terminal simultaneously if enabled
#[allow(
clippy::too_many_arguments,
clippy::fn_params_excessive_bools,
clippy::needless_pass_by_ref_mut
)]
#[cfg(not(target_os = "windows"))]
fn handle_scan_config_confirm(
app: &mut crate::state::AppState,
pending_install_names: Option<&Vec<String>>,
dry_run: bool,
do_clamav: bool,
do_trivy: bool,
do_semgrep: bool,
do_shellcheck: bool,
do_virustotal: bool,
do_custom: bool,
do_sleuth: bool,
) -> crate::state::Modal {
tracing::info!(
event = "scan_config_confirm",
dry_run,
do_clamav,
do_trivy,
do_semgrep,
do_shellcheck,
do_virustotal,
do_custom,
pending_count = pending_install_names.map_or(0, Vec::len),
"Scan Configuration confirmed"
);
crate::theme::save_scan_do_clamav(do_clamav);
crate::theme::save_scan_do_trivy(do_trivy);
crate::theme::save_scan_do_semgrep(do_semgrep);
crate::theme::save_scan_do_shellcheck(do_shellcheck);
crate::theme::save_scan_do_virustotal(do_virustotal);
crate::theme::save_scan_do_custom(do_custom);
crate::theme::save_scan_do_sleuth(do_sleuth);
#[cfg(not(target_os = "windows"))]
if let Some(names) = pending_install_names {
if names.is_empty() {
tracing::warn!("Scan confirmed but no pending AUR package names were found");
return crate::state::Modal::None;
}
tracing::info!(
names = ?names,
count = names.len(),
dry_run,
"Launching AUR scans via integrated process"
);
// Handle each package sequentially (for now, just first package)
// TODO: Add support for sequential multi-package scans
let first_pkg = &names[0];
// Create a dummy `PackageItem` for display in `PreflightExec` modal
let scan_item = PackageItem {
name: format!("scan:{first_pkg}"),
version: String::new(),
description: format!("Security scan for {first_pkg}"),
source: Source::Aur,
popularity: None,
out_of_date: None,
orphaned: false,
};
// Transition to PreflightExec modal for scan
app.modal = crate::state::Modal::PreflightExec {
items: vec![scan_item],
action: crate::state::PreflightAction::Install, // Use Install as placeholder
tab: crate::state::PreflightTab::Summary,
verbose: false,
log_lines: Vec::new(),
abortable: false,
header_chips: crate::state::modal::PreflightHeaderChips::default(),
success: None,
};
// Store executor request for scan
app.pending_executor_request = Some(ExecutorRequest::Scan {
package: first_pkg.clone(),
do_clamav,
do_trivy,
do_semgrep,
do_shellcheck,
do_virustotal,
do_custom,
dry_run,
});
// If sleuth is enabled, spawn it in a separate terminal (runs simultaneously)
if do_sleuth && !dry_run {
let sleuth_cmd = crate::install::build_sleuth_command_for_terminal(first_pkg);
crate::install::spawn_shell_commands_in_terminal(&[sleuth_cmd]);
}
// If there are multiple packages, log a warning (sequential scans not yet implemented)
if names.len() > 1 {
tracing::warn!(
"Multiple packages requested for scan, but only scanning first package: {}",
first_pkg
);
}
return crate::state::Modal::PreflightExec {
items: vec![PackageItem {
name: format!("scan:{first_pkg}"),
version: String::new(),
description: format!("Security scan for {first_pkg}"),
source: Source::Aur,
popularity: None,
out_of_date: None,
orphaned: false,
}],
action: crate::state::PreflightAction::Install,
tab: crate::state::PreflightTab::Summary,
verbose: false,
log_lines: Vec::new(),
abortable: false,
success: None,
header_chips: crate::state::modal::PreflightHeaderChips::default(),
};
}
tracing::warn!("Scan confirmed but no pending AUR package names were found");
crate::state::Modal::None
}
#[cfg(test)]
mod tests;
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/modals/scan/tests.rs | src/events/modals/scan/tests.rs | //! Unit tests for scan configuration modal handlers.
use crate::state::AppState;
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
use crate::events::modals::scan::handle_scan_config;
#[test]
/// What: Verify `ScanConfig` modal handles Esc to close.
///
/// Inputs:
/// - `ScanConfig` modal, Esc key event.
///
/// Output:
/// - Modal is closed or previous modal is restored.
///
/// Details:
/// - Tests that Esc closes the `ScanConfig` modal.
fn scan_config_esc_closes_modal() {
let mut app = AppState {
modal: crate::state::Modal::ScanConfig {
do_clamav: false,
do_trivy: false,
do_semgrep: false,
do_shellcheck: false,
do_virustotal: false,
do_custom: false,
do_sleuth: false,
cursor: 0,
},
..Default::default()
};
let mut do_clamav = false;
let mut do_trivy = false;
let mut do_semgrep = false;
let mut do_shellcheck = false;
let mut do_virustotal = false;
let mut do_custom = false;
let mut do_sleuth = false;
let mut cursor = 0;
let ke = KeyEvent::new(KeyCode::Esc, KeyModifiers::empty());
let _ = handle_scan_config(
ke,
&mut app,
&mut do_clamav,
&mut do_trivy,
&mut do_semgrep,
&mut do_shellcheck,
&mut do_virustotal,
&mut do_custom,
&mut do_sleuth,
&mut cursor,
);
// Modal should be closed or previous modal restored
match app.modal {
crate::state::Modal::None | crate::state::Modal::Preflight { .. } => {}
_ => panic!("Expected modal to be closed or previous modal restored"),
}
}
#[test]
/// What: Verify `ScanConfig` modal handles navigation.
///
/// Inputs:
/// - `ScanConfig` modal, Down key event.
///
/// Output:
/// - Cursor moves down.
///
/// Details:
/// - Tests that navigation keys work in `ScanConfig` modal.
fn scan_config_navigation() {
let mut app = AppState {
modal: crate::state::Modal::ScanConfig {
do_clamav: false,
do_trivy: false,
do_semgrep: false,
do_shellcheck: false,
do_virustotal: false,
do_custom: false,
do_sleuth: false,
cursor: 0,
},
..Default::default()
};
let mut do_clamav = false;
let mut do_trivy = false;
let mut do_semgrep = false;
let mut do_shellcheck = false;
let mut do_virustotal = false;
let mut do_custom = false;
let mut do_sleuth = false;
let mut cursor = 0;
let ke = KeyEvent::new(KeyCode::Down, KeyModifiers::empty());
let _ = handle_scan_config(
ke,
&mut app,
&mut do_clamav,
&mut do_trivy,
&mut do_semgrep,
&mut do_shellcheck,
&mut do_virustotal,
&mut do_custom,
&mut do_sleuth,
&mut cursor,
);
assert_eq!(cursor, 1, "Cursor should move down");
}
#[test]
/// What: Verify `ScanConfig` modal handles toggle with Space.
///
/// Inputs:
/// - `ScanConfig` modal, Space key event on first option.
///
/// Output:
/// - `do_clamav` flag is toggled.
///
/// Details:
/// - Tests that Space toggles scan options in `ScanConfig` modal.
fn scan_config_toggle() {
let mut app = AppState {
modal: crate::state::Modal::ScanConfig {
do_clamav: false,
do_trivy: false,
do_semgrep: false,
do_shellcheck: false,
do_virustotal: false,
do_custom: false,
do_sleuth: false,
cursor: 0,
},
..Default::default()
};
let mut do_clamav = false;
let mut do_trivy = false;
let mut do_semgrep = false;
let mut do_shellcheck = false;
let mut do_virustotal = false;
let mut do_custom = false;
let mut do_sleuth = false;
let mut cursor = 0;
let ke = KeyEvent::new(KeyCode::Char(' '), KeyModifiers::empty());
let _ = handle_scan_config(
ke,
&mut app,
&mut do_clamav,
&mut do_trivy,
&mut do_semgrep,
&mut do_shellcheck,
&mut do_virustotal,
&mut do_custom,
&mut do_sleuth,
&mut cursor,
);
assert!(do_clamav, "do_clamav should be toggled to true");
}
#[test]
/// What: Verify `ScanConfig` modal handles Enter to execute scan.
///
/// Inputs:
/// - `ScanConfig` modal with options selected, Enter key event.
///
/// Output:
/// - Scan is executed (spawns terminal - will fail in test environment).
///
/// Details:
/// - Tests that Enter triggers scan execution.
/// - Note: This will spawn a terminal, so it's expected to fail in test environment.
fn scan_config_enter_executes() {
let mut app = AppState {
modal: crate::state::Modal::ScanConfig {
do_clamav: true,
do_trivy: false,
do_semgrep: false,
do_shellcheck: false,
do_virustotal: false,
do_custom: false,
do_sleuth: false,
cursor: 0,
},
pending_install_names: Some(vec!["test-pkg".to_string()]),
..Default::default()
};
let mut do_clamav = true;
let mut do_trivy = false;
let mut do_semgrep = false;
let mut do_shellcheck = false;
let mut do_virustotal = false;
let mut do_custom = false;
let mut do_sleuth = false;
let mut cursor = 0;
let ke = KeyEvent::new(KeyCode::Enter, KeyModifiers::empty());
let _ = handle_scan_config(
ke,
&mut app,
&mut do_clamav,
&mut do_trivy,
&mut do_semgrep,
&mut do_shellcheck,
&mut do_virustotal,
&mut do_custom,
&mut do_sleuth,
&mut cursor,
);
// Modal should transition (scan spawns terminal)
// The exact modal depends on implementation, but it should not be ScanConfig anymore
if let crate::state::Modal::ScanConfig { .. } = app.modal {
// If still ScanConfig, that's also acceptable (scan might be async)
} else {
// Modal changed - scan was triggered
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/modals/tests/system_update.rs | src/events/modals/tests/system_update.rs | //! Tests for `SystemUpdate` modal key event handling.
use crossterm::event::{KeyCode, KeyModifiers};
use tokio::sync::mpsc;
use crate::state::PackageItem;
use super::common::{key_event, new_app};
use super::handle_modal_key;
#[test]
/// What: Verify Esc key closes `SystemUpdate` modal and doesn't restore it.
///
/// Inputs:
/// - `SystemUpdate` modal with default settings
/// - Esc key event
///
/// Output:
/// - Modal is set to None and remains None (not restored)
///
/// Details:
/// - Tests the bug fix where Esc was being immediately restored
fn system_update_esc_closes_modal() {
let mut app = new_app();
app.modal = crate::state::Modal::SystemUpdate {
do_mirrors: false,
do_pacman: false,
force_sync: false,
do_aur: false,
do_cache: false,
country_idx: 0,
countries: vec!["US".to_string(), "DE".to_string()],
mirror_count: 10,
cursor: 0,
};
let (add_tx, _add_rx) = mpsc::unbounded_channel::<PackageItem>();
let ke = key_event(KeyCode::Esc, KeyModifiers::empty());
handle_modal_key(ke, &mut app, &add_tx);
assert!(matches!(app.modal, crate::state::Modal::None));
}
#[test]
/// What: Verify navigation keys in `SystemUpdate` modal don't close it.
///
/// Inputs:
/// - `SystemUpdate` modal
/// - Up/Down key events
///
/// Output:
/// - Modal remains open and cursor position changes
///
/// Details:
/// - Ensures other keys still work correctly after the Esc fix
fn system_update_navigation_preserves_modal() {
let mut app = new_app();
app.modal = crate::state::Modal::SystemUpdate {
do_mirrors: false,
do_pacman: false,
force_sync: false,
do_aur: false,
do_cache: false,
country_idx: 0,
countries: vec!["US".to_string(), "DE".to_string()],
mirror_count: 10,
cursor: 0,
};
let (add_tx, _add_rx) = mpsc::unbounded_channel::<PackageItem>();
// Press Down - should move cursor and keep modal open
let ke_down = key_event(KeyCode::Down, KeyModifiers::empty());
handle_modal_key(ke_down, &mut app, &add_tx);
match &app.modal {
crate::state::Modal::SystemUpdate { cursor, .. } => {
assert_eq!(*cursor, 1);
}
_ => panic!("Modal should remain SystemUpdate after Down key"),
}
// Press Up - should move cursor back and keep modal open
let ke_up = key_event(KeyCode::Up, KeyModifiers::empty());
handle_modal_key(ke_up, &mut app, &add_tx);
match &app.modal {
crate::state::Modal::SystemUpdate { cursor, .. } => {
assert_eq!(*cursor, 0);
}
_ => panic!("Modal should remain SystemUpdate after Up key"),
}
}
#[test]
/// What: Verify unhandled keys in `SystemUpdate` modal don't break state.
///
/// Inputs:
/// - `SystemUpdate` modal
/// - Unhandled key event (e.g., 'z')
///
/// Output:
/// - Modal remains open with unchanged state
///
/// Details:
/// - Ensures unhandled keys don't cause issues
fn system_update_unhandled_key_preserves_modal() {
let mut app = new_app();
app.modal = crate::state::Modal::SystemUpdate {
do_mirrors: false,
do_pacman: false,
force_sync: false,
do_aur: false,
do_cache: false,
country_idx: 0,
countries: vec!["US".to_string(), "DE".to_string()],
mirror_count: 10,
cursor: 0,
};
let (add_tx, _add_rx) = mpsc::unbounded_channel::<PackageItem>();
let ke = key_event(KeyCode::Char('z'), KeyModifiers::empty());
handle_modal_key(ke, &mut app, &add_tx);
// Modal should remain open since 'z' is not handled
match &app.modal {
crate::state::Modal::SystemUpdate { cursor, .. } => {
assert_eq!(*cursor, 0);
}
_ => panic!("Modal should remain SystemUpdate for unhandled key"),
}
}
#[test]
/// What: Verify toggle keys in `SystemUpdate` modal work correctly.
///
/// Inputs:
/// - `SystemUpdate` modal
/// - Space key event to toggle options
///
/// Output:
/// - Modal remains open and flags are toggled
///
/// Details:
/// - Ensures toggle functionality still works after the Esc fix
fn system_update_toggle_works() {
let mut app = new_app();
app.modal = crate::state::Modal::SystemUpdate {
do_mirrors: false,
do_pacman: false,
force_sync: false,
do_aur: false,
do_cache: false,
country_idx: 0,
countries: vec!["US".to_string(), "DE".to_string()],
mirror_count: 10,
cursor: 0,
};
let (add_tx, _add_rx) = mpsc::unbounded_channel::<PackageItem>();
// Press Space to toggle the first option (do_mirrors)
let ke_space = key_event(KeyCode::Char(' '), KeyModifiers::empty());
handle_modal_key(ke_space, &mut app, &add_tx);
match &app.modal {
crate::state::Modal::SystemUpdate {
do_mirrors, cursor, ..
} => {
assert!(*do_mirrors);
assert_eq!(*cursor, 0);
}
_ => panic!("Modal should remain SystemUpdate after Space key"),
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/modals/tests/global_keybinds.rs | src/events/modals/tests/global_keybinds.rs | //! Tests for global keybind blocking when modals are open.
use crossterm::event::{KeyCode, KeyModifiers};
use tokio::sync::mpsc;
use crate::state::PackageItem;
use super::common::{create_test_modals, key_event, new_app};
use super::handle_modal_key;
#[test]
/// What: Verify Ctrl+R (reload config) is blocked when modals are open.
///
/// Inputs:
/// - Each modal type (except None and Preflight)
/// - Ctrl+R key event
///
/// Output:
/// - Config reload does NOT trigger
/// - Modal remains open or handles 'r' key per its own logic
///
/// Details:
/// - Tests that global keybind is blocked for all modals
/// - Note: Some modals (like `PostSummary`) use 'r' for their own actions (rollback)
/// which is expected behavior - the modal keybind takes priority
fn global_keybind_ctrl_r_blocked_in_all_modals() {
// Config reload toast message pattern (from i18n)
let config_reload_patterns = ["config", "reload", "Config", "Reload"];
for (modal, name) in create_test_modals() {
let mut app = new_app();
app.modal = modal.clone();
let (add_tx, _add_rx) = mpsc::unbounded_channel::<PackageItem>();
let ke = key_event(KeyCode::Char('r'), KeyModifiers::CONTROL);
handle_modal_key(ke, &mut app, &add_tx);
// If there's a toast message, verify it's NOT a config reload message
// (some modals like PostSummary use 'r' for their own actions like rollback)
if let Some(ref msg) = app.toast_message {
let is_config_reload = config_reload_patterns.iter().any(|p| msg.contains(p));
assert!(
!is_config_reload,
"{name}: Ctrl+R should not trigger config reload, got toast: {msg}"
);
}
// Modal should still be open (or closed by its own handler, but NOT by global keybind)
// We just verify no global side effects occurred
}
}
#[test]
/// What: Verify Ctrl+X (PKGBUILD toggle) is blocked when modals are open.
///
/// Inputs:
/// - Each modal type (except None and Preflight)
/// - Ctrl+X key event
///
/// Output:
/// - PKGBUILD visibility does NOT change
///
/// Details:
/// - Tests that global keybind is blocked for all modals
fn global_keybind_ctrl_x_blocked_in_all_modals() {
for (modal, name) in create_test_modals() {
let mut app = new_app();
app.modal = modal.clone();
app.pkgb_visible = false;
let (add_tx, _add_rx) = mpsc::unbounded_channel::<PackageItem>();
let ke = key_event(KeyCode::Char('x'), KeyModifiers::CONTROL);
handle_modal_key(ke, &mut app, &add_tx);
assert!(
!app.pkgb_visible,
"{name}: Ctrl+X should be blocked, pkgb_visible should remain false"
);
}
}
#[test]
/// What: Verify Ctrl+S (change sort) is blocked when modals are open.
///
/// Inputs:
/// - Each modal type (except None and Preflight)
/// - Ctrl+S key event
///
/// Output:
/// - Sort order does NOT change
///
/// Details:
/// - Tests that global keybind is blocked for all modals
fn global_keybind_ctrl_s_blocked_in_all_modals() {
for (modal, name) in create_test_modals() {
let mut app = new_app();
app.modal = modal.clone();
let original_sort = app.sort_mode;
let (add_tx, _add_rx) = mpsc::unbounded_channel::<PackageItem>();
let ke = key_event(KeyCode::Char('s'), KeyModifiers::CONTROL);
handle_modal_key(ke, &mut app, &add_tx);
assert_eq!(
app.sort_mode, original_sort,
"{name}: Ctrl+S should be blocked, sort_mode should remain unchanged"
);
}
}
#[test]
/// What: Verify F1 (help overlay) is blocked when modals are open.
///
/// Inputs:
/// - Each modal type (except None, Preflight, and Help itself)
/// - F1 key event
///
/// Output:
/// - Help modal does NOT open (no nested Help modal)
///
/// Details:
/// - Tests that global keybind is blocked for all modals
fn global_keybind_f1_blocked_in_all_modals() {
for (modal, name) in create_test_modals() {
// Skip Help modal itself - F1 doesn't make sense there
if matches!(modal, crate::state::Modal::Help) {
continue;
}
let mut app = new_app();
app.modal = modal.clone();
let (add_tx, _add_rx) = mpsc::unbounded_channel::<PackageItem>();
let ke = key_event(KeyCode::F(1), KeyModifiers::empty());
handle_modal_key(ke, &mut app, &add_tx);
// Should NOT have opened Help modal (would replace current modal)
// The modal should either be unchanged or closed by its own Esc/Enter handling
// but NOT replaced by Help
assert!(
!matches!(app.modal, crate::state::Modal::Help)
|| matches!(modal, crate::state::Modal::Help),
"{name}: F1 should be blocked, Help modal should not open"
);
}
}
#[test]
/// What: Verify Ctrl+T (comments toggle) is blocked when modals are open.
///
/// Inputs:
/// - Each modal type (except None and Preflight)
/// - Ctrl+T key event
///
/// Output:
/// - Comments visibility does NOT change
///
/// Details:
/// - Tests that global keybind is blocked for all modals
fn global_keybind_ctrl_t_blocked_in_all_modals() {
for (modal, name) in create_test_modals() {
let mut app = new_app();
app.modal = modal.clone();
let original_comments_visible = app.comments_visible;
let (add_tx, _add_rx) = mpsc::unbounded_channel::<PackageItem>();
let ke = key_event(KeyCode::Char('t'), KeyModifiers::CONTROL);
handle_modal_key(ke, &mut app, &add_tx);
assert_eq!(
app.comments_visible, original_comments_visible,
"{name}: Ctrl+T should be blocked, comments_visible should remain unchanged"
);
}
}
#[test]
/// What: Verify all global keybinds work when no modal is open.
///
/// Inputs:
/// - `Modal::None`
/// - Various global keybind key events
///
/// Output:
/// - Global keybinds should work normally (changes state)
///
/// Details:
/// - Baseline test to ensure global keybinds work when expected
fn global_keybinds_work_when_no_modal_open() {
// Test Ctrl+S changes sort mode when no modal is open
let mut app = new_app();
app.modal = crate::state::Modal::None;
let original_sort = app.sort_mode;
// Note: handle_modal_key returns early for Modal::None,
// so global keybinds are handled by handle_global_key in mod.rs
// This test verifies the modal handler doesn't interfere
let (add_tx, _add_rx) = mpsc::unbounded_channel::<PackageItem>();
let ke = key_event(KeyCode::Char('s'), KeyModifiers::CONTROL);
let result = handle_modal_key(ke, &mut app, &add_tx);
// Modal handler should return false for Modal::None (not handled)
assert!(!result, "Modal::None should return false (not handled)");
// Sort mode should be unchanged by modal handler (global handler would change it)
assert_eq!(
app.sort_mode, original_sort,
"Modal handler should not change sort_mode for Modal::None"
);
}
#[test]
/// What: Verify modal keybinds take priority over global keybinds.
///
/// Inputs:
/// - News modal with items
/// - Ctrl+R key event (global: reload config, modal: mark all read)
///
/// Output:
/// - Modal action triggers (mark all read)
/// - Global action does NOT trigger (no toast)
///
/// Details:
/// - Comprehensive test for the original issue (Ctrl+R conflict in News modal)
/// - Only works in normal mode
fn modal_keybinds_priority_over_global_ctrl_r_in_news() {
let mut app = new_app();
app.search_normal_mode = true; // Must be in normal mode
let items = vec![
crate::state::types::NewsFeedItem {
id: "https://example.com/1".to_string(),
date: "2025-01-01".to_string(),
title: "News 1".to_string(),
summary: None,
url: Some("https://example.com/1".to_string()),
source: crate::state::types::NewsFeedSource::ArchNews,
severity: None,
packages: Vec::new(),
},
crate::state::types::NewsFeedItem {
id: "https://example.com/2".to_string(),
date: "2025-01-02".to_string(),
title: "News 2".to_string(),
summary: None,
url: Some("https://example.com/2".to_string()),
source: crate::state::types::NewsFeedSource::ArchNews,
severity: None,
packages: Vec::new(),
},
];
app.modal = crate::state::Modal::News {
items,
selected: 0,
scroll: 0,
};
// Verify initial state
assert!(app.news_read_urls.is_empty());
assert!(!app.news_read_dirty);
assert!(app.toast_message.is_none());
let (add_tx, _add_rx) = mpsc::unbounded_channel::<PackageItem>();
let ke = key_event(KeyCode::Char('r'), KeyModifiers::CONTROL);
handle_modal_key(ke, &mut app, &add_tx);
// Modal action should have triggered: mark all read
assert_eq!(
app.news_read_urls.len(),
2,
"All news items should be marked as read"
);
assert!(app.news_read_dirty, "news_read_dirty should be true");
// Global action should NOT have triggered: no config reload toast
assert!(
app.toast_message.is_none(),
"Config reload toast should NOT appear (global keybind blocked)"
);
// Modal should remain open
assert!(
matches!(app.modal, crate::state::Modal::News { .. }),
"News modal should remain open"
);
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/modals/tests/preflight.rs | src/events/modals/tests/preflight.rs | //! Tests for `PreflightExec` modal key event handling.
use crossterm::event::{KeyCode, KeyModifiers};
use tokio::sync::mpsc;
use crate::state::{PackageItem, PreflightAction, PreflightTab, modal::PreflightHeaderChips};
use super::common::{key_event, new_app};
use super::handle_modal_key;
#[test]
/// What: Verify Esc key closes `PreflightExec` modal and doesn't restore it.
///
/// Inputs:
/// - `PreflightExec` modal
/// - Esc key event
///
/// Output:
/// - Modal is set to None and remains None (not restored)
///
/// Details:
/// - Tests the bug fix where Esc was being immediately restored
fn preflight_exec_esc_closes_modal() {
let mut app = new_app();
app.modal = crate::state::Modal::PreflightExec {
verbose: false,
log_lines: vec![],
abortable: true,
items: vec![],
action: PreflightAction::Install,
tab: PreflightTab::Summary,
success: None,
header_chips: PreflightHeaderChips::default(),
};
let (add_tx, _add_rx) = mpsc::unbounded_channel::<PackageItem>();
let ke = key_event(KeyCode::Esc, KeyModifiers::empty());
handle_modal_key(ke, &mut app, &add_tx);
assert!(matches!(app.modal, crate::state::Modal::None));
}
#[test]
/// What: Verify 'q' key closes `PreflightExec` modal and doesn't restore it.
///
/// Inputs:
/// - `PreflightExec` modal
/// - 'q' key event
///
/// Output:
/// - Modal is set to None and remains None (not restored)
///
/// Details:
/// - Tests that 'q' also works to close the modal
fn preflight_exec_q_closes_modal() {
let mut app = new_app();
app.modal = crate::state::Modal::PreflightExec {
verbose: false,
log_lines: vec![],
abortable: true,
items: vec![],
action: PreflightAction::Install,
tab: PreflightTab::Summary,
success: None,
header_chips: PreflightHeaderChips::default(),
};
let (add_tx, _add_rx) = mpsc::unbounded_channel::<PackageItem>();
let ke = key_event(KeyCode::Char('q'), KeyModifiers::empty());
handle_modal_key(ke, &mut app, &add_tx);
assert!(matches!(app.modal, crate::state::Modal::None));
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/modals/tests/help.rs | src/events/modals/tests/help.rs | //! Tests for Help modal key event handling.
use crossterm::event::{KeyCode, KeyModifiers};
use tokio::sync::mpsc;
use crate::state::PackageItem;
use super::common::{key_event, new_app};
use super::handle_modal_key;
#[test]
/// What: Verify Esc key closes Help modal.
///
/// Inputs:
/// - Help modal
/// - Esc key event
///
/// Output:
/// - Modal is set to None
///
/// Details:
/// - Tests that Esc closes Help modal correctly
fn help_esc_closes_modal() {
let mut app = new_app();
app.modal = crate::state::Modal::Help;
let (add_tx, _add_rx) = mpsc::unbounded_channel::<PackageItem>();
let ke = key_event(KeyCode::Esc, KeyModifiers::empty());
handle_modal_key(ke, &mut app, &add_tx);
assert!(matches!(app.modal, crate::state::Modal::None));
}
#[test]
/// What: Verify Enter key closes Help modal.
///
/// Inputs:
/// - Help modal
/// - Enter key event
///
/// Output:
/// - Modal is set to None
///
/// Details:
/// - Tests that Enter also closes Help modal
fn help_enter_closes_modal() {
let mut app = new_app();
app.modal = crate::state::Modal::Help;
let (add_tx, _add_rx) = mpsc::unbounded_channel::<PackageItem>();
let ke = key_event(KeyCode::Enter, KeyModifiers::empty());
handle_modal_key(ke, &mut app, &add_tx);
assert!(matches!(app.modal, crate::state::Modal::None));
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/modals/tests/optional_deps.rs | src/events/modals/tests/optional_deps.rs | //! Tests for `OptionalDeps` modal key event handling.
use crossterm::event::{KeyCode, KeyModifiers};
use tokio::sync::mpsc;
use crate::state::PackageItem;
use super::common::{key_event, new_app};
use super::handle_modal_key;
#[test]
/// What: Verify Esc key closes `OptionalDeps` modal and doesn't restore it.
///
/// Inputs:
/// - `OptionalDeps` modal with test rows
/// - Esc key event
///
/// Output:
/// - Modal is set to None and remains None (not restored)
///
/// Details:
/// - Tests the bug fix where Esc was being immediately restored
fn optional_deps_esc_closes_modal() {
let mut app = new_app();
let rows = vec![crate::state::types::OptionalDepRow {
label: "Test".to_string(),
package: "test-pkg".to_string(),
installed: false,
selectable: true,
note: None,
}];
app.modal = crate::state::Modal::OptionalDeps { rows, selected: 0 };
let (add_tx, _add_rx) = mpsc::unbounded_channel::<PackageItem>();
let ke = key_event(KeyCode::Esc, KeyModifiers::empty());
handle_modal_key(ke, &mut app, &add_tx);
assert!(matches!(app.modal, crate::state::Modal::None));
}
#[test]
/// What: Verify navigation keys in `OptionalDeps` modal don't close it.
///
/// Inputs:
/// - `OptionalDeps` modal with multiple rows
/// - Up/Down key events
///
/// Output:
/// - Modal remains open and selection changes
///
/// Details:
/// - Ensures other keys still work correctly after the Esc fix
fn optional_deps_navigation_preserves_modal() {
let mut app = new_app();
let rows = vec![
crate::state::types::OptionalDepRow {
label: "Test 1".to_string(),
package: "test-pkg-1".to_string(),
installed: false,
selectable: true,
note: None,
},
crate::state::types::OptionalDepRow {
label: "Test 2".to_string(),
package: "test-pkg-2".to_string(),
installed: false,
selectable: true,
note: None,
},
];
app.modal = crate::state::Modal::OptionalDeps { rows, selected: 0 };
let (add_tx, _add_rx) = mpsc::unbounded_channel::<PackageItem>();
// Press Down - should move selection and keep modal open
let ke_down = key_event(KeyCode::Down, KeyModifiers::empty());
handle_modal_key(ke_down, &mut app, &add_tx);
match &app.modal {
crate::state::Modal::OptionalDeps { selected, .. } => {
assert_eq!(*selected, 1);
}
_ => panic!("Modal should remain OptionalDeps after Down key"),
}
// Press Up - should move selection back and keep modal open
let ke_up = key_event(KeyCode::Up, KeyModifiers::empty());
handle_modal_key(ke_up, &mut app, &add_tx);
match &app.modal {
crate::state::Modal::OptionalDeps { selected, .. } => {
assert_eq!(*selected, 0);
}
_ => panic!("Modal should remain OptionalDeps after Up key"),
}
}
#[test]
/// What: Verify unhandled keys in `OptionalDeps` modal don't break state.
///
/// Inputs:
/// - `OptionalDeps` modal
/// - Unhandled key event (e.g., 'x')
///
/// Output:
/// - Modal remains open with unchanged state
///
/// Details:
/// - Ensures unhandled keys don't cause issues
fn optional_deps_unhandled_key_preserves_modal() {
let mut app = new_app();
let rows = vec![crate::state::types::OptionalDepRow {
label: "Test".to_string(),
package: "test-pkg".to_string(),
installed: false,
selectable: true,
note: None,
}];
app.modal = crate::state::Modal::OptionalDeps { rows, selected: 0 };
let (add_tx, _add_rx) = mpsc::unbounded_channel::<PackageItem>();
let ke = key_event(KeyCode::Char('x'), KeyModifiers::empty());
handle_modal_key(ke, &mut app, &add_tx);
// Modal should remain open since 'x' is not handled
match &app.modal {
crate::state::Modal::OptionalDeps { selected, .. } => {
assert_eq!(*selected, 0);
}
_ => panic!("Modal should remain OptionalDeps for unhandled key"),
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/modals/tests/mod.rs | src/events/modals/tests/mod.rs | //! Tests for modal key event handling, particularly Esc key bug fixes.
mod alert;
mod common;
mod confirm;
mod global_keybinds;
mod help;
mod news;
mod optional_deps;
mod other;
mod post_summary;
mod preflight;
mod scan;
mod system_update;
// Re-export handle_modal_key_test for tests
pub(super) use crate::events::modals::handle_modal_key_test as handle_modal_key;
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/modals/tests/other.rs | src/events/modals/tests/other.rs | //! Tests for other modal key event handling (`GnomeTerminalPrompt`, `ImportHelp`).
use crossterm::event::{KeyCode, KeyModifiers};
use tokio::sync::mpsc;
use crate::state::PackageItem;
use super::common::{key_event, new_app};
use super::handle_modal_key;
#[test]
/// What: Verify Esc key closes `GnomeTerminalPrompt` modal.
///
/// Inputs:
/// - `GnomeTerminalPrompt` modal
/// - Esc key event
///
/// Output:
/// - Modal is set to None
///
/// Details:
/// - Tests that Esc closes `GnomeTerminalPrompt` modal correctly
fn gnome_terminal_prompt_esc_closes_modal() {
let mut app = new_app();
app.modal = crate::state::Modal::GnomeTerminalPrompt;
let (add_tx, _add_rx) = mpsc::unbounded_channel::<PackageItem>();
let ke = key_event(KeyCode::Esc, KeyModifiers::empty());
handle_modal_key(ke, &mut app, &add_tx);
assert!(matches!(app.modal, crate::state::Modal::None));
}
#[test]
/// What: Verify Enter key in `GnomeTerminalPrompt` modal spawns terminal.
///
/// Inputs:
/// - `GnomeTerminalPrompt` modal
/// - Enter key event
///
/// Output:
/// - Modal closes and terminal spawns
///
/// Details:
/// - Ensures Enter key works correctly
/// - Cleans up terminal window opened by the test
fn gnome_terminal_prompt_enter_spawns_terminal() {
let mut app = new_app();
app.modal = crate::state::Modal::GnomeTerminalPrompt;
let (add_tx, _add_rx) = mpsc::unbounded_channel::<PackageItem>();
let ke = key_event(KeyCode::Enter, KeyModifiers::empty());
handle_modal_key(ke, &mut app, &add_tx);
assert!(matches!(app.modal, crate::state::Modal::None));
// No cleanup needed - spawn_shell_commands_in_terminal is a no-op during tests
}
#[test]
/// What: Verify Esc key closes `ImportHelp` modal.
///
/// Inputs:
/// - `ImportHelp` modal
/// - Esc key event
///
/// Output:
/// - Modal is set to None
///
/// Details:
/// - Tests that Esc closes `ImportHelp` modal correctly
fn import_help_esc_closes_modal() {
let mut app = new_app();
app.modal = crate::state::Modal::ImportHelp;
let (add_tx, _add_rx) = mpsc::unbounded_channel::<PackageItem>();
let ke = key_event(KeyCode::Esc, KeyModifiers::empty());
handle_modal_key(ke, &mut app, &add_tx);
assert!(matches!(app.modal, crate::state::Modal::None));
}
#[test]
/// What: Verify Enter key closes `ImportHelp` modal.
///
/// Inputs:
/// - `ImportHelp` modal
/// - Enter key event
///
/// Output:
/// - Modal is set to None
///
/// Details:
/// - Tests that Enter also closes `ImportHelp` modal
/// - Cleans up file picker window opened by the test
fn import_help_enter_closes_modal() {
let mut app = new_app();
app.modal = crate::state::Modal::ImportHelp;
let (add_tx, _add_rx) = mpsc::unbounded_channel::<PackageItem>();
let ke = key_event(KeyCode::Enter, KeyModifiers::empty());
handle_modal_key(ke, &mut app, &add_tx);
assert!(matches!(app.modal, crate::state::Modal::None));
// No cleanup needed - file picker is a no-op during tests (see events/modals/import.rs)
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/modals/tests/post_summary.rs | src/events/modals/tests/post_summary.rs | //! Tests for `PostSummary` modal key event handling.
use crossterm::event::{KeyCode, KeyModifiers};
use tokio::sync::mpsc;
use crate::state::PackageItem;
use super::common::{key_event, new_app};
use super::handle_modal_key;
#[test]
/// What: Verify Esc key closes `PostSummary` modal and doesn't restore it.
///
/// Inputs:
/// - `PostSummary` modal
/// - Esc key event
///
/// Output:
/// - Modal is set to None and remains None (not restored)
///
/// Details:
/// - Tests the bug fix where Esc was being immediately restored
fn post_summary_esc_closes_modal() {
let mut app = new_app();
app.modal = crate::state::Modal::PostSummary {
success: true,
changed_files: 0,
pacnew_count: 0,
pacsave_count: 0,
services_pending: vec![],
snapshot_label: None,
};
let (add_tx, _add_rx) = mpsc::unbounded_channel::<PackageItem>();
let ke = key_event(KeyCode::Esc, KeyModifiers::empty());
handle_modal_key(ke, &mut app, &add_tx);
assert!(matches!(app.modal, crate::state::Modal::None));
}
#[test]
/// What: Verify Enter key closes `PostSummary` modal and doesn't restore it.
///
/// Inputs:
/// - `PostSummary` modal
/// - Enter key event
///
/// Output:
/// - Modal is set to None and remains None (not restored)
///
/// Details:
/// - Tests that Enter also works to close the modal
fn post_summary_enter_closes_modal() {
let mut app = new_app();
app.modal = crate::state::Modal::PostSummary {
success: true,
changed_files: 0,
pacnew_count: 0,
pacsave_count: 0,
services_pending: vec![],
snapshot_label: None,
};
let (add_tx, _add_rx) = mpsc::unbounded_channel::<PackageItem>();
let ke = key_event(KeyCode::Enter, KeyModifiers::empty());
handle_modal_key(ke, &mut app, &add_tx);
assert!(matches!(app.modal, crate::state::Modal::None));
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/modals/tests/alert.rs | src/events/modals/tests/alert.rs | //! Tests for Alert modal key event handling.
use crossterm::event::{KeyCode, KeyModifiers};
use tokio::sync::mpsc;
use crate::state::PackageItem;
use super::common::{key_event, new_app};
use super::handle_modal_key;
#[test]
/// What: Verify Esc key closes Alert modal.
///
/// Inputs:
/// - Alert modal with message
/// - Esc key event
///
/// Output:
/// - Modal is set to None
///
/// Details:
/// - Tests that Esc closes Alert modal correctly
fn alert_esc_closes_modal() {
let mut app = new_app();
app.modal = crate::state::Modal::Alert {
message: "Test alert message".to_string(),
};
let (add_tx, _add_rx) = mpsc::unbounded_channel::<PackageItem>();
let ke = key_event(KeyCode::Esc, KeyModifiers::empty());
handle_modal_key(ke, &mut app, &add_tx);
assert!(matches!(app.modal, crate::state::Modal::None));
}
#[test]
/// What: Verify Enter key closes Alert modal.
///
/// Inputs:
/// - Alert modal with message
/// - Enter key event
///
/// Output:
/// - Modal is set to None
///
/// Details:
/// - Tests that Enter also closes Alert modal
fn alert_enter_closes_modal() {
let mut app = new_app();
app.modal = crate::state::Modal::Alert {
message: "Test alert message".to_string(),
};
let (add_tx, _add_rx) = mpsc::unbounded_channel::<PackageItem>();
let ke = key_event(KeyCode::Enter, KeyModifiers::empty());
handle_modal_key(ke, &mut app, &add_tx);
assert!(matches!(app.modal, crate::state::Modal::None));
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/modals/tests/common.rs | src/events/modals/tests/common.rs | //! Common test utilities for modal key event handling tests.
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
use crate::state::{AppState, PreflightAction, PreflightTab, modal::PreflightHeaderChips};
/// What: Create a baseline `AppState` for modal tests.
///
/// Inputs:
/// - None
///
/// Output:
/// - Fresh `AppState` ready for modal testing
///
/// Details:
/// - Provides a clean starting state for each test case
pub(super) fn new_app() -> AppState {
AppState::default()
}
/// What: Create a key event with Press kind.
///
/// Inputs:
/// - `code`: Key code
/// - `modifiers`: Key modifiers
///
/// Output:
/// - `KeyEvent` with Press kind
pub(super) fn key_event(code: KeyCode, modifiers: KeyModifiers) -> KeyEvent {
let mut ke = KeyEvent::new(code, modifiers);
ke.kind = crossterm::event::KeyEventKind::Press;
ke
}
/// What: Create test modals for global keybind blocking tests.
///
/// Inputs:
/// - None
///
/// Output:
/// - Vector of (modal, name) tuples for testing
///
/// Details:
/// - Returns all modals that should block global keybinds (excludes None and Preflight)
pub(super) fn create_test_modals() -> Vec<(crate::state::Modal, &'static str)> {
vec![
(
crate::state::Modal::Alert {
message: "Test alert".to_string(),
},
"Alert",
),
(
crate::state::Modal::Loading {
message: "Loading...".to_string(),
},
"Loading",
),
(
crate::state::Modal::ConfirmInstall { items: vec![] },
"ConfirmInstall",
),
(
crate::state::Modal::ConfirmReinstall {
items: vec![],
all_items: vec![],
header_chips: PreflightHeaderChips::default(),
},
"ConfirmReinstall",
),
(
crate::state::Modal::ConfirmBatchUpdate {
items: vec![],
dry_run: false,
},
"ConfirmBatchUpdate",
),
(
crate::state::Modal::PreflightExec {
items: vec![],
action: PreflightAction::Install,
tab: PreflightTab::Summary,
verbose: false,
log_lines: vec![],
abortable: false,
header_chips: PreflightHeaderChips::default(),
success: None,
},
"PreflightExec",
),
(
crate::state::Modal::PostSummary {
success: true,
changed_files: 0,
pacnew_count: 0,
pacsave_count: 0,
services_pending: vec![],
snapshot_label: None,
},
"PostSummary",
),
(crate::state::Modal::Help, "Help"),
(
crate::state::Modal::ConfirmRemove { items: vec![] },
"ConfirmRemove",
),
(
crate::state::Modal::SystemUpdate {
do_mirrors: false,
do_pacman: false,
force_sync: false,
do_aur: false,
do_cache: false,
country_idx: 0,
countries: vec!["US".to_string()],
mirror_count: 10,
cursor: 0,
},
"SystemUpdate",
),
(
crate::state::Modal::News {
items: vec![crate::state::types::NewsFeedItem {
id: "https://example.com".to_string(),
date: "2025-01-01".to_string(),
title: "Test".to_string(),
summary: None,
url: Some("https://example.com".to_string()),
source: crate::state::types::NewsFeedSource::ArchNews,
severity: None,
packages: Vec::new(),
}],
selected: 0,
scroll: 0,
},
"News",
),
(
crate::state::Modal::Updates {
entries: vec![("pkg".to_string(), "1.0".to_string(), "2.0".to_string())],
scroll: 0,
selected: 0,
},
"Updates",
),
(
crate::state::Modal::OptionalDeps {
rows: vec![],
selected: 0,
},
"OptionalDeps",
),
(
crate::state::Modal::ScanConfig {
do_clamav: false,
do_trivy: false,
do_semgrep: false,
do_shellcheck: false,
do_virustotal: false,
do_custom: false,
do_sleuth: false,
cursor: 0,
},
"ScanConfig",
),
(
crate::state::Modal::VirusTotalSetup {
input: String::new(),
cursor: 0,
},
"VirusTotalSetup",
),
(
crate::state::Modal::PasswordPrompt {
purpose: crate::state::modal::PasswordPurpose::Install,
items: vec![],
input: String::new(),
cursor: 0,
error: None,
},
"PasswordPrompt",
),
(
crate::state::Modal::GnomeTerminalPrompt,
"GnomeTerminalPrompt",
),
(crate::state::Modal::ImportHelp, "ImportHelp"),
]
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/modals/tests/news.rs | src/events/modals/tests/news.rs | //! Tests for News modal key event handling.
use crossterm::event::{KeyCode, KeyModifiers};
use tokio::sync::mpsc;
use crate::state::PackageItem;
use super::common::{key_event, new_app};
use super::handle_modal_key;
#[test]
/// What: Verify Esc key closes News modal and doesn't restore it.
///
/// Inputs:
/// - News modal with test items
/// - Esc key event
///
/// Output:
/// - Modal is set to None and remains None (not restored)
///
/// Details:
/// - Tests the bug fix where Esc should close the modal
fn news_esc_closes_modal() {
let mut app = new_app();
let items = vec![
crate::state::types::NewsFeedItem {
id: "https://example.com/news1".to_string(),
date: "2025-01-01".to_string(),
title: "Test News 1".to_string(),
summary: None,
url: Some("https://example.com/news1".to_string()),
source: crate::state::types::NewsFeedSource::ArchNews,
severity: None,
packages: Vec::new(),
},
crate::state::types::NewsFeedItem {
id: "https://example.com/news2".to_string(),
date: "2025-01-02".to_string(),
title: "Test News 2".to_string(),
summary: None,
url: Some("https://example.com/news2".to_string()),
source: crate::state::types::NewsFeedSource::ArchNews,
severity: None,
packages: Vec::new(),
},
];
app.modal = crate::state::Modal::News {
items,
selected: 0,
scroll: 0,
};
let (add_tx, _add_rx) = mpsc::unbounded_channel::<PackageItem>();
let ke = key_event(KeyCode::Esc, KeyModifiers::empty());
handle_modal_key(ke, &mut app, &add_tx);
assert!(matches!(app.modal, crate::state::Modal::None));
}
#[test]
/// What: Verify navigation keys in News modal don't close it.
///
/// Inputs:
/// - News modal with multiple items
/// - Up/Down key events
///
/// Output:
/// - Modal remains open and selection changes
///
/// Details:
/// - Ensures other keys still work correctly after the Esc fix
fn news_navigation_preserves_modal() {
let mut app = new_app();
let items = vec![
crate::state::types::NewsFeedItem {
id: "https://example.com/news1".to_string(),
date: "2025-01-01".to_string(),
title: "Test News 1".to_string(),
summary: None,
url: Some("https://example.com/news1".to_string()),
source: crate::state::types::NewsFeedSource::ArchNews,
severity: None,
packages: Vec::new(),
},
crate::state::types::NewsFeedItem {
id: "https://example.com/news2".to_string(),
date: "2025-01-02".to_string(),
title: "Test News 2".to_string(),
summary: None,
url: Some("https://example.com/news2".to_string()),
source: crate::state::types::NewsFeedSource::ArchNews,
severity: None,
packages: Vec::new(),
},
crate::state::types::NewsFeedItem {
id: "https://example.com/news3".to_string(),
date: "2025-01-03".to_string(),
title: "Test News 3".to_string(),
summary: None,
url: Some("https://example.com/news3".to_string()),
source: crate::state::types::NewsFeedSource::ArchNews,
severity: None,
packages: Vec::new(),
},
];
app.modal = crate::state::Modal::News {
items,
selected: 0,
scroll: 0,
};
let (add_tx, _add_rx) = mpsc::unbounded_channel::<PackageItem>();
// Press Down - should move selection and keep modal open
let ke_down = key_event(KeyCode::Down, KeyModifiers::empty());
handle_modal_key(ke_down, &mut app, &add_tx);
match &app.modal {
crate::state::Modal::News { selected, .. } => {
assert_eq!(*selected, 1);
}
_ => panic!("Modal should remain News after Down key"),
}
// Press Down again - should move selection further
let ke_down2 = key_event(KeyCode::Down, KeyModifiers::empty());
handle_modal_key(ke_down2, &mut app, &add_tx);
match &app.modal {
crate::state::Modal::News { selected, .. } => {
assert_eq!(*selected, 2);
}
_ => panic!("Modal should remain News after second Down key"),
}
// Press Up - should move selection back
let ke_up = key_event(KeyCode::Up, KeyModifiers::empty());
handle_modal_key(ke_up, &mut app, &add_tx);
match &app.modal {
crate::state::Modal::News { selected, .. } => {
assert_eq!(*selected, 1);
}
_ => panic!("Modal should remain News after Up key"),
}
// Press Up at top - should stay at 0
let ke_up2 = key_event(KeyCode::Up, KeyModifiers::empty());
handle_modal_key(ke_up2, &mut app, &add_tx);
match &app.modal {
crate::state::Modal::News { selected, .. } => {
assert_eq!(*selected, 0);
}
_ => panic!("Modal should remain News after Up key at top"),
}
}
#[test]
/// What: Verify Enter key in News modal doesn't close it.
///
/// Inputs:
/// - News modal with items
/// - Enter key event
///
/// Output:
/// - Modal remains open (Enter opens URL but doesn't close modal)
///
/// Details:
/// - Ensures Enter key works correctly
/// - Cleans up browser tab opened by the test
fn news_enter_preserves_modal() {
let mut app = new_app();
let test_url = "https://example.com/news";
let items = vec![crate::state::types::NewsFeedItem {
id: test_url.to_string(),
date: "2025-01-01".to_string(),
title: "Test News".to_string(),
summary: None,
url: Some(test_url.to_string()),
source: crate::state::types::NewsFeedSource::ArchNews,
severity: None,
packages: Vec::new(),
}];
app.modal = crate::state::Modal::News {
items,
selected: 0,
scroll: 0,
};
let (add_tx, _add_rx) = mpsc::unbounded_channel::<PackageItem>();
let ke = key_event(KeyCode::Enter, KeyModifiers::empty());
handle_modal_key(ke, &mut app, &add_tx);
// Modal should remain open since Enter opens URL but doesn't close modal
match &app.modal {
crate::state::Modal::News { selected, .. } => {
assert_eq!(*selected, 0);
}
_ => panic!("Modal should remain News after Enter key"),
}
// No cleanup needed - open_url is a no-op during tests
}
#[test]
/// What: Verify unhandled keys in News modal don't break state.
///
/// Inputs:
/// - News modal
/// - Unhandled key event (e.g., 'x')
///
/// Output:
/// - Modal remains open with unchanged state
///
/// Details:
/// - Ensures unhandled keys don't cause issues
fn news_unhandled_key_preserves_modal() {
let mut app = new_app();
let items = vec![crate::state::types::NewsFeedItem {
id: "https://example.com/news".to_string(),
date: "2025-01-01".to_string(),
title: "Test News".to_string(),
summary: None,
url: Some("https://example.com/news".to_string()),
source: crate::state::types::NewsFeedSource::ArchNews,
severity: None,
packages: Vec::new(),
}];
app.modal = crate::state::Modal::News {
items,
selected: 0,
scroll: 0,
};
let (add_tx, _add_rx) = mpsc::unbounded_channel::<PackageItem>();
let ke = key_event(KeyCode::Char('x'), KeyModifiers::empty());
handle_modal_key(ke, &mut app, &add_tx);
// Modal should remain open since 'x' is not handled
match &app.modal {
crate::state::Modal::News { selected, .. } => {
assert_eq!(*selected, 0);
}
_ => panic!("Modal should remain News for unhandled key"),
}
}
#[test]
/// What: Verify Ctrl+R in News modal triggers mark all read instead of config reload.
///
/// Inputs:
/// - News modal with multiple items
/// - Ctrl+R key event
///
/// Output:
/// - All news items are marked as read
/// - Modal remains open
/// - Config reload does NOT happen
///
/// Details:
/// - Ensures that when News modal is active, Ctrl+R triggers news action (mark all read)
/// instead of the global config reload action
/// - Only works in normal mode
fn news_ctrl_r_mark_all_read_not_config_reload() {
let mut app = new_app();
app.search_normal_mode = true; // Must be in normal mode
let items = vec![
crate::state::types::NewsFeedItem {
id: "https://example.com/news1".to_string(),
date: "2025-01-01".to_string(),
title: "Test News 1".to_string(),
summary: None,
url: Some("https://example.com/news1".to_string()),
source: crate::state::types::NewsFeedSource::ArchNews,
severity: None,
packages: Vec::new(),
},
crate::state::types::NewsFeedItem {
id: "https://example.com/news2".to_string(),
date: "2025-01-02".to_string(),
title: "Test News 2".to_string(),
summary: None,
url: Some("https://example.com/news2".to_string()),
source: crate::state::types::NewsFeedSource::ArchNews,
severity: None,
packages: Vec::new(),
},
crate::state::types::NewsFeedItem {
id: "https://example.com/news3".to_string(),
date: "2025-01-03".to_string(),
title: "Test News 3".to_string(),
summary: None,
url: Some("https://example.com/news3".to_string()),
source: crate::state::types::NewsFeedSource::ArchNews,
severity: None,
packages: Vec::new(),
},
];
app.modal = crate::state::Modal::News {
items,
selected: 0,
scroll: 0,
};
let (add_tx, _add_rx) = mpsc::unbounded_channel::<PackageItem>();
let ke = key_event(KeyCode::Char('r'), KeyModifiers::CONTROL);
// Verify initial state - no items marked as read
assert!(app.news_read_urls.is_empty());
assert!(!app.news_read_dirty);
handle_modal_key(ke, &mut app, &add_tx);
// Verify all items are marked as read
assert!(app.news_read_urls.contains("https://example.com/news1"));
assert!(app.news_read_urls.contains("https://example.com/news2"));
assert!(app.news_read_urls.contains("https://example.com/news3"));
assert_eq!(app.news_read_urls.len(), 3);
assert!(app.news_read_dirty);
// Verify modal remains open
match &app.modal {
crate::state::Modal::News { selected, .. } => {
assert_eq!(*selected, 0);
}
_ => panic!("Modal should remain News after Ctrl+R"),
}
// Verify config reload did NOT happen (no toast message about config reload)
// Config reload would set a toast message, but mark all read doesn't
assert!(app.toast_message.is_none());
}
#[test]
/// What: Verify 'r' (mark single read) works in News modal without conflict.
///
/// Inputs:
/// - News modal with items
/// - 'r' key event (no modifiers)
///
/// Output:
/// - Single item marked as read
///
/// Details:
/// - Tests that lowercase 'r' works for mark single read
/// - Only works in normal mode
fn news_modal_lowercase_r_marks_single_read() {
let mut app = new_app();
app.search_normal_mode = true; // Must be in normal mode
let items = vec![
crate::state::types::NewsFeedItem {
id: "https://example.com/1".to_string(),
date: "2025-01-01".to_string(),
title: "News 1".to_string(),
summary: None,
url: Some("https://example.com/1".to_string()),
source: crate::state::types::NewsFeedSource::ArchNews,
severity: None,
packages: Vec::new(),
},
crate::state::types::NewsFeedItem {
id: "https://example.com/2".to_string(),
date: "2025-01-02".to_string(),
title: "News 2".to_string(),
summary: None,
url: Some("https://example.com/2".to_string()),
source: crate::state::types::NewsFeedSource::ArchNews,
severity: None,
packages: Vec::new(),
},
];
app.modal = crate::state::Modal::News {
items,
selected: 0,
scroll: 0,
};
let (add_tx, _add_rx) = mpsc::unbounded_channel::<PackageItem>();
let ke = key_event(KeyCode::Char('r'), KeyModifiers::empty());
handle_modal_key(ke, &mut app, &add_tx);
// Only first item should be marked as read
assert_eq!(
app.news_read_urls.len(),
1,
"Only selected item should be marked as read"
);
assert!(
app.news_read_urls.contains("https://example.com/1"),
"First item URL should be marked as read"
);
assert!(app.news_read_dirty);
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/modals/tests/confirm.rs | src/events/modals/tests/confirm.rs | //! Tests for `ConfirmInstall` and `ConfirmRemove` modal key event handling.
use crossterm::event::{KeyCode, KeyModifiers};
use tokio::sync::mpsc;
use crate::state::{PackageItem, Source};
use super::common::{key_event, new_app};
use super::handle_modal_key;
#[test]
/// What: Verify Esc key closes `ConfirmInstall` modal.
///
/// Inputs:
/// - `ConfirmInstall` modal with items
/// - Esc key event
///
/// Output:
/// - Modal is set to None
///
/// Details:
/// - Tests that Esc closes `ConfirmInstall` modal correctly
fn confirm_install_esc_closes_modal() {
let mut app = new_app();
app.modal = crate::state::Modal::ConfirmInstall {
items: vec![PackageItem {
name: "test-pkg".to_string(),
version: "1.0".to_string(),
description: String::new(),
source: Source::Aur,
popularity: None,
out_of_date: None,
orphaned: false,
}],
};
let (add_tx, _add_rx) = mpsc::unbounded_channel::<PackageItem>();
let ke = key_event(KeyCode::Esc, KeyModifiers::empty());
handle_modal_key(ke, &mut app, &add_tx);
assert!(matches!(app.modal, crate::state::Modal::None));
}
#[test]
/// What: Verify Esc key closes `ConfirmRemove` modal.
///
/// Inputs:
/// - `ConfirmRemove` modal with items
/// - Esc key event
///
/// Output:
/// - Modal is set to None
///
/// Details:
/// - Tests that Esc closes `ConfirmRemove` modal correctly
fn confirm_remove_esc_closes_modal() {
let mut app = new_app();
app.modal = crate::state::Modal::ConfirmRemove {
items: vec![PackageItem {
name: "test-pkg".to_string(),
version: "1.0".to_string(),
description: String::new(),
source: Source::Aur,
popularity: None,
out_of_date: None,
orphaned: false,
}],
};
let (add_tx, _add_rx) = mpsc::unbounded_channel::<PackageItem>();
let ke = key_event(KeyCode::Esc, KeyModifiers::empty());
handle_modal_key(ke, &mut app, &add_tx);
assert!(matches!(app.modal, crate::state::Modal::None));
}
#[test]
/// What: Verify Enter key closes `ConfirmRemove` modal.
///
/// Inputs:
/// - `ConfirmRemove` modal with items
/// - Enter key event
///
/// Output:
/// - Modal is set to None
///
/// Details:
/// - Tests that Enter also closes `ConfirmRemove` modal
/// - Cleans up terminal window opened by the test
fn confirm_remove_enter_closes_modal() {
let mut app = new_app();
app.modal = crate::state::Modal::ConfirmRemove {
items: vec![PackageItem {
name: "test-pkg".to_string(),
version: "1.0".to_string(),
description: String::new(),
source: Source::Aur,
popularity: None,
out_of_date: None,
orphaned: false,
}],
};
let (add_tx, _add_rx) = mpsc::unbounded_channel::<PackageItem>();
let ke = key_event(KeyCode::Enter, KeyModifiers::empty());
handle_modal_key(ke, &mut app, &add_tx);
assert!(matches!(app.modal, crate::state::Modal::None));
// No cleanup needed - spawn_shell_commands_in_terminal is a no-op during tests
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/modals/tests/scan.rs | src/events/modals/tests/scan.rs | //! Tests for `ScanConfig` and `VirusTotalSetup` modal key event handling.
use crossterm::event::{KeyCode, KeyModifiers};
use tokio::sync::mpsc;
use crate::state::PackageItem;
use super::common::{key_event, new_app};
use super::handle_modal_key;
#[test]
/// What: Verify Esc key closes `ScanConfig` modal and doesn't restore it.
///
/// Inputs:
/// - `ScanConfig` modal
/// - Esc key event
///
/// Output:
/// - Modal is set to None and remains None (not restored)
///
/// Details:
/// - Tests the bug fix where Esc was being immediately restored
fn scan_config_esc_closes_modal() {
let mut app = new_app();
app.modal = crate::state::Modal::ScanConfig {
do_clamav: false,
do_trivy: false,
do_semgrep: false,
do_shellcheck: false,
do_virustotal: false,
do_custom: false,
do_sleuth: false,
cursor: 0,
};
let (add_tx, _add_rx) = mpsc::unbounded_channel::<PackageItem>();
let ke = key_event(KeyCode::Esc, KeyModifiers::empty());
handle_modal_key(ke, &mut app, &add_tx);
assert!(matches!(app.modal, crate::state::Modal::None));
}
#[test]
/// What: Verify Esc key closes `VirusTotalSetup` modal and doesn't restore it.
///
/// Inputs:
/// - `VirusTotalSetup` modal
/// - Esc key event
///
/// Output:
/// - Modal is set to None and remains None (not restored)
///
/// Details:
/// - Tests the bug fix where Esc was being immediately restored
fn virustotal_setup_esc_closes_modal() {
let mut app = new_app();
app.modal = crate::state::Modal::VirusTotalSetup {
input: String::new(),
cursor: 0,
};
let (add_tx, _add_rx) = mpsc::unbounded_channel::<PackageItem>();
let ke = key_event(KeyCode::Esc, KeyModifiers::empty());
handle_modal_key(ke, &mut app, &add_tx);
assert!(matches!(app.modal, crate::state::Modal::None));
}
#[test]
/// What: Verify Enter key in `VirusTotalSetup` modal with empty input opens browser.
///
/// Inputs:
/// - `VirusTotalSetup` modal with empty input
/// - Enter key event
///
/// Output:
/// - Modal remains open and browser opens
///
/// Details:
/// - Ensures Enter key works correctly when input is empty
/// - Cleans up browser tab opened by the test
fn virustotal_setup_enter_opens_browser() {
let mut app = new_app();
app.modal = crate::state::Modal::VirusTotalSetup {
input: String::new(),
cursor: 0,
};
let (add_tx, _add_rx) = mpsc::unbounded_channel::<PackageItem>();
let ke = key_event(KeyCode::Enter, KeyModifiers::empty());
handle_modal_key(ke, &mut app, &add_tx);
// Modal should remain open since input is empty
match &app.modal {
crate::state::Modal::VirusTotalSetup { .. } => {}
_ => panic!("Modal should remain VirusTotalSetup after Enter with empty input"),
}
// No cleanup needed - open_url is a no-op during tests
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/modals/optional_deps/tests.rs | src/events/modals/optional_deps/tests.rs | //! Unit tests for optional dependencies modal handlers.
use crate::state::{AppState, types::OptionalDepRow};
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
use crate::events::modals::optional_deps::handle_optional_deps;
/// What: Create a test optional dependency row.
///
/// Inputs:
/// - `package`: Package name
/// - `installed`: Whether package is installed
/// - `selectable`: Whether row is selectable
///
/// Output:
/// - `OptionalDepRow` ready for testing
///
/// Details:
/// - Helper to create test optional dependency rows
fn create_test_row(package: &str, installed: bool, selectable: bool) -> OptionalDepRow {
OptionalDepRow {
label: format!("Test: {package}"),
package: package.into(),
installed,
selectable,
note: None,
}
}
#[test]
/// What: Verify `OptionalDeps` modal handles Esc to close.
///
/// Inputs:
/// - `OptionalDeps` modal, Esc key event.
///
/// Output:
/// - Modal is closed.
///
/// Details:
/// - Tests that Esc closes the `OptionalDeps` modal.
fn optional_deps_esc_closes_modal() {
let mut app = AppState::default();
let rows = vec![create_test_row("test-pkg", false, true)];
app.modal = crate::state::Modal::OptionalDeps {
rows: rows.clone(),
selected: 0,
};
let mut selected = 0;
let ke = KeyEvent::new(KeyCode::Esc, KeyModifiers::empty());
let result = handle_optional_deps(ke, &mut app, &rows, &mut selected);
match app.modal {
crate::state::Modal::None => {}
_ => panic!("Expected modal to be closed"),
}
assert_eq!(result, Some(false));
}
#[test]
/// What: Verify `OptionalDeps` modal handles navigation.
///
/// Inputs:
/// - `OptionalDeps` modal, Down key event.
///
/// Output:
/// - Selection moves down.
///
/// Details:
/// - Tests that navigation keys work in `OptionalDeps` modal.
fn optional_deps_navigation() {
let mut app = AppState::default();
let rows = vec![
create_test_row("pkg1", false, true),
create_test_row("pkg2", false, true),
];
app.modal = crate::state::Modal::OptionalDeps {
rows: rows.clone(),
selected: 0,
};
let mut selected = 0;
let ke = KeyEvent::new(KeyCode::Down, KeyModifiers::empty());
let _ = handle_optional_deps(ke, &mut app, &rows, &mut selected);
assert_eq!(selected, 1, "Selection should move down");
}
#[test]
/// What: Verify `OptionalDeps` modal handles Enter to install.
///
/// Inputs:
/// - `OptionalDeps` modal with selectable row, Enter key event.
///
/// Output:
/// - Installation is executed (spawns terminal - will fail in test environment).
///
/// Details:
/// - Tests that Enter triggers optional dependency installation.
/// - Note: This will spawn a terminal, so it's expected to fail in test environment.
fn optional_deps_enter_installs() {
let mut app = AppState::default();
let rows = vec![create_test_row("test-pkg", false, true)];
app.modal = crate::state::Modal::OptionalDeps {
rows: rows.clone(),
selected: 0,
};
let mut selected = 0;
let ke = KeyEvent::new(KeyCode::Enter, KeyModifiers::empty());
let result = handle_optional_deps(ke, &mut app, &rows, &mut selected);
// Should return Some(true) when installation is triggered
assert_eq!(result, Some(true));
// Modal should transition to PreflightExec after installation is triggered
match app.modal {
crate::state::Modal::PreflightExec { .. } => {
// Expected - installation now uses executor pattern and transitions to PreflightExec
}
_ => panic!("Expected modal to transition to PreflightExec after installation"),
}
// Verify that pending_executor_request is set
assert!(
app.pending_executor_request.is_some(),
"Optional deps installation should set pending_executor_request"
);
}
#[test]
/// What: Verify `OptionalDeps` modal Enter on installed package shows reinstall confirmation.
///
/// Inputs:
/// - `OptionalDeps` modal with installed row, Enter key event.
///
/// Output:
/// - `ConfirmReinstall` modal is opened.
///
/// Details:
/// - Tests that Enter on installed packages shows reinstall confirmation modal.
/// - After confirmation, the package will be reinstalled.
fn optional_deps_enter_installed_shows_reinstall() {
let mut app = AppState::default();
let rows = vec![create_test_row("test-pkg", true, false)];
app.modal = crate::state::Modal::OptionalDeps {
rows: rows.clone(),
selected: 0,
};
let mut selected = 0;
let ke = KeyEvent::new(KeyCode::Enter, KeyModifiers::empty());
let result = handle_optional_deps(ke, &mut app, &rows, &mut selected);
// Should return Some(false) when showing reinstall confirmation
assert_eq!(result, Some(false));
// Modal should transition to ConfirmReinstall
match app.modal {
crate::state::Modal::ConfirmReinstall { .. } => {}
_ => panic!("Expected modal to transition to ConfirmReinstall"),
}
}
#[test]
/// What: Verify `OptionalDeps` modal Enter on virustotal-setup opens setup modal.
///
/// Inputs:
/// - `OptionalDeps` modal with virustotal-setup row, Enter key event.
///
/// Output:
/// - `VirusTotalSetup` modal is opened.
///
/// Details:
/// - Tests that Enter on virustotal-setup opens the setup modal.
fn optional_deps_enter_virustotal_setup() {
let mut app = AppState::default();
let rows = vec![create_test_row("virustotal-setup", false, true)];
app.modal = crate::state::Modal::OptionalDeps {
rows: rows.clone(),
selected: 0,
};
let mut selected = 0;
let ke = KeyEvent::new(KeyCode::Enter, KeyModifiers::empty());
let _ = handle_optional_deps(ke, &mut app, &rows, &mut selected);
match app.modal {
crate::state::Modal::VirusTotalSetup { .. } => {}
_ => panic!("Expected VirusTotalSetup modal"),
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/modals/system_update/tests.rs | src/events/modals/system_update/tests.rs | //! Unit tests for system update modal handlers.
use crate::state::AppState;
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
use super::handle_system_update;
#[test]
/// What: Verify `SystemUpdate` modal handles Esc to close.
///
/// Inputs:
/// - `SystemUpdate` modal, Esc key event.
///
/// Output:
/// - Modal is closed.
///
/// Details:
/// - Tests that Esc closes the `SystemUpdate` modal.
fn system_update_esc_closes_modal() {
let mut app = AppState {
modal: crate::state::Modal::SystemUpdate {
do_mirrors: false,
do_pacman: false,
force_sync: false,
do_aur: false,
do_cache: false,
country_idx: 0,
countries: vec!["Worldwide".to_string()],
mirror_count: 10,
cursor: 0,
},
..Default::default()
};
let mut do_mirrors = false;
let mut do_pacman = false;
let mut force_sync = false;
let mut do_aur = false;
let mut do_cache = false;
let mut country_idx = 0;
let countries = vec!["Worldwide".to_string()];
let mut mirror_count = 10;
let mut cursor = 0;
let ke = KeyEvent::new(KeyCode::Esc, KeyModifiers::empty());
let _ = handle_system_update(
ke,
&mut app,
&mut do_mirrors,
&mut do_pacman,
&mut force_sync,
&mut do_aur,
&mut do_cache,
&mut country_idx,
&countries,
&mut mirror_count,
&mut cursor,
);
match app.modal {
crate::state::Modal::None => {}
_ => panic!("Expected modal to be closed"),
}
}
#[test]
/// What: Verify `SystemUpdate` modal handles navigation.
///
/// Inputs:
/// - `SystemUpdate` modal, Down key event.
///
/// Output:
/// - Cursor moves down.
///
/// Details:
/// - Tests that navigation keys work in `SystemUpdate` modal.
fn system_update_navigation() {
let mut app = AppState {
modal: crate::state::Modal::SystemUpdate {
do_mirrors: false,
do_pacman: false,
force_sync: false,
do_aur: false,
do_cache: false,
country_idx: 0,
countries: vec!["Worldwide".to_string()],
mirror_count: 10,
cursor: 0,
},
..Default::default()
};
let mut do_mirrors = false;
let mut do_pacman = false;
let mut force_sync = false;
let mut do_aur = false;
let mut do_cache = false;
let mut country_idx = 0;
let countries = vec!["Worldwide".to_string()];
let mut mirror_count = 10;
let mut cursor = 0;
let ke = KeyEvent::new(KeyCode::Down, KeyModifiers::empty());
let _ = handle_system_update(
ke,
&mut app,
&mut do_mirrors,
&mut do_pacman,
&mut force_sync,
&mut do_aur,
&mut do_cache,
&mut country_idx,
&countries,
&mut mirror_count,
&mut cursor,
);
assert_eq!(cursor, 1, "Cursor should move down");
}
#[test]
/// What: Verify `SystemUpdate` modal handles toggle with Space.
///
/// Inputs:
/// - `SystemUpdate` modal, Space key event on first option.
///
/// Output:
/// - `do_mirrors` flag is toggled.
///
/// Details:
/// - Tests that Space toggles options in `SystemUpdate` modal.
fn system_update_toggle() {
let mut app = AppState {
modal: crate::state::Modal::SystemUpdate {
do_mirrors: false,
do_pacman: false,
force_sync: false,
do_aur: false,
do_cache: false,
country_idx: 0,
countries: vec!["Worldwide".to_string()],
mirror_count: 10,
cursor: 0,
},
..Default::default()
};
let mut do_mirrors = false;
let mut do_pacman = false;
let mut force_sync = false;
let mut do_aur = false;
let mut do_cache = false;
let mut country_idx = 0;
let countries = vec!["Worldwide".to_string()];
let mut mirror_count = 10;
let mut cursor = 0;
let ke = KeyEvent::new(KeyCode::Char(' '), KeyModifiers::empty());
let _ = handle_system_update(
ke,
&mut app,
&mut do_mirrors,
&mut do_pacman,
&mut force_sync,
&mut do_aur,
&mut do_cache,
&mut country_idx,
&countries,
&mut mirror_count,
&mut cursor,
);
assert!(do_mirrors, "do_mirrors should be toggled to true");
}
#[test]
/// What: Verify `SystemUpdate` modal handles Enter to show password prompt.
///
/// Inputs:
/// - `SystemUpdate` modal with options selected, Enter key event.
///
/// Output:
/// - Transitions to `PasswordPrompt` modal with pending update commands.
///
/// Details:
/// - Tests that Enter triggers password prompt before system update execution.
/// - Verifies that `pending_update_commands` is set with the update commands.
fn system_update_enter_executes() {
let mut app = AppState {
modal: crate::state::Modal::SystemUpdate {
do_mirrors: false,
do_pacman: true,
force_sync: false,
do_aur: false,
do_cache: false,
country_idx: 0,
countries: vec!["Worldwide".to_string()],
mirror_count: 10,
cursor: 0,
},
..Default::default()
};
let mut do_mirrors = false;
let mut do_pacman = true;
let mut force_sync = false;
let mut do_aur = false;
let mut do_cache = false;
let mut country_idx = 0;
let countries = vec!["Worldwide".to_string()];
let mut mirror_count = 10;
let mut cursor = 0;
let ke = KeyEvent::new(KeyCode::Enter, KeyModifiers::empty());
let result = handle_system_update(
ke,
&mut app,
&mut do_mirrors,
&mut do_pacman,
&mut force_sync,
&mut do_aur,
&mut do_cache,
&mut country_idx,
&countries,
&mut mirror_count,
&mut cursor,
);
// Should return Some(true) when Enter triggers password prompt
assert_eq!(result, Some(true));
// Modal should transition to PasswordPrompt
match &app.modal {
crate::state::Modal::PasswordPrompt { purpose, .. } => {
assert!(
matches!(purpose, crate::state::modal::PasswordPurpose::Update),
"Password purpose should be Update"
);
}
_ => panic!("Expected modal to transition to PasswordPrompt"),
}
// Verify that pending_update_commands is set
assert!(
app.pending_update_commands.is_some(),
"System update should set pending_update_commands"
);
// Verify the commands include pacman update with normal sync (-Syu)
let commands = app
.pending_update_commands
.as_ref()
.expect("pending_update_commands should be set");
assert!(
commands.iter().any(|c| c.contains("pacman -Syu")),
"Commands should include pacman -Syu for normal sync"
);
}
#[test]
/// What: Verify force sync option uses `-Syyu` instead of `-Syu`.
///
/// Inputs:
/// - `SystemUpdate` modal with `force_sync` enabled, Enter key event.
///
/// Output:
/// - Commands use `-Syyu` flag.
///
/// Details:
/// - Tests that enabling force sync uses the force database refresh flag.
fn system_update_force_sync_uses_syyu() {
let mut app = AppState {
modal: crate::state::Modal::SystemUpdate {
do_mirrors: false,
do_pacman: true,
force_sync: true,
do_aur: false,
do_cache: false,
country_idx: 0,
countries: vec!["Worldwide".to_string()],
mirror_count: 10,
cursor: 0,
},
..Default::default()
};
let mut do_mirrors = false;
let mut do_pacman = true;
let mut force_sync = true;
let mut do_aur = false;
let mut do_cache = false;
let mut country_idx = 0;
let countries = vec!["Worldwide".to_string()];
let mut mirror_count = 10;
let mut cursor = 0;
let ke = KeyEvent::new(KeyCode::Enter, KeyModifiers::empty());
let _ = handle_system_update(
ke,
&mut app,
&mut do_mirrors,
&mut do_pacman,
&mut force_sync,
&mut do_aur,
&mut do_cache,
&mut country_idx,
&countries,
&mut mirror_count,
&mut cursor,
);
// Verify the commands use -Syyu (force sync)
let commands = app
.pending_update_commands
.as_ref()
.expect("pending_update_commands should be set");
assert!(
commands.iter().any(|c| c.contains("-Syyu")),
"Commands should include -Syyu for force sync"
);
assert!(
!commands
.iter()
.any(|c| c.contains("-Syu --noconfirm") && !c.contains("-Syyu")),
"Commands should not include plain -Syu when force sync is enabled"
);
}
#[test]
/// What: Verify AUR update uses `-Sua` when pacman is also selected.
///
/// Inputs:
/// - `SystemUpdate` modal with both `do_pacman` and `do_aur` enabled, Enter key event.
///
/// Output:
/// - AUR command uses `-Sua` flag (AUR only, since official packages are updated by pacman).
///
/// Details:
/// - Tests that when both pacman and AUR updates are selected, AUR uses `-Sua` to avoid redundant official package updates.
fn system_update_aur_uses_sua_when_pacman_selected() {
let mut app = AppState {
modal: crate::state::Modal::SystemUpdate {
do_mirrors: false,
do_pacman: true,
force_sync: false,
do_aur: true,
do_cache: false,
country_idx: 0,
countries: vec!["Worldwide".to_string()],
mirror_count: 10,
cursor: 0,
},
..Default::default()
};
let mut do_mirrors = false;
let mut do_pacman = true;
let mut force_sync = false;
let mut do_aur = true;
let mut do_cache = false;
let mut country_idx = 0;
let countries = vec!["Worldwide".to_string()];
let mut mirror_count = 10;
let mut cursor = 0;
let ke = KeyEvent::new(KeyCode::Enter, KeyModifiers::empty());
let _ = handle_system_update(
ke,
&mut app,
&mut do_mirrors,
&mut do_pacman,
&mut force_sync,
&mut do_aur,
&mut do_cache,
&mut country_idx,
&countries,
&mut mirror_count,
&mut cursor,
);
// Verify the commands include pacman -Syu
let commands = app
.pending_update_commands
.as_ref()
.expect("pending_update_commands should be set");
assert!(
commands.iter().any(|c| c.contains("pacman -Syu")),
"Commands should include pacman -Syu"
);
// Verify AUR command is stored separately and uses -Sua (not -Syu) when pacman is also selected
let aur_command = app
.pending_aur_update_command
.as_ref()
.expect("pending_aur_update_command should be set when both pacman and AUR are selected");
assert!(
aur_command.contains("paru -Sua") || aur_command.contains("yay -Sua"),
"AUR command should use -Sua when pacman is also selected"
);
assert!(
!aur_command.contains("paru -Syu") && !aur_command.contains("yay -Syu"),
"AUR command should not use -Syu when pacman is also selected"
);
// Verify AUR command is NOT in the main command list
assert!(
!commands
.iter()
.any(|c| c.contains("paru") || c.contains("yay")),
"AUR command should not be in pending_update_commands when pacman is also selected"
);
}
#[test]
/// What: Verify AUR update uses `-Sua` when only AUR is selected (no pacman).
///
/// Inputs:
/// - `SystemUpdate` modal with only `do_aur` enabled (no pacman), Enter key event.
///
/// Output:
/// - AUR command uses `-Sua` flag (updates only AUR packages).
///
/// Details:
/// - Tests that when only AUR update is selected, AUR uses `-Sua` to update only AUR packages.
/// - AUR helpers will handle dependency resolution and report if newer official packages are needed.
fn system_update_aur_uses_sua_when_only_aur_selected() {
let mut app = AppState {
modal: crate::state::Modal::SystemUpdate {
do_mirrors: false,
do_pacman: false,
force_sync: false,
do_aur: true,
do_cache: false,
country_idx: 0,
countries: vec!["Worldwide".to_string()],
mirror_count: 10,
cursor: 0,
},
..Default::default()
};
let mut do_mirrors = false;
let mut do_pacman = false;
let mut force_sync = false;
let mut do_aur = true;
let mut do_cache = false;
let mut country_idx = 0;
let countries = vec!["Worldwide".to_string()];
let mut mirror_count = 10;
let mut cursor = 0;
let ke = KeyEvent::new(KeyCode::Enter, KeyModifiers::empty());
let _ = handle_system_update(
ke,
&mut app,
&mut do_mirrors,
&mut do_pacman,
&mut force_sync,
&mut do_aur,
&mut do_cache,
&mut country_idx,
&countries,
&mut mirror_count,
&mut cursor,
);
// Verify AUR command uses -Sua (not -Syu) when only AUR is selected
let commands = app
.pending_update_commands
.as_ref()
.expect("pending_update_commands should be set");
assert!(
commands
.iter()
.any(|c| c.contains("paru -Sua") || c.contains("yay -Sua")),
"AUR command should use -Sua when only AUR is selected"
);
assert!(
commands
.iter()
.all(|c| !c.contains("-Syu") || c.contains("-Sua")),
"AUR command should not use -Syu when only AUR is selected (must use -Sua if -Syu is present)"
);
}
#[test]
/// What: Verify left/right/tab keys toggle `force_sync` on pacman row.
///
/// Inputs:
/// - `SystemUpdate` modal on cursor row 1 (pacman), Left/Right/Tab key event.
///
/// Output:
/// - `force_sync` is toggled.
///
/// Details:
/// - Tests that Left/Right/Tab on pacman row toggles sync mode.
fn system_update_left_right_toggles_force_sync() {
let mut app = AppState {
modal: crate::state::Modal::SystemUpdate {
do_mirrors: false,
do_pacman: true,
force_sync: false,
do_aur: false,
do_cache: false,
country_idx: 0,
countries: vec!["Worldwide".to_string()],
mirror_count: 10,
cursor: 1, // Pacman row
},
..Default::default()
};
let mut do_mirrors = false;
let mut do_pacman = true;
let mut force_sync = false;
let mut do_aur = false;
let mut do_cache = false;
let mut country_idx = 0;
let countries = vec!["Worldwide".to_string()];
let mut mirror_count = 10;
let mut cursor = 1; // Pacman row
// Press Right to toggle force_sync to true
let ke = KeyEvent::new(KeyCode::Right, KeyModifiers::empty());
let _ = handle_system_update(
ke,
&mut app,
&mut do_mirrors,
&mut do_pacman,
&mut force_sync,
&mut do_aur,
&mut do_cache,
&mut country_idx,
&countries,
&mut mirror_count,
&mut cursor,
);
assert!(
force_sync,
"force_sync should be toggled to true with Right"
);
// Press Left to toggle force_sync back to false
let ke = KeyEvent::new(KeyCode::Left, KeyModifiers::empty());
let _ = handle_system_update(
ke,
&mut app,
&mut do_mirrors,
&mut do_pacman,
&mut force_sync,
&mut do_aur,
&mut do_cache,
&mut country_idx,
&countries,
&mut mirror_count,
&mut cursor,
);
assert!(
!force_sync,
"force_sync should be toggled back to false with Left"
);
// Press Tab to toggle force_sync to true
let ke = KeyEvent::new(KeyCode::Tab, KeyModifiers::empty());
let _ = handle_system_update(
ke,
&mut app,
&mut do_mirrors,
&mut do_pacman,
&mut force_sync,
&mut do_aur,
&mut do_cache,
&mut country_idx,
&countries,
&mut mirror_count,
&mut cursor,
);
assert!(force_sync, "force_sync should be toggled to true with Tab");
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/modals/install/tests.rs | src/events/modals/install/tests.rs | //! Unit tests for install and remove modal handlers.
#![cfg(test)]
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
use crate::state::{AppState, PackageItem, Source};
use super::{handle_confirm_install, handle_confirm_remove};
/// What: Create a test package item with specified source.
///
/// Inputs:
/// - `name`: Package name
/// - `source`: Package source (Official or AUR)
///
/// Output:
/// - PackageItem ready for testing
///
/// Details:
/// - Helper to create test packages with consistent structure
fn create_test_package(name: &str, source: Source) -> PackageItem {
PackageItem {
name: name.into(),
version: "1.0.0".into(),
description: String::new(),
source,
popularity: None,
out_of_date: None,
orphaned: false,
}
}
#[test]
/// What: Verify ConfirmInstall modal handles Esc to close.
///
/// Inputs:
/// - ConfirmInstall modal, Esc key event.
///
/// Output:
/// - Modal is closed.
///
/// Details:
/// - Tests that Esc closes the ConfirmInstall modal.
fn confirm_install_esc_closes_modal() {
let mut app = AppState::default();
let items = vec![create_test_package("test-pkg", Source::Aur)];
app.modal = crate::state::Modal::ConfirmInstall {
items: items.clone(),
};
let ke = KeyEvent::new(KeyCode::Esc, KeyModifiers::empty());
let _ = handle_confirm_install(ke, &mut app, &items);
match app.modal {
crate::state::Modal::None => {}
_ => panic!("Expected modal to be closed"),
}
}
#[test]
/// What: Verify ConfirmRemove modal handles Esc to cancel.
///
/// Inputs:
/// - ConfirmRemove modal, Esc key event.
///
/// Output:
/// - Modal is closed (removal cancelled).
///
/// Details:
/// - Tests that Esc cancels removal and closes modal.
fn confirm_remove_esc_cancels() {
let mut app = AppState::default();
let items = vec![create_test_package(
"test-pkg",
Source::Official {
repo: "extra".into(),
arch: "x86_64".into(),
},
)];
app.modal = crate::state::Modal::ConfirmRemove {
items: items.clone(),
};
let ke = KeyEvent::new(KeyCode::Esc, KeyModifiers::empty());
let _ = handle_confirm_remove(ke, &mut app, &items);
match app.modal {
crate::state::Modal::None => {}
_ => panic!("Expected modal to be closed"),
}
}
#[test]
/// What: Verify ConfirmRemove modal requires explicit 'y' confirmation.
///
/// Inputs:
/// - ConfirmRemove modal, Enter key event (should cancel).
///
/// Output:
/// - Modal is closed (removal cancelled, Enter defaults to No).
///
/// Details:
/// - Tests that Enter cancels removal (defaults to No).
fn confirm_remove_enter_defaults_to_no() {
let mut app = AppState::default();
let items = vec![create_test_package(
"test-pkg",
Source::Official {
repo: "extra".into(),
arch: "x86_64".into(),
},
)];
app.modal = crate::state::Modal::ConfirmRemove {
items: items.clone(),
};
let ke = KeyEvent::new(KeyCode::Enter, KeyModifiers::empty());
let _ = handle_confirm_remove(ke, &mut app, &items);
match app.modal {
crate::state::Modal::None => {}
_ => panic!("Expected modal to be closed (Enter defaults to No)"),
}
}
#[test]
/// What: Verify ConfirmRemove modal proceeds with 'y' confirmation.
///
/// Inputs:
/// - ConfirmRemove modal, 'y' key event.
///
/// Output:
/// - Removal is executed (spawns terminal - will fail in test environment).
///
/// Details:
/// - Tests that 'y' triggers removal execution.
/// - Note: This will spawn a terminal, so it's expected to fail in test environment.
fn confirm_remove_y_confirms() {
let mut app = AppState::default();
let items = vec![create_test_package(
"test-pkg",
Source::Official {
repo: "extra".into(),
arch: "x86_64".into(),
},
)];
app.modal = crate::state::Modal::ConfirmRemove {
items: items.clone(),
};
app.remove_cascade_mode = crate::state::modal::CascadeMode::Basic;
let ke = KeyEvent::new(KeyCode::Char('y'), KeyModifiers::empty());
let _ = handle_confirm_remove(ke, &mut app, &items);
// Modal should be closed after removal is triggered
match app.modal {
crate::state::Modal::None => {}
_ => panic!("Expected modal to be closed after removal"),
}
// Remove list should be cleared
assert!(app.remove_list.is_empty());
}
#[test]
/// What: Verify ConfirmInstall modal handles Enter to install.
///
/// Inputs:
/// - ConfirmInstall modal, Enter key event.
///
/// Output:
/// - Install is executed (spawns terminal - will fail in test environment).
///
/// Details:
/// - Tests that Enter triggers install execution.
/// - Note: This will spawn a terminal, so it's expected to fail in test environment.
fn confirm_install_enter_triggers_install() {
let mut app = AppState::default();
let items = vec![create_test_package("test-pkg", Source::Aur)];
app.modal = crate::state::Modal::ConfirmInstall {
items: items.clone(),
};
let ke = KeyEvent::new(KeyCode::Enter, KeyModifiers::empty());
let _ = handle_confirm_install(ke, &mut app, &items);
// Modal should be closed after install is triggered
match app.modal {
crate::state::Modal::None => {}
_ => panic!("Expected modal to be closed after install"),
}
}
#[test]
/// What: Verify ConfirmInstall modal handles 's' to open scan config.
///
/// Inputs:
/// - ConfirmInstall modal with AUR packages, 's' key event.
///
/// Output:
/// - ScanConfig modal is opened.
///
/// Details:
/// - Tests that 's' opens scan configuration for AUR packages.
fn confirm_install_s_opens_scan_config() {
let mut app = AppState::default();
let items = vec![create_test_package("test-pkg", Source::Aur)];
app.modal = crate::state::Modal::ConfirmInstall {
items: items.clone(),
};
let ke = KeyEvent::new(KeyCode::Char('s'), KeyModifiers::empty());
let _ = handle_confirm_install(ke, &mut app, &items);
match app.modal {
crate::state::Modal::ScanConfig { .. } => {}
_ => panic!("Expected ScanConfig modal"),
}
}
#[test]
/// What: Verify ConfirmInstall modal 's' shows alert for non-AUR packages.
///
/// Inputs:
/// - ConfirmInstall modal with only official packages, 's' key event.
///
/// Output:
/// - Alert modal is shown.
///
/// Details:
/// - Tests that 's' shows alert when no AUR packages are selected.
fn confirm_install_s_no_aur_shows_alert() {
let mut app = AppState::default();
let items = vec![create_test_package(
"test-pkg",
Source::Official {
repo: "extra".into(),
arch: "x86_64".into(),
},
)];
app.modal = crate::state::Modal::ConfirmInstall {
items: items.clone(),
};
let ke = KeyEvent::new(KeyCode::Char('s'), KeyModifiers::empty());
let _ = handle_confirm_install(ke, &mut app, &items);
match app.modal {
crate::state::Modal::Alert { .. } => {}
_ => panic!("Expected Alert modal for non-AUR packages"),
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/preflight/tests.rs | src/events/preflight/tests.rs | //! Tests for Preflight modal event handling.
#[cfg(test)]
use super::display::{
build_file_display_items, compute_display_items_len, compute_file_display_items_len,
};
#[cfg(test)]
use super::keys::handle_preflight_key;
#[cfg(test)]
use crate::state::modal::{
CascadeMode, DependencyInfo, DependencySource, DependencyStatus, FileChange, FileChangeType,
PackageFileInfo, ServiceImpact, ServiceRestartDecision,
};
#[cfg(test)]
use crate::state::{AppState, Modal, PackageItem, PreflightAction, PreflightTab, Source};
#[cfg(test)]
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
#[cfg(test)]
use std::collections::HashSet;
/// What: Construct a minimal `PackageItem` fixture used by preflight tests.
///
/// Inputs:
/// - `name`: Package identifier to embed in the resulting fixture.
///
/// Output:
/// - `PackageItem` populated with deterministic metadata for assertions.
///
/// Details:
/// - Provides consistent version/description/source values so each test can focus on modal behaviour.
fn pkg(name: &str) -> PackageItem {
PackageItem {
name: name.into(),
version: "1.0.0".into(),
description: "pkg".into(),
source: Source::Official {
repo: "extra".into(),
arch: "x86_64".into(),
},
popularity: None,
out_of_date: None,
orphaned: false,
}
}
/// What: Build a `DependencyInfo` fixture describing a package edge for dependency tests.
///
/// Inputs:
/// - `name`: Dependency package name to populate the struct.
/// - `required_by`: Slice of package names that declare the dependency.
///
/// Output:
/// - `DependencyInfo` instance configured for deterministic assertions.
///
/// Details:
/// - Sets predictable version/status/source fields so tests can concentrate on tree expansion logic.
fn dep(name: &str, required_by: &[&str]) -> DependencyInfo {
DependencyInfo {
name: name.into(),
version: ">=1".into(),
status: DependencyStatus::ToInstall,
source: DependencySource::Official {
repo: "extra".into(),
},
required_by: required_by.iter().map(|s| (*s).into()).collect(),
depends_on: Vec::new(),
is_core: false,
is_system: false,
}
}
/// What: Build a `DependencyInfo` fixture with a specific status for testing status display.
///
/// Inputs:
/// - `name`: Dependency package name to populate the struct.
/// - `required_by`: Slice of package names that declare the dependency.
/// - `status`: Specific dependency status to test.
///
/// Output:
/// - `DependencyInfo` instance with the specified status for assertions.
///
/// Details:
/// - Allows testing different dependency statuses (`Installed`, `ToInstall`, etc.) to verify correct display.
fn dep_with_status(name: &str, required_by: &[&str], status: DependencyStatus) -> DependencyInfo {
DependencyInfo {
name: name.into(),
version: ">=1".into(),
status,
source: DependencySource::Official {
repo: "extra".into(),
},
required_by: required_by.iter().map(|s| (*s).into()).collect(),
depends_on: Vec::new(),
is_core: false,
is_system: false,
}
}
/// What: Create a `PackageFileInfo` fixture with a configurable number of synthetic files.
///
/// Inputs:
/// - `name`: Package identifier associated with the file changes.
/// - `file_count`: Number of file entries to generate.
///
/// Output:
/// - `PackageFileInfo` containing `file_count` new file records under `/tmp`.
///
/// Details:
/// - Each generated file is marked as a new change, allowing tests to validate expansion counts easily.
fn file_info(name: &str, file_count: usize) -> PackageFileInfo {
let mut files = Vec::new();
for idx in 0..file_count {
files.push(FileChange {
path: format!("/tmp/{name}_{idx}"),
change_type: FileChangeType::New,
package: name.into(),
is_config: false,
predicted_pacnew: false,
predicted_pacsave: false,
});
}
PackageFileInfo {
name: name.into(),
files,
total_count: file_count,
new_count: file_count,
changed_count: 0,
removed_count: 0,
config_count: 0,
pacnew_candidates: 0,
pacsave_candidates: 0,
}
}
/// What: Construct a `ServiceImpact` fixture representing a single unit for Services tab tests.
///
/// Inputs:
/// - `unit`: Fully-qualified systemd unit identifier to populate the struct.
/// - `decision`: Initial restart preference that the test expects to mutate.
///
/// Output:
/// - `ServiceImpact` configured with deterministic metadata for assertions.
///
/// Details:
/// - Marks the unit as active and needing restart so event handlers may flip the decision.
fn svc(unit: &str, decision: ServiceRestartDecision) -> ServiceImpact {
ServiceImpact {
unit_name: unit.into(),
providers: vec!["target".into()],
is_active: true,
needs_restart: true,
recommended_decision: ServiceRestartDecision::Restart,
restart_decision: decision,
}
}
#[test]
/// What: Ensure dependency display length counts unique entries when groups are expanded.
///
/// Inputs:
/// - Dependency list with duplicates and an expanded set containing the first package.
///
/// Output:
/// - Computed length includes headers plus unique dependencies, yielding four rows.
///
/// Details:
/// - Demonstrates deduplication of repeated dependency records across packages.
fn deps_display_len_counts_unique_expanded_dependencies() {
let items = vec![pkg("app"), pkg("tool")];
let deps = vec![
dep("libfoo", &["app"]),
dep("libbar", &["app", "tool"]),
dep("libbar", &["app"]),
];
let mut expanded = HashSet::new();
expanded.insert("app".to_string());
let len = compute_display_items_len(&items, &deps, &expanded);
assert_eq!(len, 4);
}
#[test]
/// What: Verify the collapsed dependency view only counts package headers.
///
/// Inputs:
/// - Dependency list with multiple packages but an empty expanded set.
///
/// Output:
/// - Display length equals the number of packages (two).
///
/// Details:
/// - Confirms collapsed state omits dependency children entirely.
fn deps_display_len_collapsed_counts_only_headers() {
let items = vec![pkg("app"), pkg("tool")];
let deps = vec![dep("libfoo", &["app"]), dep("libbar", &["tool"])];
let expanded = HashSet::new();
let len = compute_display_items_len(&items, &deps, &expanded);
assert_eq!(len, 2);
}
#[test]
/// What: Confirm file display counts add child rows only for expanded entries.
///
/// Inputs:
/// - File info for a package with two files and another with zero files.
///
/// Output:
/// - Collapsed count returns two (both packages shown); expanded count increases to four (2 headers + 2 files).
///
/// Details:
/// - Exercises the branch that toggles between header-only and expanded file listings.
fn file_display_len_respects_expansion_state() {
let items = vec![pkg("pkg"), pkg("empty")];
let info = vec![file_info("pkg", 2), file_info("empty", 0)];
let mut expanded = HashSet::new();
let collapsed = compute_file_display_items_len(&items, &info, &expanded);
assert_eq!(collapsed, 2); // Both packages shown
expanded.insert("pkg".to_string());
let expanded_len = compute_file_display_items_len(&items, &info, &expanded);
assert_eq!(expanded_len, 4); // 2 headers + 2 files from pkg
}
#[test]
/// What: Ensure file display item builder yields headers plus placeholder rows when expanded.
///
/// Inputs:
/// - File info with two entries for a single package and varying expansion sets.
///
/// Output:
/// - Collapsed result contains only the header; expanded result includes header plus two child slots.
///
/// Details:
/// - Helps guarantee alignment between item construction and length calculations.
fn build_file_items_match_expansion() {
let items = vec![pkg("pkg")];
let info = vec![file_info("pkg", 2)];
let collapsed = build_file_display_items(&items, &info, &HashSet::new());
assert_eq!(collapsed, vec![(true, "pkg".into())]);
let mut expanded = HashSet::new();
expanded.insert("pkg".to_string());
let expanded_items = build_file_display_items(&items, &info, &expanded);
assert_eq!(
expanded_items,
vec![
(true, "pkg".into()),
(false, String::new()),
(false, String::new())
]
);
}
/// What: Prepare an `AppState` with a seeded Preflight modal tailored for keyboard interaction tests.
///
/// Inputs:
/// - `tab`: Initial tab to display inside the Preflight modal.
/// - `dependency_info`: Pre-resolved dependency list to seed the modal state.
/// - `dep_selected`: Initial selection index for the dependency list.
/// - `dep_tree_expanded`: Set of package names that should start expanded.
///
/// Output:
/// - `AppState` instance whose `modal` field is pre-populated with consistent fixtures.
///
/// Details:
/// - Reduces duplication across tests that exercise navigation/expansion logic within the Preflight modal.
fn setup_preflight_app(
tab: PreflightTab,
dependency_info: Vec<DependencyInfo>,
dep_selected: usize,
dep_tree_expanded: HashSet<String>,
) -> AppState {
let mut app = AppState::default();
let items = vec![pkg("target")];
app.modal = Modal::Preflight {
items,
action: PreflightAction::Install,
tab,
summary: None,
summary_scroll: 0,
header_chips: crate::state::modal::PreflightHeaderChips::default(),
dependency_info,
dep_selected,
dep_tree_expanded,
deps_error: None,
file_info: Vec::new(),
file_selected: 0,
file_tree_expanded: HashSet::new(),
files_error: None,
service_info: Vec::new(),
service_selected: 0,
services_loaded: false,
services_error: None,
sandbox_info: Vec::new(),
sandbox_selected: 0,
sandbox_tree_expanded: std::collections::HashSet::new(),
sandbox_loaded: false,
sandbox_error: None,
selected_optdepends: std::collections::HashMap::new(),
cascade_mode: CascadeMode::Basic,
cached_reverse_deps_report: None,
};
app
}
/// What: Build an `AppState` seeded with Services tab data for restart decision tests.
///
/// Inputs:
/// - `tab`: Initial tab to display inside the Preflight modal (expected to be Services).
/// - `service_info`: Collection of service impacts to expose through the modal.
/// - `service_selected`: Index that should be focused when the test begins.
///
/// Output:
/// - `AppState` populated with deterministic fixtures for Services tab interactions.
///
/// Details:
/// - Marks services as already loaded so handlers operate directly on the provided data.
fn setup_preflight_app_with_services(
tab: PreflightTab,
service_info: Vec<ServiceImpact>,
service_selected: usize,
) -> AppState {
let mut app = AppState::default();
let items = vec![pkg("target")];
app.modal = Modal::Preflight {
items,
action: PreflightAction::Install,
tab,
summary: None,
summary_scroll: 0,
header_chips: crate::state::modal::PreflightHeaderChips::default(),
dependency_info: Vec::new(),
dep_selected: 0,
dep_tree_expanded: HashSet::new(),
deps_error: None,
file_info: Vec::new(),
file_selected: 0,
file_tree_expanded: HashSet::new(),
files_error: None,
service_info,
service_selected,
services_loaded: true,
services_error: None,
sandbox_info: Vec::new(),
sandbox_selected: 0,
sandbox_tree_expanded: std::collections::HashSet::new(),
sandbox_loaded: false,
sandbox_error: None,
selected_optdepends: std::collections::HashMap::new(),
cascade_mode: CascadeMode::Basic,
cached_reverse_deps_report: None,
};
app
}
#[test]
/// What: Verify `Enter` toggles dependency expansion state within the preflight modal.
///
/// Inputs:
/// - Preflight modal focused on dependencies with an initial collapsed state.
///
/// Output:
/// - First `Enter` expands the target group; second `Enter` collapses it.
///
/// Details:
/// - Uses synthetic key events to mimic user interaction without rendering.
fn handle_enter_toggles_dependency_group() {
let deps = vec![dep("libfoo", &["target"])];
let mut app = setup_preflight_app(PreflightTab::Deps, deps, 0, HashSet::new());
let enter = KeyEvent::new(KeyCode::Enter, KeyModifiers::empty());
handle_preflight_key(enter, &mut app);
if let Modal::Preflight {
dep_tree_expanded, ..
} = &app.modal
{
assert!(dep_tree_expanded.contains("target"));
} else {
panic!("expected Preflight modal");
}
let enter_again = KeyEvent::new(KeyCode::Enter, KeyModifiers::empty());
handle_preflight_key(enter_again, &mut app);
if let Modal::Preflight {
dep_tree_expanded, ..
} = &app.modal
{
assert!(!dep_tree_expanded.contains("target"));
} else {
panic!("expected Preflight modal");
}
}
#[test]
/// What: Ensure navigation does not move past the last visible dependency row when expanded.
///
/// Inputs:
/// - Preflight modal with expanded dependencies and repeated `Down` key events.
///
/// Output:
/// - Selection stops at the final row instead of wrapping or overshooting.
///
/// Details:
/// - Exercises selection bounds checking for keyboard navigation.
fn handle_down_stops_at_last_visible_dependency_row() {
let deps = vec![dep("libfoo", &["target"]), dep("libbar", &["target"])];
let mut expanded = HashSet::new();
expanded.insert("target".to_string());
let mut app = setup_preflight_app(PreflightTab::Deps, deps, 0, expanded);
handle_preflight_key(
KeyEvent::new(KeyCode::Down, KeyModifiers::empty()),
&mut app,
);
handle_preflight_key(
KeyEvent::new(KeyCode::Down, KeyModifiers::empty()),
&mut app,
);
handle_preflight_key(
KeyEvent::new(KeyCode::Down, KeyModifiers::empty()),
&mut app,
);
if let Modal::Preflight { dep_selected, .. } = &app.modal {
assert_eq!(*dep_selected, 2);
} else {
panic!("expected Preflight modal");
}
}
#[test]
/// What: Confirm spacebar toggles the service restart decision within the Services tab.
///
/// Inputs:
/// - Preflight modal focused on Services with a single restart-ready unit selected.
///
/// Output:
/// - First space press defers the restart; second space press restores the restart decision.
///
/// Details:
/// - Exercises the branch that flips `ServiceRestartDecision` without mutating selection.
fn handle_space_toggles_service_restart_decision() {
let services = vec![svc("nginx.service", ServiceRestartDecision::Restart)];
let mut app = setup_preflight_app_with_services(PreflightTab::Services, services, 0);
handle_preflight_key(
KeyEvent::new(KeyCode::Char(' '), KeyModifiers::empty()),
&mut app,
);
if let Modal::Preflight { service_info, .. } = &app.modal {
assert_eq!(
service_info[0].restart_decision,
ServiceRestartDecision::Defer
);
} else {
panic!("expected Preflight modal");
}
handle_preflight_key(
KeyEvent::new(KeyCode::Char(' '), KeyModifiers::empty()),
&mut app,
);
if let Modal::Preflight { service_info, .. } = &app.modal {
assert_eq!(
service_info[0].restart_decision,
ServiceRestartDecision::Restart
);
} else {
panic!("expected Preflight modal");
}
}
#[test]
/// What: Ensure dedicated shortcuts force service restart decisions regardless of current state.
///
/// Inputs:
/// - Services tab with one unit initially set to defer, then the `r` and `Shift+D` bindings.
///
/// Output:
/// - `r` enforces restart, `Shift+D` enforces defer on the focused service.
///
/// Details:
/// - Verifies that direct commands override any prior toggled state for the selected row.
fn handle_service_restart_shortcuts_force_decisions() {
let services = vec![svc("postgresql.service", ServiceRestartDecision::Defer)];
let mut app = setup_preflight_app_with_services(PreflightTab::Services, services, 0);
handle_preflight_key(
KeyEvent::new(KeyCode::Char('r'), KeyModifiers::empty()),
&mut app,
);
if let Modal::Preflight { service_info, .. } = &app.modal {
assert_eq!(
service_info[0].restart_decision,
ServiceRestartDecision::Restart
);
} else {
panic!("expected Preflight modal");
}
handle_preflight_key(
KeyEvent::new(KeyCode::Char('D'), KeyModifiers::SHIFT),
&mut app,
);
if let Modal::Preflight { service_info, .. } = &app.modal {
assert_eq!(
service_info[0].restart_decision,
ServiceRestartDecision::Defer
);
} else {
panic!("expected Preflight modal");
}
}
#[test]
/// What: Verify that installed dependencies are correctly included in the dependency list.
///
/// Inputs:
/// - Preflight modal with dependencies including installed ones.
///
/// Output:
/// - All dependencies, including installed ones, are present in `dependency_info`.
///
/// Details:
/// - Tests that installed dependencies are not filtered out and should display with checkmarks.
fn installed_dependencies_are_included_in_list() {
let installed_dep = dep_with_status(
"libinstalled",
&["target"],
DependencyStatus::Installed {
version: "1.2.3".into(),
},
);
let to_install_dep = dep("libnew", &["target"]);
let deps = vec![installed_dep, to_install_dep];
let app = setup_preflight_app(PreflightTab::Deps, deps, 0, HashSet::new());
if let Modal::Preflight {
dependency_info, ..
} = &app.modal
{
assert_eq!(dependency_info.len(), 2);
// Verify installed dependency is present
assert!(
dependency_info.iter().any(|d| d.name == "libinstalled"
&& matches!(d.status, DependencyStatus::Installed { .. }))
);
// Verify to-install dependency is present
assert!(
dependency_info
.iter()
.any(|d| d.name == "libnew" && matches!(d.status, DependencyStatus::ToInstall))
);
} else {
panic!("expected Preflight modal");
}
}
#[test]
/// What: Verify that cached dependencies are correctly loaded when switching to Deps tab.
///
/// Inputs:
/// - `AppState` with cached dependencies in `install_list_deps`.
/// - Preflight modal initially on Summary tab, then switching to Deps tab.
///
/// Output:
/// - Cached dependencies are loaded into `dependency_info` when switching to Deps tab.
///
/// Details:
/// - Tests the tab switching logic that loads cached dependencies from app state.
fn cached_dependencies_load_on_tab_switch() {
let mut app = AppState::default();
let items = vec![pkg("target")];
let cached_deps = vec![dep("libcached", &["target"])];
app.install_list_deps = cached_deps;
app.modal = Modal::Preflight {
items,
action: PreflightAction::Install,
tab: PreflightTab::Summary,
summary: None,
summary_scroll: 0,
header_chips: crate::state::modal::PreflightHeaderChips::default(),
dependency_info: Vec::new(),
dep_selected: 0,
dep_tree_expanded: HashSet::new(),
deps_error: None,
file_info: Vec::new(),
file_selected: 0,
file_tree_expanded: HashSet::new(),
files_error: None,
service_info: Vec::new(),
service_selected: 0,
services_loaded: false,
services_error: None,
sandbox_info: Vec::new(),
sandbox_selected: 0,
sandbox_tree_expanded: std::collections::HashSet::new(),
sandbox_loaded: false,
sandbox_error: None,
selected_optdepends: std::collections::HashMap::new(),
cascade_mode: CascadeMode::Basic,
cached_reverse_deps_report: None,
};
// Switch to Deps tab
handle_preflight_key(
KeyEvent::new(KeyCode::Right, KeyModifiers::empty()),
&mut app,
);
if let Modal::Preflight {
tab,
dependency_info,
..
} = &app.modal
{
assert_eq!(*tab, PreflightTab::Deps);
assert_eq!(dependency_info.len(), 1);
assert_eq!(dependency_info[0].name, "libcached");
} else {
panic!("expected Preflight modal");
}
}
#[test]
/// What: Verify that cached files are correctly loaded when switching to Files tab.
///
/// Inputs:
/// - `AppState` with cached files in `install_list_files`.
/// - Preflight modal initially on Summary tab, then switching to Files tab.
///
/// Output:
/// - Cached files are loaded into `file_info` when switching to Files tab.
///
/// Details:
/// - Tests the tab switching logic that loads cached files from app state.
fn cached_files_load_on_tab_switch() {
let mut app = AppState::default();
let items = vec![pkg("target")];
let cached_files = vec![file_info("target", 3)];
app.install_list_files = cached_files;
app.modal = Modal::Preflight {
items,
action: PreflightAction::Install,
tab: PreflightTab::Summary,
summary: None,
summary_scroll: 0,
header_chips: crate::state::modal::PreflightHeaderChips::default(),
dependency_info: Vec::new(),
dep_selected: 0,
dep_tree_expanded: HashSet::new(),
deps_error: None,
file_info: Vec::new(),
file_selected: 0,
file_tree_expanded: HashSet::new(),
files_error: None,
service_info: Vec::new(),
service_selected: 0,
services_loaded: false,
services_error: None,
sandbox_info: Vec::new(),
sandbox_selected: 0,
sandbox_tree_expanded: std::collections::HashSet::new(),
sandbox_loaded: false,
sandbox_error: None,
selected_optdepends: std::collections::HashMap::new(),
cascade_mode: CascadeMode::Basic,
cached_reverse_deps_report: None,
};
// Switch to Files tab (Right twice: Summary -> Deps -> Files)
handle_preflight_key(
KeyEvent::new(KeyCode::Right, KeyModifiers::empty()),
&mut app,
);
handle_preflight_key(
KeyEvent::new(KeyCode::Right, KeyModifiers::empty()),
&mut app,
);
if let Modal::Preflight { tab, file_info, .. } = &app.modal {
assert_eq!(*tab, PreflightTab::Files);
assert_eq!(file_info.len(), 1);
assert_eq!(file_info[0].name, "target");
assert_eq!(file_info[0].files.len(), 3);
} else {
panic!("expected Preflight modal");
}
}
#[test]
/// What: Verify that dependencies with Installed status are counted correctly in display length.
///
/// Inputs:
/// - Dependency list containing both installed and to-install dependencies.
///
/// Output:
/// - Display length includes all dependencies regardless of status.
///
/// Details:
/// - Ensures installed dependencies are not excluded from the display count.
fn installed_dependencies_counted_in_display_length() {
let items = vec![pkg("app")];
let deps = vec![
dep_with_status(
"libinstalled",
&["app"],
DependencyStatus::Installed {
version: "1.0.0".into(),
},
),
dep("libnew", &["app"]),
];
let mut expanded = HashSet::new();
expanded.insert("app".to_string());
let len = compute_display_items_len(&items, &deps, &expanded);
// Should count: 1 header + 2 dependencies = 3
assert_eq!(len, 3);
}
#[test]
/// What: Verify that files are correctly displayed when `file_info` is populated.
///
/// Inputs:
/// - Preflight modal with `file_info` containing files for a package.
///
/// Output:
/// - File display length correctly counts files when package is expanded.
///
/// Details:
/// - Ensures files are not filtered out and are correctly counted for display.
fn files_displayed_when_file_info_populated() {
let items = vec![pkg("pkg1"), pkg("pkg2")];
let file_infos = vec![file_info("pkg1", 5), file_info("pkg2", 3)];
let mut expanded = HashSet::new();
expanded.insert("pkg1".to_string());
let len = compute_file_display_items_len(&items, &file_infos, &expanded);
// Should count: 2 headers + 5 files from pkg1 = 7
assert_eq!(len, 7);
// Expand both packages
expanded.insert("pkg2".to_string());
let len_expanded = compute_file_display_items_len(&items, &file_infos, &expanded);
// Should count: 2 headers + 5 files + 3 files = 10
assert_eq!(len_expanded, 10);
}
#[test]
/// What: Verify that empty `file_info` shows correct empty state.
///
/// Inputs:
/// - Preflight modal with empty `file_info` but packages in items.
///
/// Output:
/// - File display length returns 2 (all packages shown even if no file info).
///
/// Details:
/// - Ensures empty states are handled correctly without panicking.
fn empty_file_info_handled_correctly() {
let items = vec![pkg("pkg1"), pkg("pkg2")];
let file_infos = Vec::<PackageFileInfo>::new();
let expanded = HashSet::new();
let len = compute_file_display_items_len(&items, &file_infos, &expanded);
// Should count: 2 headers (all packages shown even if no file info)
assert_eq!(len, 2);
}
#[test]
/// What: Verify that dependencies are correctly filtered by `required_by` when loading from cache.
///
/// Inputs:
/// - `AppState` with cached dependencies, some matching current items and some not.
/// - Preflight modal switching to Deps tab.
///
/// Output:
/// - Only dependencies required by current items are loaded.
///
/// Details:
/// - Tests the filtering logic that ensures only relevant dependencies are shown.
fn dependencies_filtered_by_required_by_on_cache_load() {
let mut app = AppState::default();
let items = vec![pkg("target")];
// Create dependencies: one for "target", one for "other" package
let deps_for_target = dep("libtarget", &["target"]);
let deps_for_other = dep("libother", &["other"]);
app.install_list_deps = vec![deps_for_target, deps_for_other];
app.modal = Modal::Preflight {
items,
action: PreflightAction::Install,
tab: PreflightTab::Summary,
summary: None,
summary_scroll: 0,
header_chips: crate::state::modal::PreflightHeaderChips::default(),
dependency_info: Vec::new(),
dep_selected: 0,
dep_tree_expanded: HashSet::new(),
deps_error: None,
file_info: Vec::new(),
file_selected: 0,
file_tree_expanded: HashSet::new(),
files_error: None,
service_info: Vec::new(),
service_selected: 0,
services_loaded: false,
services_error: None,
sandbox_info: Vec::new(),
sandbox_selected: 0,
sandbox_tree_expanded: std::collections::HashSet::new(),
sandbox_loaded: false,
sandbox_error: None,
selected_optdepends: std::collections::HashMap::new(),
cascade_mode: CascadeMode::Basic,
cached_reverse_deps_report: None,
};
// Switch to Deps tab
handle_preflight_key(
KeyEvent::new(KeyCode::Right, KeyModifiers::empty()),
&mut app,
);
if let Modal::Preflight {
dependency_info, ..
} = &app.modal
{
// Should only load dependency for "target", not "other"
assert_eq!(dependency_info.len(), 1);
assert_eq!(dependency_info[0].name, "libtarget");
assert!(
dependency_info[0]
.required_by
.iter()
.any(|req| req == "target")
);
} else {
panic!("expected Preflight modal");
}
}
#[test]
/// What: Verify that files are correctly filtered by package name when loading from cache.
///
/// Inputs:
/// - `AppState` with cached files for multiple packages.
/// - Preflight modal with only some packages in items.
///
/// Output:
/// - Only files for packages in items are loaded.
///
/// Details:
/// - Tests the filtering logic that ensures only relevant files are shown.
fn files_filtered_by_package_name_on_cache_load() {
let mut app = AppState::default();
let items = vec![pkg("target")];
let files_for_target = file_info("target", 2);
let files_for_other = file_info("other", 3);
app.install_list_files = vec![files_for_target, files_for_other];
app.modal = Modal::Preflight {
items,
action: PreflightAction::Install,
tab: PreflightTab::Summary,
summary: None,
summary_scroll: 0,
header_chips: crate::state::modal::PreflightHeaderChips::default(),
dependency_info: Vec::new(),
dep_selected: 0,
dep_tree_expanded: HashSet::new(),
deps_error: None,
file_info: Vec::new(),
file_selected: 0,
file_tree_expanded: HashSet::new(),
files_error: None,
service_info: Vec::new(),
service_selected: 0,
services_loaded: false,
services_error: None,
sandbox_info: Vec::new(),
sandbox_selected: 0,
sandbox_tree_expanded: std::collections::HashSet::new(),
sandbox_loaded: false,
sandbox_error: None,
selected_optdepends: std::collections::HashMap::new(),
cascade_mode: CascadeMode::Basic,
cached_reverse_deps_report: None,
};
// Switch to Files tab
handle_preflight_key(
KeyEvent::new(KeyCode::Right, KeyModifiers::empty()),
&mut app,
);
handle_preflight_key(
KeyEvent::new(KeyCode::Right, KeyModifiers::empty()),
&mut app,
);
if let Modal::Preflight { file_info, .. } = &app.modal {
// Should only load files for "target", not "other"
assert_eq!(file_info.len(), 1);
assert_eq!(file_info[0].name, "target");
assert_eq!(file_info[0].files.len(), 2);
} else {
panic!("expected Preflight modal");
}
}
// Key Handler Safety Tests
// These tests prevent the TUI from closing unexpectedly when using preflight key handlers
#[test]
/// What: Verify that pressing 'f' for file sync doesn't close the TUI.
///
/// Inputs:
/// - Preflight modal open on Files tab
/// - 'f' key pressed
///
/// Output:
/// - Handler returns `false` (TUI stays open)
///
/// Details:
/// - Verifies the fix for issue where 'f' key closed the TUI
fn test_f_key_file_sync_doesnt_close_tui() {
let mut app = AppState {
modal: Modal::Preflight {
items: vec![pkg("test-package")],
action: PreflightAction::Install,
tab: PreflightTab::Files,
summary: None,
summary_scroll: 0,
header_chips: crate::state::modal::PreflightHeaderChips::default(),
dependency_info: Vec::new(),
dep_selected: 0,
dep_tree_expanded: HashSet::new(),
deps_error: None,
file_info: Vec::new(),
file_selected: 0,
file_tree_expanded: HashSet::new(),
files_error: None,
service_info: Vec::new(),
service_selected: 0,
services_loaded: false,
services_error: None,
sandbox_info: Vec::new(),
sandbox_selected: 0,
sandbox_tree_expanded: HashSet::new(),
sandbox_loaded: false,
sandbox_error: None,
selected_optdepends: std::collections::HashMap::new(),
cascade_mode: CascadeMode::Basic,
cached_reverse_deps_report: None,
},
..Default::default()
};
let key_event = KeyEvent::new(KeyCode::Char('f'), KeyModifiers::empty());
let should_exit = handle_preflight_key(key_event, &mut app);
assert!(
!should_exit,
"Pressing 'f' for file sync should not close the TUI"
);
}
#[test]
/// What: Verify that pressing 'p' to proceed with install doesn't close the TUI.
///
/// Inputs:
/// - Preflight modal open with Install action
/// - 'p' key pressed
///
/// Output:
/// - Handler returns `false` (TUI stays open)
///
/// Details:
/// - Verifies the fix for issue where 'p' key closed the TUI
fn test_p_key_proceed_install_doesnt_close_tui() {
let mut app = AppState {
modal: Modal::Preflight {
items: vec![pkg("test-package")],
action: PreflightAction::Install,
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | true |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/preflight/display.rs | src/events/preflight/display.rs | //! Display computation functions for Preflight modal tabs.
use std::collections::{HashMap, HashSet};
use crate::state::PackageItem;
/// What: Compute how many rows the dependency list will render in the Preflight Deps tab.
///
/// Inputs:
/// - `items`: Packages selected for install/remove shown in the modal
/// - `dependency_info`: Flattened dependency metadata resolved for those packages
/// - `dep_tree_expanded`: Set of package names currently expanded in the UI tree
///
/// Output:
/// - Total number of list rows (headers plus visible dependency entries).
///
/// Details:
/// - Mirrors the UI logic to keep keyboard navigation in sync with rendered rows.
/// - Counts one header per package that has dependencies; only counts individual dependencies when
/// that package appears in `dep_tree_expanded` and deduplicates by dependency name.
pub(super) fn compute_display_items_len(
items: &[PackageItem],
dependency_info: &[crate::state::modal::DependencyInfo],
dep_tree_expanded: &HashSet<String>,
) -> usize {
// Group dependencies by the packages that require them (same as UI code)
let mut grouped: HashMap<String, Vec<&crate::state::modal::DependencyInfo>> = HashMap::new();
for dep in dependency_info {
for req_by in &dep.required_by {
grouped.entry(req_by.clone()).or_default().push(dep);
}
}
// Count display items: 1 header per package + unique deps per package (only if expanded)
// IMPORTANT: Show ALL packages, even if they have no dependencies
// This matches the UI rendering logic
let mut count = 0;
for pkg_name in items.iter().map(|p| &p.name) {
// Always add header for each package (even if no dependencies)
count += 1;
// Count unique dependencies only if package is expanded AND has dependencies
if dep_tree_expanded.contains(pkg_name)
&& let Some(pkg_deps) = grouped.get(pkg_name)
{
let mut seen_deps = HashSet::new();
for dep in pkg_deps {
if seen_deps.insert(dep.name.as_str()) {
count += 1;
}
}
}
}
count
}
/// What: Compute how many rows the Sandbox tab list should expose given expansion state.
///
/// Inputs:
/// - `items`: Packages in the transaction
/// - `sandbox_info`: Resolved sandbox analysis for AUR packages
/// - `sandbox_tree_expanded`: Set of package names currently expanded in the Sandbox tab
///
/// Output:
/// - Total list length combining headers plus visible dependency entries.
///
/// Details:
/// - Adds one row per package header.
/// - Adds additional rows for each dependency when package is expanded (only for AUR packages).
pub(super) fn compute_sandbox_display_items_len(
items: &[PackageItem],
sandbox_info: &[crate::logic::sandbox::SandboxInfo],
sandbox_tree_expanded: &HashSet<String>,
) -> usize {
let mut count = 0;
for item in items {
count += 1; // Package header
// Add dependencies only if expanded and AUR
if matches!(item.source, crate::state::Source::Aur)
&& sandbox_tree_expanded.contains(&item.name)
&& let Some(info) = sandbox_info.iter().find(|s| s.package_name == item.name)
{
count += info.depends.len();
count += info.makedepends.len();
count += info.checkdepends.len();
count += info.optdepends.len();
}
}
count
}
/// What: Compute how many rows the Files tab list should expose given expansion state.
///
/// Inputs:
/// - `items`: All packages under review.
/// - `file_info`: Resolved file change metadata grouped per package
/// - `file_tree_expanded`: Set of package names currently expanded in the Files tab
///
/// Output:
/// - Total list length combining headers plus visible file entries.
///
/// Details:
/// - Always counts ALL packages from items, even if they have no files.
/// - Adds one row per package header and additional rows for each file when expanded.
pub fn compute_file_display_items_len(
items: &[PackageItem],
file_info: &[crate::state::modal::PackageFileInfo],
file_tree_expanded: &HashSet<String>,
) -> usize {
// Create a map for quick lookup of file info by package name
let file_info_map: HashMap<String, &crate::state::modal::PackageFileInfo> = file_info
.iter()
.map(|info| (info.name.clone(), info))
.collect();
let mut count = 0;
// Always count ALL packages from items, even if they have no file info
for item in items {
count += 1; // Package header
if file_tree_expanded.contains(&item.name) {
// Count file rows if available
if let Some(pkg_info) = file_info_map.get(&item.name) {
count += pkg_info.files.len();
}
}
}
count
}
/// What: Build the flattened `(is_header, label)` list shown by the Files tab renderer.
///
/// Inputs:
/// - `items`: All packages under review.
/// - `file_info`: Resolved file change metadata grouped by package
/// - `file_tree_expanded`: Set of package names that should expand to show individual files
///
/// Output:
/// - Vector of `(bool, String)` pairs distinguishing headers (`true`) from file rows (`false`).
///
/// Details:
/// - Always shows ALL packages from items, even if they have no files.
/// - This ensures packages that failed to resolve files (e.g., due to conflicts) are still visible.
/// - Uses empty strings for file rows because UI draws file details from separate collections.
pub fn build_file_display_items(
items: &[PackageItem],
file_info: &[crate::state::modal::PackageFileInfo],
file_tree_expanded: &HashSet<String>,
) -> Vec<(bool, String)> {
// Create a map for quick lookup of file info by package name
let file_info_map: HashMap<String, &crate::state::modal::PackageFileInfo> = file_info
.iter()
.map(|info| (info.name.clone(), info))
.collect();
let mut display_items: Vec<(bool, String)> = Vec::new();
// Always show ALL packages from items, even if they have no file info
for item in items {
let pkg_name = &item.name;
display_items.push((true, pkg_name.clone()));
if file_tree_expanded.contains(pkg_name) {
// Show file rows if available
if let Some(pkg_info) = file_info_map.get(pkg_name) {
display_items.extend(pkg_info.files.iter().map(|_| (false, String::new())));
}
}
}
display_items
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/preflight/mod.rs | src/events/preflight/mod.rs | //! Preflight modal event handling.
pub mod display;
pub mod keys;
mod modal;
#[cfg(test)]
mod tests;
pub use display::{build_file_display_items, compute_file_display_items_len};
pub use keys::handle_preflight_key;
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/preflight/modal.rs | src/events/preflight/modal.rs | //! Modal management functions for Preflight modal.
use crate::state::{AppState, PackageItem};
/// Parameters for handling deps tab switch.
struct DepsTabParams<'a> {
/// Dependency information list.
dependency_info: &'a mut Vec<crate::state::modal::DependencyInfo>,
/// Currently selected dependency index.
dep_selected: &'a mut usize,
/// Dependency info from install list.
install_list_deps: &'a [crate::state::modal::DependencyInfo],
/// Whether dependency resolution is in progress.
preflight_deps_resolving: bool,
/// Pending dependency resolution request (packages, action).
preflight_deps_items: &'a mut Option<(Vec<PackageItem>, crate::state::modal::PreflightAction)>,
/// Flag indicating if preflight summary was cleared for remove action.
remove_preflight_summary_cleared: &'a mut bool,
/// Cached reverse dependency report.
cached_reverse_deps_report: &'a mut Option<crate::logic::deps::ReverseDependencyReport>,
}
/// Parameters for handling services tab switch.
struct ServicesTabParams<'a> {
/// Service impact information list.
service_info: &'a mut Vec<crate::state::modal::ServiceImpact>,
/// Currently selected service index.
service_selected: &'a mut usize,
/// Whether service information has been loaded.
services_loaded: &'a mut bool,
/// Service info from install list.
install_list_services: &'a [crate::state::modal::ServiceImpact],
/// Path to services cache file.
services_cache_path: &'a std::path::PathBuf,
/// Whether service resolution is in progress.
services_resolving: bool,
/// Pending service analysis request (packages).
preflight_services_items: &'a mut Option<Vec<PackageItem>>,
/// Whether preflight service resolution is in progress.
preflight_services_resolving: &'a mut bool,
}
/// Parameters for handling sandbox tab switch.
struct SandboxTabParams<'a> {
/// Sandbox analysis information list.
sandbox_info: &'a mut Vec<crate::logic::sandbox::SandboxInfo>,
/// Currently selected sandbox item index.
sandbox_selected: &'a mut usize,
/// Whether sandbox information has been loaded.
sandbox_loaded: &'a mut bool,
/// Sandbox info from install list.
install_list_sandbox: &'a [crate::logic::sandbox::SandboxInfo],
/// Pending sandbox analysis request (packages).
preflight_sandbox_items: &'a mut Option<Vec<PackageItem>>,
/// Whether preflight sandbox resolution is in progress.
preflight_sandbox_resolving: &'a mut bool,
}
/// What: Close the Preflight modal and clean up all related state.
///
/// Inputs:
/// - `app`: Mutable application state containing the Preflight modal
/// - `service_info`: Service info to save before closing
///
/// Output:
/// - None (mutates app state directly).
///
/// Details:
/// - Cancels in-flight operations, clears queues, and saves service restart decisions.
pub(super) fn close_preflight_modal(
app: &mut AppState,
service_info: &[crate::state::modal::ServiceImpact],
) {
if service_info.is_empty() {
// No services to plan
} else {
app.pending_service_plan = service_info.to_vec();
}
app.previous_modal = None;
app.remove_preflight_summary.clear();
app.preflight_cancelled
.store(true, std::sync::atomic::Ordering::Relaxed);
app.preflight_summary_items = None;
app.preflight_deps_items = None;
app.preflight_files_items = None;
app.preflight_services_items = None;
app.preflight_sandbox_items = None;
app.modal = crate::state::Modal::None;
}
/// What: Handle switching to Deps tab and load cached dependencies.
///
/// Inputs:
/// - `items`: Packages in the transaction
/// - `action`: Install or remove action
/// - `params`: Parameters struct containing mutable state and cache references
///
/// Output:
/// - Returns true if background resolution was triggered, false otherwise.
///
/// Details:
/// - Loads cached dependencies if available, otherwise triggers background resolution.
fn handle_deps_tab_switch(
items: &[PackageItem],
action: crate::state::PreflightAction,
params: &mut DepsTabParams<'_>,
) -> bool {
tracing::debug!(
"[Preflight] switch_preflight_tab: Deps tab - dependency_info.len()={}, cache.len()={}, resolving={}",
params.dependency_info.len(),
params.install_list_deps.len(),
params.preflight_deps_resolving
);
tracing::info!(
"[Preflight] handle_deps_tab_switch: dependency_info.len()={}, action={:?}, items={}",
params.dependency_info.len(),
action,
items.len()
);
if params.dependency_info.is_empty() {
tracing::info!(
"[Preflight] handle_deps_tab_switch: dependency_info is empty, will trigger resolution"
);
match action {
crate::state::PreflightAction::Install => {
let item_names: std::collections::HashSet<String> =
items.iter().map(|i| i.name.clone()).collect();
let cached_deps: Vec<crate::state::modal::DependencyInfo> = params
.install_list_deps
.iter()
.filter(|dep| {
dep.required_by
.iter()
.any(|req_by| item_names.contains(req_by))
})
.cloned()
.collect();
tracing::info!(
"[Preflight] switch_preflight_tab: Deps - Found {} cached deps (filtered from {} total), items={:?}",
cached_deps.len(),
params.install_list_deps.len(),
item_names
);
if cached_deps.is_empty() {
tracing::debug!(
"[Preflight] Triggering background dependency resolution for {} packages",
items.len()
);
*params.preflight_deps_items =
Some((items.to_vec(), crate::state::PreflightAction::Install));
*params.remove_preflight_summary_cleared = true;
return true;
}
*params.dependency_info = cached_deps;
*params.dep_selected = 0;
tracing::info!(
"[Preflight] switch_preflight_tab: Deps - Loaded {} deps into modal, dep_selected=0",
params.dependency_info.len()
);
*params.remove_preflight_summary_cleared = true;
}
crate::state::PreflightAction::Remove => {
// Check if we have a cached reverse dependency report from summary computation
if let Some(report) = params.cached_reverse_deps_report.as_ref() {
tracing::info!(
"[Preflight] Using cached reverse dependency report ({} deps) from summary computation",
report.dependencies.len()
);
params.dependency_info.clone_from(&report.dependencies);
*params.dep_selected = 0;
// Clear the cache after using it to free memory
*params.cached_reverse_deps_report = None;
*params.remove_preflight_summary_cleared = true;
return false;
}
// No cached report available, trigger background resolution
tracing::debug!(
"[Preflight] No cached report available, triggering background reverse dependency resolution for {} packages",
items.len()
);
*params.preflight_deps_items =
Some((items.to_vec(), crate::state::PreflightAction::Remove));
*params.remove_preflight_summary_cleared = true;
return true;
}
crate::state::PreflightAction::Downgrade => {
// For downgrade, we don't need to resolve dependencies
// Downgrade tool handles its own logic
tracing::debug!("[Preflight] Downgrade action: skipping dependency resolution");
*params.dependency_info = Vec::new();
*params.dep_selected = 0;
*params.remove_preflight_summary_cleared = true;
}
}
} else {
tracing::debug!(
"[Preflight] switch_preflight_tab: Deps tab - dependency_info not empty ({} entries), skipping cache load",
params.dependency_info.len()
);
}
false
}
/// What: Handle switching to Files tab and load cached file information.
///
/// Inputs:
/// - `items`: Packages in the transaction
/// - `action`: Install or remove action
/// - `file_info`: Mutable reference to file info vector
/// - `file_selected`: Mutable reference to selected index
/// - `install_list_files`: Reference to cached files
/// - `preflight_files_items`: Mutable reference to items for resolution
/// - `preflight_files_resolving`: Mutable reference to resolving flag
///
/// Output:
/// - None (mutates state directly).
///
/// Details:
/// - Loads cached file information if available for Install actions, otherwise triggers background resolution.
/// - For Remove actions, always triggers fresh resolution since cached files contain Install-specific data (New/Changed) that is incorrect for Remove (should be Removed).
fn handle_files_tab_switch(
items: &[PackageItem],
action: crate::state::PreflightAction,
file_info: &mut Vec<crate::state::modal::PackageFileInfo>,
file_selected: &mut usize,
install_list_files: &[crate::state::modal::PackageFileInfo],
preflight_files_items: &mut Option<Vec<PackageItem>>,
preflight_files_resolving: &mut bool,
) {
tracing::debug!(
"[Preflight] switch_preflight_tab: Files tab - file_info.len()={}, cache.len()={}, resolving={}, action={:?}",
file_info.len(),
install_list_files.len(),
*preflight_files_resolving,
action
);
if file_info.is_empty() {
match action {
crate::state::PreflightAction::Install => {
let item_names: std::collections::HashSet<String> =
items.iter().map(|i| i.name.clone()).collect();
let cached_files: Vec<crate::state::modal::PackageFileInfo> = install_list_files
.iter()
.filter(|file_info| item_names.contains(&file_info.name))
.cloned()
.collect();
tracing::info!(
"[Preflight] switch_preflight_tab: Files - Found {} cached files (filtered from {} total), items={:?}",
cached_files.len(),
install_list_files.len(),
item_names
);
if cached_files.is_empty() {
tracing::debug!(
"[Preflight] Triggering background file resolution for {} packages",
items.len()
);
*preflight_files_items = Some(items.to_vec());
*preflight_files_resolving = true;
} else {
*file_info = cached_files;
*file_selected = 0;
tracing::info!(
"[Preflight] switch_preflight_tab: Files - Loaded {} files into modal, file_selected=0",
file_info.len()
);
}
}
crate::state::PreflightAction::Remove => {
// For Remove actions, always trigger fresh resolution since cached files
// contain Install-specific data (New/Changed) that is incorrect for Remove (should be Removed)
tracing::debug!(
"[Preflight] Triggering background file resolution for {} packages (action=Remove) - cache not used due to action mismatch",
items.len()
);
*preflight_files_items = Some(items.to_vec());
*preflight_files_resolving = true;
}
crate::state::PreflightAction::Downgrade => {
// For Downgrade actions, always trigger fresh resolution
tracing::debug!(
"[Preflight] Triggering background file resolution for {} packages (action=Downgrade)",
items.len()
);
*preflight_files_items = Some(items.to_vec());
*preflight_files_resolving = true;
}
}
} else {
tracing::debug!(
"[Preflight] switch_preflight_tab: Files tab - file_info not empty ({} entries), skipping cache load",
file_info.len()
);
}
}
/// What: Handle switching to Services tab and load cached service information.
///
/// Inputs:
/// - `items`: Packages in the transaction
/// - `action`: Install or remove action
/// - `params`: Parameters struct containing mutable state and cache references
///
/// Output:
/// - None (mutates state directly).
///
/// Details:
/// - For Install actions: Loads cached service information if available (from `install_list_services`).
/// - For Remove actions: Always triggers fresh resolution since cached services contain Install-specific
/// `needs_restart` values that differ from Remove actions.
fn handle_services_tab_switch(
items: &[PackageItem],
action: crate::state::PreflightAction,
params: &mut ServicesTabParams<'_>,
) {
if params.service_info.is_empty() && !params.services_resolving {
match action {
crate::state::PreflightAction::Install => {
// For Install actions, check cache and use if available
let cache_exists = if items.is_empty() {
false
} else {
let signature = crate::app::services_cache::compute_signature(items);
crate::app::services_cache::load_cache(params.services_cache_path, &signature)
.is_some()
};
if cache_exists {
if !params.install_list_services.is_empty() {
*params.service_info = params.install_list_services.to_vec();
*params.service_selected = 0;
}
// Cache exists (empty or not) - mark as loaded
tracing::debug!(
"[Preflight] Services cache exists for Install action, marking as loaded ({} services)",
params.service_info.len()
);
*params.services_loaded = true;
} else {
// No cache exists - trigger background resolution
tracing::debug!(
"[Preflight] Triggering background service resolution for {} packages (action=Install)",
items.len()
);
*params.preflight_services_items = Some(items.to_vec());
*params.preflight_services_resolving = true;
}
}
crate::state::PreflightAction::Remove => {
// For Remove actions, always trigger fresh resolution since cached services
// contain Install-specific needs_restart values that are incorrect for Remove
tracing::debug!(
"[Preflight] Triggering background service resolution for {} packages (action=Remove) - cache not used due to action mismatch",
items.len()
);
*params.preflight_services_items = Some(items.to_vec());
*params.preflight_services_resolving = true;
}
crate::state::PreflightAction::Downgrade => {
// For Downgrade actions, always trigger fresh resolution
tracing::debug!(
"[Preflight] Triggering background service resolution for {} packages (action=Downgrade)",
items.len()
);
*params.preflight_services_items = Some(items.to_vec());
*params.preflight_services_resolving = true;
}
}
}
}
/// What: Handle switching to Sandbox tab and load cached sandbox information.
///
/// Inputs:
/// - `items`: Packages in the transaction
/// - `action`: Install or remove action
/// - `params`: Parameters struct containing mutable state and cache references
///
/// Output:
/// - None (mutates state directly).
///
/// Details:
/// - Loads cached sandbox information if available, otherwise triggers background resolution.
fn handle_sandbox_tab_switch(
items: &[PackageItem],
action: crate::state::PreflightAction,
params: &mut SandboxTabParams<'_>,
) {
if params.sandbox_info.is_empty() && !*params.sandbox_loaded {
match action {
crate::state::PreflightAction::Install => {
let item_names: std::collections::HashSet<String> =
items.iter().map(|i| i.name.clone()).collect();
let cached_sandbox: Vec<crate::logic::sandbox::SandboxInfo> = params
.install_list_sandbox
.iter()
.filter(|s| item_names.contains(&s.package_name))
.cloned()
.collect();
if cached_sandbox.is_empty() {
let aur_items: Vec<_> = items
.iter()
.filter(|p| matches!(p.source, crate::state::Source::Aur))
.cloned()
.collect();
if aur_items.is_empty() {
*params.sandbox_loaded = true;
} else {
tracing::debug!(
"[Preflight] Triggering background sandbox resolution for {} AUR packages",
aur_items.len()
);
*params.preflight_sandbox_items = Some(aur_items);
*params.preflight_sandbox_resolving = true;
}
} else {
*params.sandbox_info = cached_sandbox;
*params.sandbox_selected = 0;
*params.sandbox_loaded = true;
}
}
crate::state::PreflightAction::Remove | crate::state::PreflightAction::Downgrade => {
*params.sandbox_loaded = true;
}
}
}
}
/// What: Switch to a new Preflight tab and load cached data if available.
///
/// Inputs:
/// - `new_tab`: Target tab to switch to
/// - `app`: Mutable application state
/// - `items`: Packages in the transaction
/// - `action`: Install or remove action
///
/// Output:
/// - None (mutates app.modal directly).
///
/// Details:
/// - Handles cache loading and background resolution for each tab type.
pub(super) fn switch_preflight_tab(
new_tab: crate::state::PreflightTab,
app: &mut AppState,
items: &[PackageItem],
action: crate::state::PreflightAction,
) {
tracing::info!(
"[Preflight] switch_preflight_tab: Switching to {:?}, items={}, action={:?}",
new_tab,
items.len(),
action
);
// Extract needed app fields before borrowing modal
let install_list_deps: &[crate::state::modal::DependencyInfo] = &app.install_list_deps;
let install_list_files: &[crate::state::modal::PackageFileInfo] = &app.install_list_files;
let install_list_services: &[crate::state::modal::ServiceImpact] = &app.install_list_services;
let install_list_sandbox: &[crate::logic::sandbox::SandboxInfo] = &app.install_list_sandbox;
let services_cache_path = app.services_cache_path.clone();
let services_resolving = app.services_resolving;
let preflight_deps_resolving_value = app.preflight_deps_resolving;
// Prepare mutable state that will be updated
let mut preflight_deps_items: Option<(Vec<PackageItem>, crate::state::PreflightAction)> = None;
let mut preflight_files_items = None;
let mut preflight_services_items = None;
let mut preflight_sandbox_items = None;
let mut preflight_files_resolving = false;
let mut preflight_services_resolving = false;
let mut preflight_sandbox_resolving = false;
let mut remove_preflight_summary_cleared = false;
if let crate::state::Modal::Preflight {
tab,
dependency_info,
dep_selected,
file_info,
file_selected,
service_info,
service_selected,
services_loaded,
sandbox_info,
sandbox_selected,
sandbox_loaded,
cached_reverse_deps_report,
..
} = &mut app.modal
{
let old_tab = *tab;
*tab = new_tab;
tracing::debug!(
"[Preflight] switch_preflight_tab: Tab field updated from {:?} to {:?}",
old_tab,
new_tab
);
match new_tab {
crate::state::PreflightTab::Deps => {
let mut deps_params = DepsTabParams {
dependency_info,
dep_selected,
install_list_deps,
preflight_deps_resolving: preflight_deps_resolving_value,
preflight_deps_items: &mut preflight_deps_items,
remove_preflight_summary_cleared: &mut remove_preflight_summary_cleared,
cached_reverse_deps_report,
};
// handle_deps_tab_switch sets preflight_deps_items with the correct action
let _should_trigger = handle_deps_tab_switch(items, action, &mut deps_params);
}
crate::state::PreflightTab::Files => {
handle_files_tab_switch(
items,
action,
file_info,
file_selected,
install_list_files,
&mut preflight_files_items,
&mut preflight_files_resolving,
);
}
crate::state::PreflightTab::Services => {
let mut services_params = ServicesTabParams {
service_info,
service_selected,
services_loaded,
install_list_services,
services_cache_path: &services_cache_path,
services_resolving,
preflight_services_items: &mut preflight_services_items,
preflight_services_resolving: &mut preflight_services_resolving,
};
handle_services_tab_switch(items, action, &mut services_params);
}
crate::state::PreflightTab::Sandbox => {
let mut sandbox_params = SandboxTabParams {
sandbox_info,
sandbox_selected,
sandbox_loaded,
install_list_sandbox,
preflight_sandbox_items: &mut preflight_sandbox_items,
preflight_sandbox_resolving: &mut preflight_sandbox_resolving,
};
handle_sandbox_tab_switch(items, action, &mut sandbox_params);
}
crate::state::PreflightTab::Summary => {}
}
}
// Apply mutations after modal borrow is released
if let Some((items, action)) = preflight_deps_items {
tracing::info!(
"[Preflight] switch_preflight_tab: Setting preflight_deps_items with {} items, action={:?}, setting preflight_deps_resolving=true",
items.len(),
action
);
app.preflight_deps_items = Some((items, action));
app.preflight_deps_resolving = true;
}
if remove_preflight_summary_cleared {
app.remove_preflight_summary.clear();
}
if let Some(items) = preflight_files_items {
app.preflight_files_items = Some(items);
app.preflight_files_resolving = preflight_files_resolving;
}
if let Some(items) = preflight_services_items {
app.preflight_services_items = Some(items);
app.preflight_services_resolving = preflight_services_resolving;
}
if let Some(items) = preflight_sandbox_items {
app.preflight_sandbox_items = Some(items);
app.preflight_sandbox_resolving = preflight_sandbox_resolving;
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::state::modal::{
PreflightAction, PreflightTab, ServiceImpact, ServiceRestartDecision,
};
/// What: Test that Install actions can use cached services.
///
/// Inputs:
/// - `action`: `PreflightAction::Install`
/// - Cached services in `install_list_services`
/// - Cache file exists with matching signature
///
/// Output:
/// - `service_info` is populated from cache
/// - `services_loaded` is set to true
///
/// Details:
/// - Verifies that Install actions correctly load cached services.
#[test]
fn test_handle_services_tab_switch_install_uses_cache() {
let mut app = AppState::default();
let items = vec![PackageItem {
name: "test-pkg".to_string(),
version: "1.0".to_string(),
description: String::new(),
source: crate::state::Source::Aur,
popularity: None,
out_of_date: None,
orphaned: false,
}];
// Set up cached services
app.install_list_services = vec![ServiceImpact {
unit_name: "test.service".to_string(),
providers: vec!["test-pkg".to_string()],
is_active: true,
needs_restart: true,
recommended_decision: ServiceRestartDecision::Restart,
restart_decision: ServiceRestartDecision::Restart,
}];
// Create a temporary cache file
let temp_dir = std::env::temp_dir();
let cache_path = temp_dir.join("test_services_cache.json");
let signature = crate::app::services_cache::compute_signature(&items);
crate::app::services_cache::save_cache(&cache_path, &signature, &app.install_list_services);
app.services_cache_path = cache_path.clone();
// Open preflight modal with Install action
app.modal = crate::state::Modal::Preflight {
items: items.clone(),
action: PreflightAction::Install,
tab: PreflightTab::Summary,
summary: None,
summary_scroll: 0,
header_chips: crate::state::modal::PreflightHeaderChips::default(),
dependency_info: Vec::new(),
dep_selected: 0,
dep_tree_expanded: std::collections::HashSet::new(),
deps_error: None,
file_info: Vec::new(),
file_selected: 0,
file_tree_expanded: std::collections::HashSet::new(),
files_error: None,
service_info: Vec::new(),
service_selected: 0,
services_loaded: false,
services_error: None,
sandbox_info: Vec::new(),
sandbox_selected: 0,
sandbox_tree_expanded: std::collections::HashSet::new(),
sandbox_loaded: false,
sandbox_error: None,
selected_optdepends: std::collections::HashMap::new(),
cascade_mode: crate::state::modal::CascadeMode::Basic,
cached_reverse_deps_report: None,
};
// Switch to Services tab
switch_preflight_tab(
PreflightTab::Services,
&mut app,
&items,
PreflightAction::Install,
);
// Verify services were loaded from cache
if let crate::state::Modal::Preflight {
service_info,
services_loaded,
..
} = &app.modal
{
assert!(*services_loaded, "Services should be marked as loaded");
assert!(
!service_info.is_empty(),
"Services should be loaded from cache"
);
assert_eq!(service_info.len(), 1);
assert_eq!(service_info[0].unit_name, "test.service");
assert!(
service_info[0].needs_restart,
"Install action should have needs_restart=true"
);
} else {
panic!("Expected Preflight modal");
}
// Clean up
let _ = std::fs::remove_file(&cache_path);
}
/// What: Test that Remove actions always trigger resolution (don't use Install cache).
///
/// Inputs:
/// - `action`: `PreflightAction::Remove`
/// - Cached services in `install_list_services` (from Install action)
/// - Cache file exists with matching signature
///
/// Output:
/// - `preflight_services_items` is set (triggering resolution)
/// - `preflight_services_resolving` is set to true
/// - `service_info` remains empty (not loaded from Install cache)
///
/// Details:
/// - Verifies that Remove actions don't reuse Install-cached services,
/// ensuring correct `needs_restart` values.
#[test]
fn test_handle_services_tab_switch_remove_ignores_install_cache() {
let mut app = AppState::default();
let items = vec![PackageItem {
name: "test-pkg".to_string(),
version: "1.0".to_string(),
description: String::new(),
source: crate::state::Source::Aur,
popularity: None,
out_of_date: None,
orphaned: false,
}];
// Set up cached services from Install action (with needs_restart=true)
app.install_list_services = vec![ServiceImpact {
unit_name: "test.service".to_string(),
providers: vec!["test-pkg".to_string()],
is_active: true,
needs_restart: true, // This is incorrect for Remove actions
recommended_decision: ServiceRestartDecision::Restart,
restart_decision: ServiceRestartDecision::Restart,
}];
// Create a temporary cache file (from Install action)
let temp_dir = std::env::temp_dir();
let cache_path = temp_dir.join("test_services_cache_remove.json");
let signature = crate::app::services_cache::compute_signature(&items);
crate::app::services_cache::save_cache(&cache_path, &signature, &app.install_list_services);
app.services_cache_path = cache_path.clone();
// Open preflight modal with Remove action
app.modal = crate::state::Modal::Preflight {
items: items.clone(),
action: PreflightAction::Remove,
tab: PreflightTab::Summary,
summary: None,
summary_scroll: 0,
header_chips: crate::state::modal::PreflightHeaderChips::default(),
dependency_info: Vec::new(),
dep_selected: 0,
dep_tree_expanded: std::collections::HashSet::new(),
deps_error: None,
file_info: Vec::new(),
file_selected: 0,
file_tree_expanded: std::collections::HashSet::new(),
files_error: None,
service_info: Vec::new(),
service_selected: 0,
services_loaded: false,
services_error: None,
sandbox_info: Vec::new(),
sandbox_selected: 0,
sandbox_tree_expanded: std::collections::HashSet::new(),
sandbox_loaded: false,
sandbox_error: None,
selected_optdepends: std::collections::HashMap::new(),
cascade_mode: crate::state::modal::CascadeMode::Basic,
cached_reverse_deps_report: None,
};
// Switch to Services tab
switch_preflight_tab(
PreflightTab::Services,
&mut app,
&items,
PreflightAction::Remove,
);
// Verify that resolution was triggered instead of using cache
assert!(
app.preflight_services_items.is_some(),
"Remove action should trigger resolution, not use Install cache"
);
assert!(
app.preflight_services_resolving,
"Services should be marked as resolving for Remove action"
);
// Verify service_info was NOT loaded from Install cache
if let crate::state::Modal::Preflight {
service_info,
services_loaded,
..
} = &app.modal
{
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | true |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/preflight/keys/command_keys.rs | src/events/preflight/keys/command_keys.rs | //! Command key handlers for Preflight modal.
use std::sync::{Arc, Mutex};
use crate::state::{AppState, PackageItem};
use crate::events::preflight::modal::close_preflight_modal;
/// What: Handle F key - sync file database.
///
/// Inputs:
/// - `app`: Mutable application state
///
/// Output:
/// - Always returns `false` to continue event processing.
///
/// Details:
/// - Runs the sync operation in a background thread to avoid blocking the UI.
/// - If sync requires root privileges, shows password prompt and uses integrated executor.
pub(super) fn handle_f_key(app: &mut AppState) -> bool {
if let crate::state::Modal::Preflight { tab, .. } = &app.modal {
if *tab != crate::state::PreflightTab::Files {
return false;
}
} else {
return false;
}
// Show initial message that sync is starting
app.toast_message = Some("File database sync starting...".to_string());
app.toast_expires_at = Some(std::time::Instant::now() + std::time::Duration::from_secs(5));
// Run sync in background thread to avoid blocking the UI
// Use catch_unwind to prevent panics from crashing the TUI
// Store result in Arc<Mutex<Option<...>>> so we can check it in tick handler
let sync_result: crate::state::app_state::FileSyncResult = Arc::new(Mutex::new(None));
let sync_result_clone = Arc::clone(&sync_result);
std::thread::spawn(move || {
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
// Use the new ensure_file_db_synced function with force=true
// This will attempt to sync regardless of timestamp
let sync_result_inner = crate::logic::files::ensure_file_db_synced(true, 7);
match sync_result_inner {
Ok(synced) => {
if synced {
tracing::info!("File database sync completed successfully");
} else {
tracing::info!("File database is already fresh");
}
if let Ok(mut guard) = sync_result_clone.lock() {
*guard = Some(Ok(synced));
}
}
Err(e) => {
// Sync failed (likely requires root), show password prompt
tracing::warn!("File database sync failed: {}, will prompt for password", e);
if let Ok(mut guard) = sync_result_clone.lock() {
*guard = Some(Err(e));
}
}
}
}));
if let Err(panic_info) = result {
tracing::error!("File database sync thread panicked: {:?}", panic_info);
}
});
// Store the sync result Arc in AppState so we can check it in tick handler
app.pending_file_sync_result = Some(sync_result);
// Clear file_info to trigger re-resolution after sync completes
if let crate::state::Modal::Preflight {
file_info,
file_selected,
..
} = &mut app.modal
{
*file_info = Vec::new();
*file_selected = 0;
}
false
}
/// What: Handle S key - open scan configuration modal.
///
/// Inputs:
/// - `app`: Mutable application state
///
/// Output:
/// - Always returns `false`.
pub(super) fn handle_s_key(app: &mut AppState) -> bool {
// Build AUR package name list to scan
let names = if let crate::state::Modal::Preflight { items, .. } = &app.modal {
items
.iter()
.filter(|p| matches!(p.source, crate::state::Source::Aur))
.map(|p| p.name.clone())
.collect::<Vec<_>>()
} else {
return false;
};
if names.is_empty() {
app.modal = crate::state::Modal::Alert {
message: "No AUR packages selected to scan.\nAdd AUR packages to scan, then press 's'."
.into(),
};
} else {
app.pending_install_names = Some(names);
// Open Scan Configuration modal initialized from settings.conf
let prefs = crate::theme::settings();
// Store current Preflight modal state before opening ScanConfig
app.previous_modal = Some(app.modal.clone());
app.modal = crate::state::Modal::ScanConfig {
do_clamav: prefs.scan_do_clamav,
do_trivy: prefs.scan_do_trivy,
do_semgrep: prefs.scan_do_semgrep,
do_shellcheck: prefs.scan_do_shellcheck,
do_virustotal: prefs.scan_do_virustotal,
do_custom: prefs.scan_do_custom,
do_sleuth: prefs.scan_do_sleuth,
cursor: 0,
};
}
false
}
/// What: Handle d key - toggle dry-run mode.
///
/// Inputs:
/// - `app`: Mutable application state
///
/// Output:
/// - Always returns `false`.
pub(super) fn handle_dry_run_key(app: &mut AppState) -> bool {
app.dry_run = !app.dry_run;
let toast_key = if app.dry_run {
"app.toasts.dry_run_enabled"
} else {
"app.toasts.dry_run_disabled"
};
app.toast_message = Some(crate::i18n::t(app, toast_key));
false
}
/// What: Handle m key - cycle cascade mode.
///
/// Inputs:
/// - `app`: Mutable application state
///
/// Output:
/// - Always returns `false`.
pub(super) fn handle_m_key(app: &mut AppState) -> bool {
let next_mode_opt = if let crate::state::Modal::Preflight {
action: crate::state::PreflightAction::Remove,
cascade_mode,
..
} = &mut app.modal
{
let next_mode = cascade_mode.next();
*cascade_mode = next_mode;
Some(next_mode)
} else {
None
};
if let Some(next_mode) = next_mode_opt {
app.remove_cascade_mode = next_mode;
app.toast_message = Some(format!(
"Cascade mode set to {} ({})",
next_mode.flag(),
next_mode.description()
));
app.toast_expires_at = Some(std::time::Instant::now() + std::time::Duration::from_secs(4));
}
false
}
/// What: Extract install targets from preflight modal.
///
/// Inputs:
/// - `items`: Items from preflight modal
/// - `selected_optdepends`: Selected optional dependencies
///
/// Output: Packages to install including optional dependencies.
///
/// Details: Adds selected optional dependencies to the install list.
fn extract_install_targets(
items: &[PackageItem],
selected_optdepends: &std::collections::HashMap<String, std::collections::HashSet<String>>,
) -> Vec<PackageItem> {
let mut packages = items.to_vec();
// Add selected optional dependencies as additional packages to install
for optdeps in selected_optdepends.values() {
for optdep in optdeps {
let optdep_pkg_name = crate::logic::sandbox::extract_package_name(optdep);
if !packages.iter().any(|p| p.name == optdep_pkg_name) {
packages.push(PackageItem {
name: optdep_pkg_name,
version: String::new(),
description: String::new(),
source: crate::state::Source::Official {
repo: String::new(),
arch: String::new(),
},
popularity: None,
out_of_date: None,
orphaned: false,
});
}
}
}
packages
}
/// What: Handle proceed action for install targets.
///
/// Inputs:
/// - `app`: Mutable application state
/// - `packages`: Packages to install
/// - `header_chips`: Header chip metrics
///
/// Output: `false` to keep TUI open.
///
/// Details: Checks for reinstalls first, then batch updates (only if update available), handles password prompt if needed, or starts execution.
pub(super) fn handle_proceed_install(
app: &mut AppState,
packages: Vec<PackageItem>,
header_chips: crate::state::modal::PreflightHeaderChips,
) -> bool {
// First, check if we're installing packages that are already installed (reinstall scenario)
// This check happens BEFORE password prompt
// BUT exclude packages that have updates available (those should go through normal update flow)
let installed_set = crate::logic::deps::get_installed_packages();
let provided_set = crate::logic::deps::get_provided_packages(&installed_set);
let upgradable_set = crate::logic::deps::get_upgradable_packages();
let installed_packages: Vec<crate::state::PackageItem> = packages
.iter()
.filter(|item| {
// Check if package is installed or provided by an installed package
let is_installed = crate::logic::deps::is_package_installed_or_provided(
&item.name,
&installed_set,
&provided_set,
);
if !is_installed {
return false;
}
// Check if package has an update available
// For official packages: check if it's in upgradable_set OR version differs from installed
// For AUR packages: check if target version is different from installed version
let has_update = if upgradable_set.contains(&item.name) {
// Package is in upgradable set (pacman -Qu)
true
} else if !item.version.is_empty() {
// Normalize target version by removing revision suffix (same as installed version normalization)
let normalized_target_version =
item.version.split('-').next().unwrap_or(&item.version);
// Compare normalized target version with normalized installed version
// This works for both official and AUR packages
crate::logic::deps::get_installed_version(&item.name)
.is_ok_and(|installed_version| normalized_target_version != installed_version)
} else {
// No version info available, no update
false
};
// Only show reinstall confirmation if installed AND no update available
// If update is available, it should go through normal update flow
!has_update
})
.cloned()
.collect();
if !installed_packages.is_empty() {
// Show reinstall confirmation modal (before password prompt)
// Store both installed packages (for display) and all packages (for installation)
app.modal = crate::state::Modal::ConfirmReinstall {
items: installed_packages,
all_items: packages,
header_chips,
};
return false; // Don't close modal yet, wait for confirmation
}
// Check if this is a batch update scenario requiring confirmation
// Only show if there's actually an update available (package is upgradable)
// AND the package has installed packages in its "Required By" field (dependency risk)
let upgradable_set = crate::logic::deps::get_upgradable_packages();
let has_versions = packages.iter().any(|item| {
matches!(item.source, crate::state::Source::Official { .. }) && !item.version.is_empty()
});
let has_upgrade_available = packages.iter().any(|item| {
matches!(item.source, crate::state::Source::Official { .. })
&& upgradable_set.contains(&item.name)
});
// Only show warning if package has installed packages in "Required By" (dependency risk)
let has_installed_required_by = packages.iter().any(|item| {
matches!(item.source, crate::state::Source::Official { .. })
&& crate::index::is_installed(&item.name)
&& crate::logic::deps::has_installed_required_by(&item.name)
});
if has_versions && has_upgrade_available && has_installed_required_by {
// Show confirmation modal for batch updates (only if update is actually available
// AND package has installed dependents that could be affected)
app.modal = crate::state::Modal::ConfirmBatchUpdate {
items: packages,
dry_run: app.dry_run,
};
return false; // Don't close modal yet, wait for confirmation
}
// Check if password is needed
// Both official packages (sudo pacman) and AUR packages (paru/yay need sudo for final step)
// require password, so always show password prompt
// User can press Enter if passwordless sudo is configured
let username = std::env::var("USER").unwrap_or_else(|_| "user".to_string());
if let Some(lockout_msg) = crate::logic::faillock::get_lockout_message_if_locked(&username, app)
{
// User is locked out - show warning and don't show password prompt
app.modal = crate::state::Modal::Alert {
message: lockout_msg,
};
return false;
}
// Show password prompt for all installs (official and AUR)
app.modal = crate::state::Modal::PasswordPrompt {
purpose: crate::state::modal::PasswordPurpose::Install,
items: packages,
input: String::new(),
cursor: 0,
error: None,
};
app.pending_exec_header_chips = Some(header_chips);
false // Keep TUI open
}
/// What: Handle proceed action for remove targets.
///
/// Inputs:
/// - `app`: Mutable application state
/// - `items`: Items to remove
/// - `mode`: Cascade removal mode
/// - `header_chips`: Header chip metrics
///
/// Output: `false` to keep TUI open.
///
/// Details: Handles password prompt if needed, or starts execution.
pub(super) fn handle_proceed_remove(
app: &mut AppState,
items: Vec<PackageItem>,
mode: crate::state::modal::CascadeMode,
header_chips: crate::state::modal::PreflightHeaderChips,
) -> bool {
// Store cascade mode for executor (needed in both password and non-password paths)
app.remove_cascade_mode = mode;
// Remove operations always need sudo (pacman -R requires sudo regardless of package source)
// Check faillock status before showing password prompt
let username = std::env::var("USER").unwrap_or_else(|_| "user".to_string());
if let Some(lockout_msg) = crate::logic::faillock::get_lockout_message_if_locked(&username, app)
{
// User is locked out - show warning and don't show password prompt
app.modal = crate::state::Modal::Alert {
message: lockout_msg,
};
return false;
}
// Always show password prompt - user can press Enter if passwordless sudo is configured
app.modal = crate::state::Modal::PasswordPrompt {
purpose: crate::state::modal::PasswordPurpose::Remove,
items,
input: String::new(),
cursor: 0,
error: None,
};
app.pending_exec_header_chips = Some(header_chips);
false // Keep TUI open
}
/// What: Handle p key - proceed with install/remove.
///
/// Inputs:
/// - `app`: Mutable application state
///
/// Output:
/// - Always returns `false` to continue event processing.
///
/// Details:
/// - Closes the modal if install/remove is triggered, but TUI remains open.
#[allow(clippy::too_many_lines)] // Function handles complex preflight proceed logic (function has 208 lines)
pub(super) fn handle_p_key(app: &mut AppState) -> bool {
let new_summary: Option<Vec<crate::state::modal::ReverseRootSummary>> = None;
let mut blocked_dep_count: Option<usize> = None;
let mut removal_names: Option<Vec<String>> = None;
let mut removal_mode: Option<crate::state::modal::CascadeMode> = None;
let mut install_targets: Option<Vec<PackageItem>> = None;
let mut service_info_for_plan: Option<Vec<crate::state::modal::ServiceImpact>> = None;
let mut deps_not_resolved_message: Option<String> = None;
// Scope for borrowing app.modal
{
if let crate::state::Modal::Preflight {
action,
items,
dependency_info,
cascade_mode,
selected_optdepends,
service_info,
..
} = &mut app.modal
{
match action {
crate::state::PreflightAction::Install => {
let packages = extract_install_targets(&*items, selected_optdepends);
install_targets = Some(packages);
}
crate::state::PreflightAction::Remove => {
// If dependency_info is empty, dependencies haven't been resolved yet.
// Show a warning but allow removal to proceed (don't block).
if dependency_info.is_empty() {
// Show warning if cascade mode is Basic (might have dependents we don't know about)
if !cascade_mode.allows_dependents() {
deps_not_resolved_message = Some(
"Warning: Dependencies not resolved yet. Package may have dependents. Switch to Dependencies tab to check."
.to_string(),
);
}
// Always allow removal to proceed, even if dependencies aren't resolved
removal_names = Some(items.iter().map(|p| p.name.clone()).collect());
removal_mode = Some(*cascade_mode);
} else if cascade_mode.allows_dependents() {
// Cascade mode allows dependents, proceed with removal
removal_names = Some(items.iter().map(|p| p.name.clone()).collect());
removal_mode = Some(*cascade_mode);
} else {
// Dependencies are resolved, cascade mode is Basic, and there are dependents
// Block removal since Basic mode doesn't allow removing packages with dependents
blocked_dep_count = Some(dependency_info.len());
}
}
crate::state::PreflightAction::Downgrade => {
// For downgrade, we don't need to check dependencies
// Downgrade tool handles its own logic
// Just allow downgrade to proceed - handled separately below
}
}
if !service_info.is_empty() {
service_info_for_plan = Some(service_info.clone());
}
}
}
// Set toast message if dependencies not resolved
if let Some(msg) = deps_not_resolved_message {
app.toast_message = Some(msg);
app.toast_expires_at = Some(std::time::Instant::now() + std::time::Duration::from_secs(5));
}
if let Some(summary) = new_summary {
app.remove_preflight_summary = summary;
}
if let Some(plan) = service_info_for_plan {
app.pending_service_plan = plan;
} else {
app.pending_service_plan.clear();
}
if let Some(packages) = install_targets {
// Get header_chips and service_info before closing modal
let header_chips = if let crate::state::Modal::Preflight { header_chips, .. } = &app.modal {
header_chips.clone()
} else {
crate::state::modal::PreflightHeaderChips::default()
};
let service_info = if let crate::state::Modal::Preflight { service_info, .. } = &app.modal {
service_info.clone()
} else {
Vec::new()
};
// Close preflight modal
crate::events::preflight::modal::close_preflight_modal(app, &service_info);
return handle_proceed_install(app, packages, header_chips);
} else if let Some(names) = removal_names {
let mode = removal_mode.unwrap_or(crate::state::modal::CascadeMode::Basic);
// Get header_chips and service_info before closing modal
let header_chips = if let crate::state::Modal::Preflight { header_chips, .. } = &app.modal {
header_chips.clone()
} else {
crate::state::modal::PreflightHeaderChips::default()
};
let service_info = if let crate::state::Modal::Preflight { service_info, .. } = &app.modal {
service_info.clone()
} else {
Vec::new()
};
// Get items for removal
let items = if let crate::state::Modal::Preflight { items, .. } = &app.modal {
items
.iter()
.filter(|p| names.contains(&p.name))
.cloned()
.collect()
} else {
Vec::new()
};
// Close preflight modal
crate::events::preflight::modal::close_preflight_modal(app, &service_info);
return handle_proceed_remove(app, items, mode, header_chips);
}
// Check if this is a downgrade action
let is_downgrade = if let crate::state::Modal::Preflight { action, .. } = &app.modal {
matches!(action, crate::state::PreflightAction::Downgrade)
} else {
false
};
if is_downgrade {
// Get items, action, header_chips, and cascade_mode before closing modal
let (items, _action, header_chips, cascade_mode) = if let crate::state::Modal::Preflight {
action,
items,
header_chips,
cascade_mode,
..
} = &app.modal
{
(items.clone(), *action, header_chips.clone(), *cascade_mode)
} else {
return false;
};
// Downgrade operations always need sudo (downgrade tool requires sudo)
// Always show password prompt - user can press Enter if passwordless sudo is configured
// Store cascade mode for consistency (though downgrade doesn't use it)
app.remove_cascade_mode = cascade_mode;
// Get service_info before closing modal
let service_info = if let crate::state::Modal::Preflight { service_info, .. } = &app.modal {
service_info.clone()
} else {
Vec::new()
};
// Close preflight modal
crate::events::preflight::modal::close_preflight_modal(app, &service_info);
// Check faillock status before showing password prompt for downgrade
let username = std::env::var("USER").unwrap_or_else(|_| "user".to_string());
if let Some(lockout_msg) =
crate::logic::faillock::get_lockout_message_if_locked(&username, app)
{
// User is locked out - show warning and don't show password prompt
app.modal = crate::state::Modal::Alert {
message: lockout_msg,
};
return false;
}
// Show password prompt for downgrade
app.modal = crate::state::Modal::PasswordPrompt {
purpose: crate::state::modal::PasswordPurpose::Downgrade,
items,
input: String::new(),
cursor: 0,
error: None,
};
app.pending_exec_header_chips = Some(header_chips);
return false;
}
if let Some(count) = blocked_dep_count {
let root_list: Vec<String> = app
.remove_preflight_summary
.iter()
.filter(|summary| summary.total_dependents > 0)
.map(|summary| summary.package.clone())
.collect();
let subject = if root_list.is_empty() {
"the selected packages".to_string()
} else {
root_list.join(", ")
};
app.toast_message = Some(format!(
"Removal blocked: {count} dependent package(s) rely on {subject}. Enable cascade removal to proceed."
));
app.toast_expires_at = Some(std::time::Instant::now() + std::time::Duration::from_secs(6));
}
false
}
/// What: Handle c key - snapshot placeholder.
///
/// Inputs:
/// - `app`: Mutable application state
///
/// Output:
/// - Always returns `false`.
pub(super) fn handle_c_key(app: &mut AppState) -> bool {
// TODO: implement Logic for creating a snapshot
app.toast_message = Some(crate::i18n::t(app, "app.toasts.snapshot_placeholder"));
false
}
/// What: Handle q key - close modal.
///
/// Inputs:
/// - `app`: Mutable application state
///
/// Output:
/// - Always returns `false` to continue event processing.
///
/// Details:
/// - Closes the modal but keeps the TUI open.
pub(super) fn handle_q_key(app: &mut AppState) -> bool {
let service_info = if let crate::state::Modal::Preflight { service_info, .. } = &app.modal {
service_info.clone()
} else {
Vec::new()
};
close_preflight_modal(app, &service_info);
// Return false to keep TUI open - modal is closed but app continues
false
}
/// What: Handle ? key - show help.
///
/// Inputs:
/// - `app`: Mutable application state
///
/// Output:
/// - Always returns `false`.
pub(super) fn handle_help_key(app: &mut AppState) -> bool {
let help_message = if let crate::state::Modal::Preflight { tab, .. } = &app.modal {
if *tab == crate::state::PreflightTab::Deps {
crate::i18n::t(app, "app.modals.preflight.help.deps_tab")
} else {
crate::i18n::t(app, "app.modals.preflight.help.general")
}
} else {
return false;
};
app.previous_modal = Some(app.modal.clone());
app.modal = crate::state::Modal::Alert {
message: help_message,
};
false
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/preflight/keys/action_keys.rs | src/events/preflight/keys/action_keys.rs | //! Action key handlers for Preflight modal.
use std::collections::HashMap;
use crate::state::AppState;
use crate::state::modal::ServiceRestartDecision;
use super::context::{EnterOrSpaceContext, PreflightKeyContext};
use super::tab_handlers::handle_enter_or_space;
use crate::events::preflight::modal::close_preflight_modal;
/// What: Handle Esc key - close the Preflight modal.
///
/// Inputs:
/// - `app`: Mutable application state
///
/// Output:
/// - Always returns `false` to continue event processing.
///
/// Details:
/// - Closes the preflight modal but keeps the TUI open.
pub(super) fn handle_esc_key(app: &mut AppState) -> bool {
let service_info = if let crate::state::Modal::Preflight { service_info, .. } = &app.modal {
service_info.clone()
} else {
Vec::new()
};
close_preflight_modal(app, &service_info);
// Return false to keep TUI open - modal is closed but app continues
false
}
/// What: Handle Enter key - execute Enter/Space action.
///
/// Inputs:
/// - `app`: Mutable application state
///
/// Output:
/// - Always returns `false` to continue event processing.
///
/// Details:
/// - May close the modal if action requires it, but TUI remains open.
pub(super) fn handle_enter_key(app: &mut AppState) -> bool {
let should_close = if let crate::state::Modal::Preflight {
tab,
items,
dependency_info,
dep_selected,
dep_tree_expanded,
file_info,
file_selected,
file_tree_expanded,
sandbox_info,
sandbox_selected,
sandbox_tree_expanded,
selected_optdepends,
service_info,
service_selected,
..
} = &mut app.modal
{
handle_enter_or_space(EnterOrSpaceContext {
tab,
items,
dependency_info,
dep_selected: *dep_selected,
dep_tree_expanded,
file_info,
file_selected: *file_selected,
file_tree_expanded,
sandbox_info,
sandbox_selected: *sandbox_selected,
sandbox_tree_expanded,
selected_optdepends,
service_info,
service_selected: *service_selected,
})
} else {
false
};
if should_close {
// Use the same flow as "p" key - delegate to handle_proceed functions
// This ensures reinstall check and batch update check happen before password prompt
let (items_clone, action_clone, header_chips_clone, cascade_mode) =
if let crate::state::Modal::Preflight {
items,
action,
header_chips,
cascade_mode,
..
} = &app.modal
{
(items.clone(), *action, header_chips.clone(), *cascade_mode)
} else {
// Not a Preflight modal, just close it
let service_info =
if let crate::state::Modal::Preflight { service_info, .. } = &app.modal {
service_info.clone()
} else {
Vec::new()
};
close_preflight_modal(app, &service_info);
return false;
};
// Get service info before closing modal
let service_info = if let crate::state::Modal::Preflight { service_info, .. } = &app.modal {
service_info.clone()
} else {
Vec::new()
};
close_preflight_modal(app, &service_info);
// Use the same proceed handlers as "p" key to ensure consistent flow
match action_clone {
crate::state::PreflightAction::Install => {
use super::command_keys;
command_keys::handle_proceed_install(app, items_clone, header_chips_clone);
}
crate::state::PreflightAction::Remove => {
use super::command_keys;
command_keys::handle_proceed_remove(
app,
items_clone,
cascade_mode,
header_chips_clone,
);
}
crate::state::PreflightAction::Downgrade => {
// Downgrade operations always need sudo (downgrade tool requires sudo)
// Check faillock status before showing password prompt
let username = std::env::var("USER").unwrap_or_else(|_| "user".to_string());
if let Some(lockout_msg) =
crate::logic::faillock::get_lockout_message_if_locked(&username, app)
{
// User is locked out - show warning and don't show password prompt
app.modal = crate::state::Modal::Alert {
message: lockout_msg,
};
return false;
}
// Always show password prompt - user can press Enter if passwordless sudo is configured
app.modal = crate::state::Modal::PasswordPrompt {
purpose: crate::state::modal::PasswordPurpose::Downgrade,
items: items_clone,
input: String::new(),
cursor: 0,
error: None,
};
app.pending_exec_header_chips = Some(header_chips_clone);
}
}
// Return false to keep TUI open - modal is closed but app continues
return false;
}
false
}
/// What: Start command execution by transitioning to `PreflightExec` and storing `ExecutorRequest`.
///
/// Inputs:
/// - `app`: Mutable application state
/// - `items`: Packages to install/remove
/// - `action`: Install or Remove action
/// - `header_chips`: Header chip metrics
/// - `password`: Optional password (if already obtained from password prompt)
///
/// Details:
/// - Transitions to `PreflightExec` modal and stores `ExecutorRequest` for processing in tick handler
#[allow(clippy::needless_pass_by_value)] // header_chips is consumed in modal creation
pub fn start_execution(
app: &mut AppState,
items: &[crate::state::PackageItem],
action: crate::state::PreflightAction,
header_chips: crate::state::modal::PreflightHeaderChips,
password: Option<String>,
) {
use crate::install::ExecutorRequest;
// Note: Reinstall check is now done in handle_proceed_install BEFORE password prompt
// This function is called after reinstall confirmation (if needed) and password prompt (if needed)
tracing::debug!(
action = ?action,
item_count = items.len(),
header_chips = ?header_chips,
has_password = password.is_some(),
"[Preflight] Transitioning modal: Preflight -> PreflightExec"
);
// Transition to PreflightExec modal
app.modal = crate::state::Modal::PreflightExec {
items: items.to_vec(),
action,
tab: crate::state::PreflightTab::Summary,
verbose: false,
log_lines: Vec::new(),
abortable: false,
header_chips,
success: None,
};
// Store executor request for processing in tick handler
app.pending_executor_request = Some(match action {
crate::state::PreflightAction::Install => ExecutorRequest::Install {
items: items.to_vec(),
password,
dry_run: app.dry_run,
},
crate::state::PreflightAction::Remove => {
let names: Vec<String> = items.iter().map(|p| p.name.clone()).collect();
ExecutorRequest::Remove {
names,
password,
cascade: app.remove_cascade_mode,
dry_run: app.dry_run,
}
}
crate::state::PreflightAction::Downgrade => {
let names: Vec<String> = items.iter().map(|p| p.name.clone()).collect();
ExecutorRequest::Downgrade {
names,
password,
dry_run: app.dry_run,
}
}
});
}
/// What: Handle Space key - toggle expand/collapse.
///
/// Inputs:
/// - `ctx`: Preflight key context
///
/// Output:
/// - Always returns `false`.
pub(super) fn handle_space_key(ctx: &mut PreflightKeyContext<'_>) -> bool {
handle_enter_or_space(EnterOrSpaceContext {
tab: ctx.tab,
items: ctx.items,
dependency_info: ctx.dependency_info,
dep_selected: *ctx.dep_selected,
dep_tree_expanded: ctx.dep_tree_expanded,
file_info: ctx.file_info,
file_selected: *ctx.file_selected,
file_tree_expanded: ctx.file_tree_expanded,
sandbox_info: ctx.sandbox_info,
sandbox_selected: *ctx.sandbox_selected,
sandbox_tree_expanded: ctx.sandbox_tree_expanded,
selected_optdepends: ctx.selected_optdepends,
service_info: ctx.service_info,
service_selected: *ctx.service_selected,
});
false
}
/// What: Handle Shift+R key - re-run all analyses.
///
/// Inputs:
/// - `app`: Mutable application state
///
/// Output:
/// - Always returns `false`.
pub(super) fn handle_shift_r_key(app: &mut AppState) -> bool {
tracing::info!("Shift+R pressed: Re-running all preflight analyses");
let (items, action) = if let crate::state::Modal::Preflight { items, action, .. } = &app.modal {
(items.clone(), *action)
} else {
return false;
};
// Clear all cached data in the modal
if let crate::state::Modal::Preflight {
dependency_info,
deps_error,
file_info,
files_error,
service_info,
services_error,
services_loaded,
sandbox_info,
sandbox_error,
sandbox_loaded,
summary,
dep_selected,
file_selected,
service_selected,
sandbox_selected,
dep_tree_expanded,
file_tree_expanded,
sandbox_tree_expanded,
..
} = &mut app.modal
{
*dependency_info = Vec::new();
*deps_error = None;
*file_info = Vec::new();
*files_error = None;
*service_info = Vec::new();
*services_error = None;
*services_loaded = false;
*sandbox_info = Vec::new();
*sandbox_error = None;
*sandbox_loaded = false;
*summary = None;
*dep_selected = 0;
*file_selected = 0;
*service_selected = 0;
*sandbox_selected = 0;
dep_tree_expanded.clear();
file_tree_expanded.clear();
sandbox_tree_expanded.clear();
}
// Reset cancellation flag
app.preflight_cancelled
.store(false, std::sync::atomic::Ordering::Relaxed);
// Queue all stages for background resolution (same as opening modal)
app.preflight_summary_items = Some((items.clone(), action));
app.preflight_summary_resolving = true;
if matches!(action, crate::state::PreflightAction::Install) {
app.preflight_deps_items = Some((items.clone(), crate::state::PreflightAction::Install));
app.preflight_deps_resolving = true;
app.preflight_files_items = Some(items.clone());
app.preflight_files_resolving = true;
app.preflight_services_items = Some(items.clone());
app.preflight_services_resolving = true;
// Only queue sandbox for AUR packages
let aur_items: Vec<_> = items
.iter()
.filter(|p| matches!(p.source, crate::state::Source::Aur))
.cloned()
.collect();
if aur_items.is_empty() {
app.preflight_sandbox_items = None;
app.preflight_sandbox_resolving = false;
if let crate::state::Modal::Preflight { sandbox_loaded, .. } = &mut app.modal {
*sandbox_loaded = true;
}
} else {
app.preflight_sandbox_items = Some(aur_items);
app.preflight_sandbox_resolving = true;
}
}
app.toast_message = Some("Re-running all preflight analyses...".to_string());
app.toast_expires_at = Some(std::time::Instant::now() + std::time::Duration::from_secs(3));
false
}
/// What: Handle regular R key - retry resolution for current tab.
///
/// Inputs:
/// - `ctx`: Preflight key context
///
/// Output:
/// - Always returns `false`.
pub(super) fn handle_r_key(ctx: &mut PreflightKeyContext<'_>) -> bool {
if *ctx.tab == crate::state::PreflightTab::Services && !ctx.service_info.is_empty() {
// Toggle restart decision for selected service (only if no error)
if *ctx.service_selected >= ctx.service_info.len() {
*ctx.service_selected = ctx.service_info.len().saturating_sub(1);
}
if let Some(service) = ctx.service_info.get_mut(*ctx.service_selected) {
service.restart_decision = ServiceRestartDecision::Restart;
}
} else if *ctx.tab == crate::state::PreflightTab::Deps
&& matches!(*ctx.action, crate::state::PreflightAction::Install)
{
// Retry dependency resolution
*ctx.deps_error = None;
*ctx.dependency_info = crate::logic::deps::resolve_dependencies(ctx.items);
*ctx.dep_selected = 0;
} else if *ctx.tab == crate::state::PreflightTab::Files {
// Retry file resolution
*ctx.files_error = None;
*ctx.file_info = crate::logic::files::resolve_file_changes(ctx.items, *ctx.action);
*ctx.file_selected = 0;
} else if *ctx.tab == crate::state::PreflightTab::Services {
// Retry service resolution
*ctx.services_error = None;
*ctx.services_loaded = false;
*ctx.service_info = crate::logic::services::resolve_service_impacts(ctx.items, *ctx.action);
*ctx.service_selected = 0;
*ctx.services_loaded = true;
}
false
}
/// What: Handle D key - set service restart decision to Defer.
///
/// Inputs:
/// - `ctx`: Preflight key context
///
/// Output:
/// - Always returns `false`.
pub(super) fn handle_d_key(ctx: &mut PreflightKeyContext<'_>) -> bool {
if *ctx.tab == crate::state::PreflightTab::Services && !ctx.service_info.is_empty() {
if *ctx.service_selected >= ctx.service_info.len() {
*ctx.service_selected = ctx.service_info.len().saturating_sub(1);
}
if let Some(service) = ctx.service_info.get_mut(*ctx.service_selected) {
service.restart_decision = ServiceRestartDecision::Defer;
}
}
false
}
/// What: Handle A key - expand/collapse all package groups.
///
/// Inputs:
/// - `ctx`: Preflight key context
///
/// Output:
/// - Always returns `false`.
pub(super) fn handle_a_key(ctx: &mut PreflightKeyContext<'_>) -> bool {
if *ctx.tab == crate::state::PreflightTab::Deps && !ctx.dependency_info.is_empty() {
let mut grouped: HashMap<String, Vec<&crate::state::modal::DependencyInfo>> =
HashMap::new();
for dep in ctx.dependency_info.iter() {
for req_by in &dep.required_by {
grouped.entry(req_by.clone()).or_default().push(dep);
}
}
let all_expanded = ctx
.items
.iter()
.all(|p| ctx.dep_tree_expanded.contains(&p.name));
if all_expanded {
// Collapse all
ctx.dep_tree_expanded.clear();
} else {
// Expand all packages (even if they have no dependencies)
for pkg_name in ctx.items.iter().map(|p| &p.name) {
ctx.dep_tree_expanded.insert(pkg_name.clone());
}
}
} else if *ctx.tab == crate::state::PreflightTab::Files && !ctx.file_info.is_empty() {
// Expand/collapse all packages in Files tab
let all_expanded = ctx
.file_info
.iter()
.filter(|p| !p.files.is_empty())
.all(|p| ctx.file_tree_expanded.contains(&p.name));
if all_expanded {
// Collapse all
ctx.file_tree_expanded.clear();
} else {
// Expand all
for pkg_info in ctx.file_info.iter() {
if !pkg_info.files.is_empty() {
ctx.file_tree_expanded.insert(pkg_info.name.clone());
}
}
}
}
false
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/preflight/keys/tab_handlers.rs | src/events/preflight/keys/tab_handlers.rs | //! Tab-specific handlers for Enter/Space key actions.
use std::collections::{HashMap, HashSet};
use crate::state::modal::ServiceRestartDecision;
use super::context::EnterOrSpaceContext;
use crate::events::preflight::display::build_file_display_items;
/// What: Handle Enter or Space key for Deps tab tree expansion/collapse.
///
/// Inputs:
/// - `ctx`: Context struct containing all necessary state references
///
/// Output:
/// - `true` if handled, `false` otherwise.
///
/// Details:
/// - Toggles expansion/collapse of dependency trees for selected package.
pub(super) fn handle_deps_tab(ctx: &mut EnterOrSpaceContext<'_>) -> bool {
if ctx.dependency_info.is_empty() {
return false;
}
let mut grouped: HashMap<String, Vec<&crate::state::modal::DependencyInfo>> = HashMap::new();
for dep in ctx.dependency_info {
for req_by in &dep.required_by {
grouped.entry(req_by.clone()).or_default().push(dep);
}
}
let mut display_items: Vec<(bool, String)> = Vec::new();
for pkg_name in ctx.items.iter().map(|p| &p.name) {
display_items.push((true, pkg_name.clone()));
if ctx.dep_tree_expanded.contains(pkg_name)
&& let Some(pkg_deps) = grouped.get(pkg_name)
{
let mut seen_deps = HashSet::new();
for dep in pkg_deps {
if seen_deps.insert(dep.name.as_str()) {
display_items.push((false, String::new()));
}
}
}
}
if let Some((is_header, pkg_name)) = display_items.get(ctx.dep_selected)
&& *is_header
{
if ctx.dep_tree_expanded.contains(pkg_name) {
ctx.dep_tree_expanded.remove(pkg_name);
} else {
ctx.dep_tree_expanded.insert(pkg_name.clone());
}
}
false
}
/// What: Handle Enter or Space key for Files tab tree expansion/collapse.
///
/// Inputs:
/// - `ctx`: Context struct containing all necessary state references
///
/// Output:
/// - `true` if handled, `false` otherwise.
///
/// Details:
/// - Toggles expansion/collapse of file trees for selected package.
pub(super) fn handle_files_tab(ctx: &mut EnterOrSpaceContext<'_>) -> bool {
let display_items = build_file_display_items(ctx.items, ctx.file_info, ctx.file_tree_expanded);
if let Some((is_header, pkg_name)) = display_items.get(ctx.file_selected)
&& *is_header
{
if ctx.file_tree_expanded.contains(pkg_name) {
ctx.file_tree_expanded.remove(pkg_name);
} else {
ctx.file_tree_expanded.insert(pkg_name.clone());
}
}
false
}
/// What: Handle Enter or Space key for Sandbox tab tree expansion/collapse and optdepends selection.
///
/// Inputs:
/// - `ctx`: Context struct containing all necessary state references
///
/// Output:
/// - `true` if handled, `false` otherwise.
///
/// Details:
/// - Toggles expansion/collapse of sandbox dependency trees for selected package.
/// - Toggles optional dependency selection when on an optdepends entry.
pub(super) fn handle_sandbox_tab(ctx: &mut EnterOrSpaceContext<'_>) -> bool {
type SandboxDisplayItem = (bool, String, Option<(&'static str, String)>);
if ctx.items.is_empty() {
return false;
}
let mut display_items: Vec<SandboxDisplayItem> = Vec::new();
for item in ctx.items {
let is_aur = matches!(item.source, crate::state::Source::Aur);
display_items.push((true, item.name.clone(), None));
if is_aur
&& ctx.sandbox_tree_expanded.contains(&item.name)
&& let Some(info) = ctx
.sandbox_info
.iter()
.find(|s| s.package_name == item.name)
{
for dep in &info.depends {
display_items.push((
false,
item.name.clone(),
Some(("depends", dep.name.clone())),
));
}
for dep in &info.makedepends {
display_items.push((
false,
item.name.clone(),
Some(("makedepends", dep.name.clone())),
));
}
for dep in &info.checkdepends {
display_items.push((
false,
item.name.clone(),
Some(("checkdepends", dep.name.clone())),
));
}
for dep in &info.optdepends {
display_items.push((
false,
item.name.clone(),
Some(("optdepends", dep.name.clone())),
));
}
}
}
if let Some((is_header, pkg_name, dep_opt)) = display_items.get(ctx.sandbox_selected) {
if *is_header {
let item = ctx
.items
.iter()
.find(|p| p.name == *pkg_name)
.expect("package should exist in items when present in display_items");
if matches!(item.source, crate::state::Source::Aur) {
if ctx.sandbox_tree_expanded.contains(pkg_name) {
ctx.sandbox_tree_expanded.remove(pkg_name);
} else {
ctx.sandbox_tree_expanded.insert(pkg_name.clone());
}
}
} else if let Some((dep_type, dep_name)) = dep_opt
&& *dep_type == "optdepends"
{
let selected_set = ctx.selected_optdepends.entry(pkg_name.clone()).or_default();
let pkg_name_from_dep = crate::logic::sandbox::extract_package_name(dep_name);
if selected_set.contains(dep_name) || selected_set.contains(&pkg_name_from_dep) {
selected_set.remove(dep_name);
selected_set.remove(&pkg_name_from_dep);
} else {
selected_set.insert(dep_name.clone());
}
}
}
false
}
/// What: Handle Enter or Space key for Services tab restart decision toggling.
///
/// Inputs:
/// - `ctx`: Context struct containing all necessary state references
///
/// Output:
/// - `true` if handled, `false` otherwise.
///
/// Details:
/// - Toggles restart decision for the selected service.
pub(super) fn handle_services_tab(ctx: &mut EnterOrSpaceContext<'_>) -> bool {
if ctx.service_info.is_empty() {
return false;
}
let service_selected = ctx
.service_selected
.min(ctx.service_info.len().saturating_sub(1));
if let Some(service) = ctx.service_info.get_mut(service_selected) {
service.restart_decision = match service.restart_decision {
ServiceRestartDecision::Restart => ServiceRestartDecision::Defer,
ServiceRestartDecision::Defer => ServiceRestartDecision::Restart,
};
}
false
}
/// What: Handle Enter or Space key for tree expansion/collapse in various tabs.
///
/// Inputs:
/// - `ctx`: Context struct containing all necessary state references
///
/// Output:
/// - `true` if the key was handled (should close modal), `false` otherwise.
///
/// Details:
/// - Handles expansion/collapse logic for Deps, Files, and Sandbox tabs.
/// - Handles service restart decision toggling in Services tab.
pub(super) fn handle_enter_or_space(ctx: EnterOrSpaceContext<'_>) -> bool {
let mut ctx = ctx;
match *ctx.tab {
crate::state::PreflightTab::Deps => handle_deps_tab(&mut ctx),
crate::state::PreflightTab::Files => handle_files_tab(&mut ctx),
crate::state::PreflightTab::Sandbox => handle_sandbox_tab(&mut ctx),
crate::state::PreflightTab::Services => handle_services_tab(&mut ctx),
crate::state::PreflightTab::Summary => true, // Default: close modal
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/preflight/keys/navigation.rs | src/events/preflight/keys/navigation.rs | //! Navigation key handlers for Preflight modal.
use crate::state::AppState;
use super::context::PreflightKeyContext;
use crate::events::preflight::display::{
compute_display_items_len, compute_file_display_items_len, compute_sandbox_display_items_len,
};
use crate::events::preflight::modal::switch_preflight_tab;
/// What: Handle Left/Right/Tab keys - switch tabs.
///
/// Inputs:
/// - `app`: Mutable application state
/// - `direction`: Direction to switch (true for right/tab, false for left)
///
/// Output:
/// - Always returns `false`.
pub(super) fn handle_tab_switch(app: &mut AppState, direction: bool) -> bool {
let (new_tab, items, action) =
if let crate::state::Modal::Preflight {
tab, items, action, ..
} = &app.modal
{
let current_tab = *tab;
let next_tab = if direction {
match current_tab {
crate::state::PreflightTab::Summary => crate::state::PreflightTab::Deps,
crate::state::PreflightTab::Deps => crate::state::PreflightTab::Files,
crate::state::PreflightTab::Files => crate::state::PreflightTab::Services,
crate::state::PreflightTab::Services => crate::state::PreflightTab::Sandbox,
crate::state::PreflightTab::Sandbox => crate::state::PreflightTab::Summary,
}
} else {
match current_tab {
crate::state::PreflightTab::Summary => crate::state::PreflightTab::Sandbox,
crate::state::PreflightTab::Deps => crate::state::PreflightTab::Summary,
crate::state::PreflightTab::Files => crate::state::PreflightTab::Deps,
crate::state::PreflightTab::Services => crate::state::PreflightTab::Files,
crate::state::PreflightTab::Sandbox => crate::state::PreflightTab::Services,
}
};
(next_tab, items.clone(), *action)
} else {
return false;
};
if let crate::state::Modal::Preflight { tab, .. } = &mut app.modal {
let old_tab = *tab;
*tab = new_tab;
tracing::info!(
"[Preflight] Keyboard tab switch: Updated tab field from {:?} to {:?}",
old_tab,
new_tab
);
}
switch_preflight_tab(new_tab, app, &items, action);
false
}
/// What: Handle Up key - move selection up in current tab.
///
/// Inputs:
/// - `ctx`: Preflight key context
///
/// Output:
/// - Always returns `false`.
pub(super) fn handle_up_key(ctx: &mut PreflightKeyContext<'_>) -> bool {
if *ctx.tab == crate::state::PreflightTab::Deps && !ctx.items.is_empty() {
if *ctx.dep_selected > 0 {
*ctx.dep_selected -= 1;
tracing::debug!(
"[Preflight] Deps Up: dep_selected={}, items={}",
*ctx.dep_selected,
ctx.items.len()
);
} else {
tracing::debug!(
"[Preflight] Deps Up: already at top (dep_selected=0), items={}",
ctx.items.len()
);
}
} else if *ctx.tab == crate::state::PreflightTab::Files
&& !ctx.file_info.is_empty()
&& *ctx.file_selected > 0
{
*ctx.file_selected -= 1;
} else if *ctx.tab == crate::state::PreflightTab::Services
&& !ctx.service_info.is_empty()
&& *ctx.service_selected > 0
{
*ctx.service_selected -= 1;
} else if *ctx.tab == crate::state::PreflightTab::Sandbox
&& !ctx.items.is_empty()
&& *ctx.sandbox_selected > 0
{
*ctx.sandbox_selected -= 1;
}
false
}
/// What: Handle Down key - move selection down in current tab.
///
/// Inputs:
/// - `ctx`: Preflight key context
///
/// Output:
/// - Always returns `false`.
pub(super) fn handle_down_key(ctx: &mut PreflightKeyContext<'_>) -> bool {
if *ctx.tab == crate::state::PreflightTab::Deps && !ctx.items.is_empty() {
let display_len =
compute_display_items_len(ctx.items, ctx.dependency_info, ctx.dep_tree_expanded);
tracing::debug!(
"[Preflight] Deps Down: dep_selected={}, display_len={}, items={}, deps={}, expanded_count={}",
*ctx.dep_selected,
display_len,
ctx.items.len(),
ctx.dependency_info.len(),
ctx.dep_tree_expanded.len()
);
if *ctx.dep_selected < display_len.saturating_sub(1) {
*ctx.dep_selected += 1;
tracing::debug!(
"[Preflight] Deps Down: moved to dep_selected={}",
*ctx.dep_selected
);
} else {
tracing::debug!(
"[Preflight] Deps Down: already at bottom (dep_selected={}, display_len={})",
*ctx.dep_selected,
display_len
);
}
} else if *ctx.tab == crate::state::PreflightTab::Files {
let display_len =
compute_file_display_items_len(ctx.items, ctx.file_info, ctx.file_tree_expanded);
if *ctx.file_selected < display_len.saturating_sub(1) {
*ctx.file_selected += 1;
}
} else if *ctx.tab == crate::state::PreflightTab::Services && !ctx.service_info.is_empty() {
let max_index = ctx.service_info.len().saturating_sub(1);
if *ctx.service_selected < max_index {
*ctx.service_selected += 1;
}
} else if *ctx.tab == crate::state::PreflightTab::Sandbox && !ctx.items.is_empty() {
let display_len = compute_sandbox_display_items_len(
ctx.items,
ctx.sandbox_info,
ctx.sandbox_tree_expanded,
);
if *ctx.sandbox_selected < display_len.saturating_sub(1) {
*ctx.sandbox_selected += 1;
}
}
false
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/preflight/keys/mod.rs | src/events/preflight/keys/mod.rs | //! Key event handling for Preflight modal.
mod action_keys;
mod command_keys;
mod context;
mod navigation;
mod tab_handlers;
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
use crate::state::AppState;
use action_keys::{
handle_a_key, handle_d_key, handle_enter_key, handle_esc_key, handle_r_key, handle_shift_r_key,
handle_space_key,
};
// Re-export start_execution for use in other modules
pub use action_keys::start_execution;
use command_keys::{
handle_c_key, handle_dry_run_key, handle_f_key, handle_help_key, handle_m_key, handle_p_key,
handle_q_key, handle_s_key,
};
use context::PreflightKeyContext;
use navigation::{handle_down_key, handle_tab_switch, handle_up_key};
/// What: Handle keys that need access to app fields outside of modal.
///
/// Inputs:
/// - `ke`: Key event
/// - `app`: Mutable application state
///
/// Output:
/// - Always returns `false`.
fn handle_keys_needing_app(ke: KeyEvent, app: &mut AppState) -> bool {
match ke.code {
KeyCode::Esc => {
handle_esc_key(app);
false
}
KeyCode::Enter => {
handle_enter_key(app);
false
}
KeyCode::Left => handle_tab_switch(app, false),
KeyCode::Right | KeyCode::Tab => handle_tab_switch(app, true),
KeyCode::Char('r' | 'R') => {
if ke.modifiers.contains(KeyModifiers::SHIFT) {
handle_shift_r_key(app)
} else {
false // Handled in first block
}
}
KeyCode::Char('f' | 'F') => handle_f_key(app),
KeyCode::Char('s' | 'S') => handle_s_key(app),
KeyCode::Char('d') => handle_dry_run_key(app),
KeyCode::Char('m') => {
// Only handle 'm' if no modifiers are present (to allow Ctrl+M for global keybinds)
if ke.modifiers.is_empty() {
handle_m_key(app)
} else {
false
}
}
KeyCode::Char('p') => handle_p_key(app),
KeyCode::Char('c') => handle_c_key(app),
KeyCode::Char('q') => handle_q_key(app),
KeyCode::Char('?') => handle_help_key(app),
_ => false,
}
}
/// What: Handle key events while the Preflight modal is active (install/remove workflows).
///
/// Inputs:
/// - `ke`: Key event received from crossterm while Preflight is focused
/// - `app`: Mutable application state containing the Preflight modal data
///
/// Output:
/// - Always returns `false` so the outer event loop continues processing.
///
/// Details:
/// - Supports tab switching, tree expansion, dependency/file navigation, scans, dry-run toggles, and
/// command execution across install/remove flows.
/// - Mutates `app.modal` (and related cached fields) to close the modal, open nested dialogs, or
/// keep it updated with resolved dependency/file data.
/// - Returns `false` so callers continue processing, matching existing event-loop expectations.
pub fn handle_preflight_key(ke: KeyEvent, app: &mut AppState) -> bool {
// First, handle keys that only need ctx (no app access required)
// This avoids borrow checker conflicts
{
if let crate::state::Modal::Preflight {
tab,
items,
action,
dependency_info,
dep_selected,
dep_tree_expanded,
deps_error,
file_info,
file_selected,
file_tree_expanded,
files_error,
service_info,
service_selected,
services_loaded,
services_error,
sandbox_info,
sandbox_selected,
sandbox_tree_expanded,
selected_optdepends,
..
} = &mut app.modal
{
let mut ctx = PreflightKeyContext {
tab,
items,
action,
dependency_info,
dep_selected,
dep_tree_expanded,
deps_error,
file_info,
file_selected,
file_tree_expanded,
files_error,
service_info,
service_selected,
services_loaded,
services_error,
sandbox_info,
sandbox_selected,
sandbox_tree_expanded,
selected_optdepends,
};
match ke.code {
KeyCode::Up => {
handle_up_key(&mut ctx);
return false;
}
KeyCode::Down => {
handle_down_key(&mut ctx);
return false;
}
KeyCode::Char(' ') => {
handle_space_key(&mut ctx);
return false;
}
KeyCode::Char('D') => {
handle_d_key(&mut ctx);
return false;
}
KeyCode::Char('a' | 'A') => {
handle_a_key(&mut ctx);
return false;
}
KeyCode::Char('r' | 'R') => {
if !ke.modifiers.contains(KeyModifiers::SHIFT) {
handle_r_key(&mut ctx);
return false;
}
// Shift+R needs app, fall through
}
_ => {
// Keys that need app access, fall through
}
}
}
false
};
// Now handle keys that need app access
// The borrow of app.modal has been released, so we can mutably borrow app again
handle_keys_needing_app(ke, app)
}
#[cfg(test)]
mod tests {
use crate::state::PackageItem;
use crate::state::modal::DependencyInfo;
use std::collections::{HashMap, HashSet};
use super::context::EnterOrSpaceContext;
use super::tab_handlers::handle_deps_tab;
// Helper to create dummy items
fn make_item(name: &str) -> PackageItem {
PackageItem {
name: name.to_string(),
version: "1.0".to_string(),
description: "desc".to_string(),
source: crate::state::Source::Official {
repo: "core".into(),
arch: "x86_64".into(),
},
popularity: None,
out_of_date: None,
orphaned: false,
}
}
#[test]
fn test_handle_deps_tab_toggle() {
// Setup
let items = vec![make_item("pkg1")];
let deps = vec![DependencyInfo {
name: "dep1".to_string(),
version: "1.0".to_string(),
status: crate::state::modal::DependencyStatus::ToInstall,
source: crate::state::modal::DependencySource::Official {
repo: "core".into(),
},
required_by: vec!["pkg1".to_string()],
depends_on: vec![],
is_core: false,
is_system: false,
}];
let mut expanded = HashSet::new();
let mut selected_optdepends = HashMap::new();
let mut service_info = Vec::new();
let mut ctx = EnterOrSpaceContext {
tab: &crate::state::PreflightTab::Deps,
items: &items,
dependency_info: &deps,
dep_selected: 0, // "pkg1" header
dep_tree_expanded: &mut expanded,
file_info: &[],
file_selected: 0,
file_tree_expanded: &mut HashSet::new(),
sandbox_info: &[],
sandbox_selected: 0,
sandbox_tree_expanded: &mut HashSet::new(),
selected_optdepends: &mut selected_optdepends,
service_info: &mut service_info,
service_selected: 0,
};
// Act: Expand pkg1
handle_deps_tab(&mut ctx);
assert!(ctx.dep_tree_expanded.contains("pkg1"));
// Act: Collapse pkg1
handle_deps_tab(&mut ctx);
assert!(!ctx.dep_tree_expanded.contains("pkg1"));
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/preflight/keys/context.rs | src/events/preflight/keys/context.rs | //! Context structs for Preflight key handling.
use std::collections::{HashMap, HashSet};
use crate::state::PackageItem;
/// What: Context struct grouping parameters for Enter/Space key handling.
///
/// Details:
/// - Reduces function argument count to avoid clippy warnings.
pub struct EnterOrSpaceContext<'a> {
/// Currently active preflight tab.
pub(crate) tab: &'a crate::state::PreflightTab,
/// Package items being analyzed.
pub(crate) items: &'a [PackageItem],
/// Dependency information for packages.
pub(crate) dependency_info: &'a [crate::state::modal::DependencyInfo],
/// Currently selected dependency index.
pub(crate) dep_selected: usize,
/// Set of expanded dependency tree nodes.
pub(crate) dep_tree_expanded: &'a mut HashSet<String>,
/// File information for packages.
pub(crate) file_info: &'a [crate::state::modal::PackageFileInfo],
/// Currently selected file index.
pub(crate) file_selected: usize,
/// Set of expanded file tree nodes.
pub(crate) file_tree_expanded: &'a mut HashSet<String>,
/// Sandbox analysis information.
pub(crate) sandbox_info: &'a [crate::logic::sandbox::SandboxInfo],
/// Currently selected sandbox item index.
pub(crate) sandbox_selected: usize,
/// Set of expanded sandbox tree nodes.
pub(crate) sandbox_tree_expanded: &'a mut HashSet<String>,
/// Map of selected optional dependencies by package.
pub(crate) selected_optdepends: &'a mut HashMap<String, HashSet<String>>,
/// Service impact information.
pub(crate) service_info: &'a mut [crate::state::modal::ServiceImpact],
/// Currently selected service index.
pub(crate) service_selected: usize,
}
/// What: Context struct grouping all Preflight modal state for key handling.
///
/// Details:
/// - Reduces function argument count and cognitive complexity.
/// - Contains all mutable references needed by key handlers.
/// - Note: `app` is passed separately to avoid borrow checker issues.
pub struct PreflightKeyContext<'a> {
/// Currently active preflight tab.
pub(crate) tab: &'a mut crate::state::PreflightTab,
/// Package items being analyzed.
pub(crate) items: &'a [PackageItem],
/// Preflight action (install/remove/downgrade).
pub(crate) action: &'a crate::state::PreflightAction,
/// Dependency information for packages.
pub(crate) dependency_info: &'a mut Vec<crate::state::modal::DependencyInfo>,
/// Currently selected dependency index.
pub(crate) dep_selected: &'a mut usize,
/// Set of expanded dependency tree nodes.
pub(crate) dep_tree_expanded: &'a mut HashSet<String>,
/// Error message for dependency resolution, if any.
pub(crate) deps_error: &'a mut Option<String>,
/// File information for packages.
pub(crate) file_info: &'a mut Vec<crate::state::modal::PackageFileInfo>,
/// Currently selected file index.
pub(crate) file_selected: &'a mut usize,
/// Set of expanded file tree nodes.
pub(crate) file_tree_expanded: &'a mut HashSet<String>,
/// Error message for file analysis, if any.
pub(crate) files_error: &'a mut Option<String>,
/// Service impact information.
pub(crate) service_info: &'a mut Vec<crate::state::modal::ServiceImpact>,
/// Currently selected service index.
pub(crate) service_selected: &'a mut usize,
/// Whether service information has been loaded.
pub(crate) services_loaded: &'a mut bool,
/// Error message for service analysis, if any.
pub(crate) services_error: &'a mut Option<String>,
/// Sandbox analysis information.
pub(crate) sandbox_info: &'a mut Vec<crate::logic::sandbox::SandboxInfo>,
/// Currently selected sandbox item index.
pub(crate) sandbox_selected: &'a mut usize,
/// Set of expanded sandbox tree nodes.
pub(crate) sandbox_tree_expanded: &'a mut HashSet<String>,
/// Map of selected optional dependencies by package.
pub(crate) selected_optdepends: &'a mut HashMap<String, HashSet<String>>,
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Firstp1ck/Pacsea | https://github.com/Firstp1ck/Pacsea/blob/c433ad6a837b7985d8b99ba9afd8f07a93d046f4/src/events/search/preflight_helpers.rs | src/events/search/preflight_helpers.rs | use crate::state::{AppState, PackageItem};
/// What: Filter cached dependencies for current items.
///
/// Inputs:
/// - `app`: Application state with cached dependencies.
/// - `item_names`: Set of current package names.
///
/// Output:
/// - Vector of matching cached dependencies.
fn filter_cached_dependencies(
app: &AppState,
item_names: &std::collections::HashSet<String>,
) -> Vec<crate::state::modal::DependencyInfo> {
app.install_list_deps
.iter()
.filter(|dep| {
dep.required_by
.iter()
.any(|req_by| item_names.contains(req_by))
})
.cloned()
.collect()
}
/// What: Filter cached files for current items.
///
/// Inputs:
/// - `app`: Application state with cached files.
/// - `item_names`: Set of current package names.
///
/// Output:
/// - Vector of matching cached files.
fn filter_cached_files(
app: &AppState,
item_names: &std::collections::HashSet<String>,
) -> Vec<crate::state::modal::PackageFileInfo> {
app.install_list_files
.iter()
.filter(|file_info| item_names.contains(&file_info.name))
.cloned()
.collect()
}
/// What: Trigger background resolution for preflight data.
///
/// Inputs:
/// - `app`: Application state.
/// - `items`: Packages to resolve.
/// - `dependency_info`: Current dependency info (empty triggers resolution).
/// - `cached_files`: Current cached files (empty triggers resolution).
///
/// Output:
/// - Updates app state with resolution flags and items.
fn trigger_background_resolution(
app: &mut AppState,
items: &[PackageItem],
dependency_info: &[crate::state::modal::DependencyInfo],
cached_files: &[crate::state::modal::PackageFileInfo],
) {
if dependency_info.is_empty() {
app.preflight_deps_items = Some((
items.to_vec(),
crate::state::modal::PreflightAction::Install,
));
app.preflight_deps_resolving = true;
}
if cached_files.is_empty() {
app.preflight_files_items = Some(items.to_vec());
app.preflight_files_resolving = true;
}
app.preflight_services_items = Some(items.to_vec());
app.preflight_services_resolving = true;
let aur_items: Vec<_> = items
.iter()
.filter(|p| matches!(p.source, crate::state::Source::Aur))
.cloned()
.collect();
if !aur_items.is_empty() {
app.preflight_sandbox_items = Some(aur_items);
app.preflight_sandbox_resolving = true;
}
}
/// What: Create preflight modal with cached data.
///
/// Inputs:
/// - `app`: Application state.
/// - `items`: Packages under review.
/// - `summary`: Preflight summary data.
/// - `header`: Header chips data.
/// - `dependency_info`: Dependency information.
/// - `cached_files`: Cached file information.
///
/// Output:
/// - Creates and sets the Preflight modal in app state.
fn create_preflight_modal_with_cache(
app: &mut AppState,
items: Vec<PackageItem>,
summary: crate::state::modal::PreflightSummaryData,
header: crate::state::modal::PreflightHeaderChips,
dependency_info: Vec<crate::state::modal::DependencyInfo>,
cached_files: Vec<crate::state::modal::PackageFileInfo>,
) {
app.modal = crate::state::Modal::Preflight {
items,
action: crate::state::PreflightAction::Install,
tab: crate::state::PreflightTab::Deps,
summary: Some(Box::new(summary)),
summary_scroll: 0,
header_chips: header,
dependency_info,
dep_selected: 0,
dep_tree_expanded: std::collections::HashSet::new(),
deps_error: None,
file_info: cached_files,
file_selected: 0,
file_tree_expanded: std::collections::HashSet::new(),
files_error: None,
service_info: Vec::new(),
service_selected: 0,
services_loaded: false,
services_error: None,
sandbox_info: Vec::new(),
sandbox_selected: 0,
sandbox_tree_expanded: std::collections::HashSet::new(),
sandbox_loaded: false,
sandbox_error: None,
selected_optdepends: std::collections::HashMap::new(),
cascade_mode: app.remove_cascade_mode,
cached_reverse_deps_report: None,
};
}
/// What: Create preflight modal for insert mode (background computation).
///
/// Inputs:
/// - `app`: Application state.
/// - `items`: Packages under review.
///
/// Output:
/// - Creates and sets the Preflight modal with background computation queued.
fn create_preflight_modal_insert_mode(app: &mut AppState, items: Vec<PackageItem>) {
let items_clone = items.clone();
app.preflight_cancelled
.store(false, std::sync::atomic::Ordering::Relaxed);
app.preflight_summary_items = Some((items_clone, crate::state::PreflightAction::Install));
app.preflight_summary_resolving = true;
app.pending_service_plan.clear();
app.modal = crate::state::Modal::Preflight {
items,
action: crate::state::PreflightAction::Install,
tab: crate::state::PreflightTab::Summary,
summary: None,
summary_scroll: 0,
header_chips: crate::state::modal::PreflightHeaderChips {
package_count: 1,
download_bytes: 0,
install_delta_bytes: 0,
aur_count: 0,
risk_score: 0,
risk_level: crate::state::modal::RiskLevel::Low,
},
dependency_info: Vec::new(),
dep_selected: 0,
dep_tree_expanded: std::collections::HashSet::new(),
deps_error: None,
file_info: Vec::new(),
file_selected: 0,
file_tree_expanded: std::collections::HashSet::new(),
files_error: None,
service_info: Vec::new(),
service_selected: 0,
services_loaded: false,
services_error: None,
sandbox_info: Vec::new(),
sandbox_selected: 0,
sandbox_tree_expanded: std::collections::HashSet::new(),
sandbox_loaded: false,
sandbox_error: None,
selected_optdepends: std::collections::HashMap::new(),
cascade_mode: app.remove_cascade_mode,
cached_reverse_deps_report: None,
};
}
/// What: Open preflight modal with cached dependencies and files, or trigger background resolution.
///
/// Inputs:
/// - `app`: Mutable application state
/// - `items`: Packages to open preflight for
/// - `use_cache`: Whether to use cached dependencies/files or trigger background resolution
///
/// Output:
/// - None (modifies app state directly)
///
/// Details:
/// - If `use_cache` is true, checks cache and uses cached data if available, otherwise triggers background resolution.
/// - If `use_cache` is false, always triggers background resolution (used in insert mode).
/// - Sets up all preflight resolution flags and initializes the modal state.
pub fn open_preflight_modal(app: &mut AppState, items: Vec<PackageItem>, use_cache: bool) {
if crate::theme::settings().skip_preflight {
// Direct install - check for reinstalls first, then batch updates
// First, check if we're installing packages that are already installed (reinstall scenario)
// BUT exclude packages that have updates available (those should go through normal update flow)
let installed_set = crate::logic::deps::get_installed_packages();
let provided_set = crate::logic::deps::get_provided_packages(&installed_set);
let upgradable_set = crate::logic::deps::get_upgradable_packages();
let installed_packages: Vec<crate::state::PackageItem> = items
.iter()
.filter(|item| {
// Check if package is installed or provided by an installed package
let is_installed = crate::logic::deps::is_package_installed_or_provided(
&item.name,
&installed_set,
&provided_set,
);
if !is_installed {
return false;
}
// Check if package has an update available
// For official packages: check if it's in upgradable_set OR version differs from installed
// For AUR packages: check if target version is different from installed version
let has_update = if upgradable_set.contains(&item.name) {
// Package is in upgradable set (pacman -Qu)
true
} else if !item.version.is_empty() {
// Normalize target version by removing revision suffix (same as installed version normalization)
let normalized_target_version =
item.version.split('-').next().unwrap_or(&item.version);
// Compare normalized target version with normalized installed version
// This works for both official and AUR packages
crate::logic::deps::get_installed_version(&item.name).is_ok_and(
|installed_version| normalized_target_version != installed_version,
)
} else {
// No version info available, no update
false
};
// Only show reinstall confirmation if installed AND no update available
// If update is available, it should go through normal update flow
!has_update
})
.cloned()
.collect();
if !installed_packages.is_empty() {
// Show reinstall confirmation modal
// Store both installed packages (for display) and all packages (for installation)
app.modal = crate::state::Modal::ConfirmReinstall {
items: installed_packages,
all_items: items,
header_chips: crate::state::modal::PreflightHeaderChips::default(),
};
return;
}
// Check if this is a batch update scenario requiring confirmation
// Only show if there's actually an update available (package is upgradable)
// AND the package has installed packages in its "Required By" field (dependency risk)
let has_versions = items.iter().any(|item| {
matches!(item.source, crate::state::Source::Official { .. }) && !item.version.is_empty()
});
let has_upgrade_available = items.iter().any(|item| {
matches!(item.source, crate::state::Source::Official { .. })
&& upgradable_set.contains(&item.name)
});
// Only show warning if package has installed packages in "Required By" (dependency risk)
let has_installed_required_by = items.iter().any(|item| {
matches!(item.source, crate::state::Source::Official { .. })
&& crate::index::is_installed(&item.name)
&& crate::logic::deps::has_installed_required_by(&item.name)
});
if has_versions && has_upgrade_available && has_installed_required_by {
// Show confirmation modal for batch updates (only if update is actually available
// AND package has installed dependents that could be affected)
app.modal = crate::state::Modal::ConfirmBatchUpdate {
items,
dry_run: app.dry_run,
};
return;
}
crate::install::start_integrated_install_all(app, &items, app.dry_run);
app.toast_message = Some(crate::i18n::t(app, "app.toasts.installing_skipped"));
app.toast_expires_at = Some(std::time::Instant::now() + std::time::Duration::from_secs(3));
return;
}
if use_cache {
// Reset cancellation flag when opening new preflight
app.preflight_cancelled
.store(false, std::sync::atomic::Ordering::Relaxed);
let crate::logic::preflight::PreflightSummaryOutcome {
summary,
header,
reverse_deps_report: _,
} = crate::logic::preflight::compute_preflight_summary(
&items,
crate::state::PreflightAction::Install,
);
app.pending_service_plan.clear();
let item_names: std::collections::HashSet<String> =
items.iter().map(|i| i.name.clone()).collect();
let cached_deps = filter_cached_dependencies(app, &item_names);
let cached_files = filter_cached_files(app, &item_names);
let dependency_info = if cached_deps.is_empty() {
tracing::debug!(
"[Preflight] Cache empty, will trigger background dependency resolution for {} packages",
items.len()
);
Vec::new()
} else {
cached_deps
};
trigger_background_resolution(app, &items, &dependency_info, &cached_files);
create_preflight_modal_with_cache(
app,
items,
summary,
header,
dependency_info,
cached_files,
);
} else {
create_preflight_modal_insert_mode(app, items);
}
app.toast_message = Some(if use_cache {
crate::i18n::t(app, "app.toasts.preflight_opened")
} else {
"Preflight opened".to_string()
});
app.toast_expires_at = Some(std::time::Instant::now() + std::time::Duration::from_secs(2));
}
#[cfg(test)]
mod tests {
use super::*;
/// What: Provide a baseline `AppState` for preflight helper tests.
///
/// Inputs: None
///
/// Output: Fresh `AppState` with default values.
fn new_app() -> AppState {
AppState::default()
}
/// What: Create a test package item for testing.
///
/// Inputs:
/// - `name`: Package name
///
/// Output: A test `PackageItem` with official source.
fn test_package(name: &str) -> PackageItem {
PackageItem {
name: name.to_string(),
version: "1.0.0".to_string(),
description: "Test package".to_string(),
source: crate::state::Source::Official {
repo: "extra".to_string(),
arch: "x86_64".to_string(),
},
popularity: None,
out_of_date: None,
orphaned: false,
}
}
#[test]
/// What: Verify that `trigger_background_resolution` sets resolution flags correctly.
///
/// Inputs:
/// - App state
/// - Empty `dependency_info` and `cached_files`
///
/// Output:
/// - Resolution flags and items are set
///
/// Details:
/// - Tests that background resolution is properly triggered when caches are empty.
fn trigger_background_resolution_sets_flags_when_cache_empty() {
let mut app = new_app();
let items = vec![test_package("test-pkg")];
trigger_background_resolution(&mut app, &items, &[], &[]);
// Flags should be set
assert!(app.preflight_deps_resolving);
assert!(app.preflight_files_resolving);
assert!(app.preflight_services_resolving);
// Items should be queued
assert!(app.preflight_deps_items.is_some());
assert!(app.preflight_files_items.is_some());
assert!(app.preflight_services_items.is_some());
}
#[test]
/// What: Verify that `trigger_background_resolution` does not set deps flag when cache has deps.
///
/// Inputs:
/// - App state
/// - Non-empty `dependency_info`
///
/// Output:
/// - Deps resolution flag and items are not set
///
/// Details:
/// - Tests that existing cached deps prevent re-resolution.
fn trigger_background_resolution_skips_deps_when_cached() {
let mut app = new_app();
let items = vec![test_package("test-pkg")];
let cached_deps = vec![crate::state::modal::DependencyInfo {
name: "cached-dep".to_string(),
version: "1.0".to_string(),
status: crate::state::modal::DependencyStatus::ToInstall,
source: crate::state::modal::DependencySource::Official {
repo: "extra".to_string(),
},
required_by: vec!["test-pkg".to_string()],
depends_on: Vec::new(),
is_core: false,
is_system: false,
}];
trigger_background_resolution(&mut app, &items, &cached_deps, &[]);
// Deps should not be triggered (cache has data)
assert!(!app.preflight_deps_resolving);
assert!(app.preflight_deps_items.is_none());
// Files should still be triggered (cache empty)
assert!(app.preflight_files_resolving);
assert!(app.preflight_files_items.is_some());
}
#[test]
/// What: Verify `create_preflight_modal_insert_mode` resets `preflight_cancelled` flag.
///
/// Inputs:
/// - App state with `preflight_cancelled` set to true
///
/// Output:
/// - `preflight_cancelled` is reset to false
///
/// Details:
/// - Tests the insert mode path resets the cancellation flag.
fn create_preflight_modal_insert_mode_resets_cancelled() {
let mut app = new_app();
app.preflight_cancelled
.store(true, std::sync::atomic::Ordering::Relaxed);
let items = vec![test_package("test-pkg")];
create_preflight_modal_insert_mode(&mut app, items);
// Cancelled flag should be reset
assert!(
!app.preflight_cancelled
.load(std::sync::atomic::Ordering::Relaxed)
);
}
#[test]
/// What: Verify `filter_cached_dependencies` returns only matching deps.
///
/// Inputs:
/// - App state with cached dependencies
/// - Set of item names to filter by
///
/// Output:
/// - Only dependencies matching the item names are returned
///
/// Details:
/// - Tests that dependency filtering works correctly.
fn filter_cached_dependencies_returns_matching() {
let mut app = new_app();
app.install_list_deps = vec![
crate::state::modal::DependencyInfo {
name: "dep-a".to_string(),
version: "1.0".to_string(),
status: crate::state::modal::DependencyStatus::ToInstall,
source: crate::state::modal::DependencySource::Official {
repo: "extra".to_string(),
},
required_by: vec!["pkg-a".to_string()],
depends_on: Vec::new(),
is_core: false,
is_system: false,
},
crate::state::modal::DependencyInfo {
name: "dep-b".to_string(),
version: "1.0".to_string(),
status: crate::state::modal::DependencyStatus::ToInstall,
source: crate::state::modal::DependencySource::Official {
repo: "extra".to_string(),
},
required_by: vec!["pkg-b".to_string()],
depends_on: Vec::new(),
is_core: false,
is_system: false,
},
];
let mut item_names = std::collections::HashSet::new();
item_names.insert("pkg-a".to_string());
let result = filter_cached_dependencies(&app, &item_names);
assert_eq!(result.len(), 1);
assert_eq!(result[0].name, "dep-a");
}
#[test]
/// What: Verify `filter_cached_files` returns only matching files.
///
/// Inputs:
/// - App state with cached file info
/// - Set of item names to filter by
///
/// Output:
/// - Only file info matching the item names are returned
///
/// Details:
/// - Tests that file filtering works correctly.
fn filter_cached_files_returns_matching() {
let mut app = new_app();
app.install_list_files = vec![
crate::state::modal::PackageFileInfo {
name: "pkg-a".to_string(),
files: vec![crate::state::modal::FileChange {
path: "/usr/bin/a".to_string(),
change_type: crate::state::modal::FileChangeType::New,
package: "pkg-a".to_string(),
is_config: false,
predicted_pacnew: false,
predicted_pacsave: false,
}],
total_count: 1,
new_count: 1,
changed_count: 0,
removed_count: 0,
config_count: 0,
pacnew_candidates: 0,
pacsave_candidates: 0,
},
crate::state::modal::PackageFileInfo {
name: "pkg-b".to_string(),
files: vec![crate::state::modal::FileChange {
path: "/usr/bin/b".to_string(),
change_type: crate::state::modal::FileChangeType::New,
package: "pkg-b".to_string(),
is_config: false,
predicted_pacnew: false,
predicted_pacsave: false,
}],
total_count: 1,
new_count: 1,
changed_count: 0,
removed_count: 0,
config_count: 0,
pacnew_candidates: 0,
pacsave_candidates: 0,
},
];
let mut item_names = std::collections::HashSet::new();
item_names.insert("pkg-a".to_string());
let result = filter_cached_files(&app, &item_names);
assert_eq!(result.len(), 1);
assert_eq!(result[0].name, "pkg-a");
}
}
| rust | MIT | c433ad6a837b7985d8b99ba9afd8f07a93d046f4 | 2026-01-04T20:14:32.225407Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.