rclean-cli 0.2.0

Find and safely clean rebuildable developer artifacts across local workspaces
use super::process::process_matches_tool;
use super::types::{AgentTool, PowerAssertion, PowerReport};

pub(super) fn parse_pmset_assertions(tool: AgentTool, output: &str) -> PowerReport {
    let all_assertions: Vec<PowerAssertion> = output
        .lines()
        .filter_map(parse_pmset_assertion_line)
        .collect();
    let assertions: Vec<PowerAssertion> = all_assertions
        .into_iter()
        .filter(|assertion| process_matches_tool(tool, &assertion.process))
        .collect();
    let agent_blocks_display_sleep = assertions
        .iter()
        .any(|assertion| assertion.kind.contains("NoDisplaySleep"));

    PowerReport {
        supported: true,
        prevent_user_idle_display_sleep: parse_pmset_summary_bool(
            output,
            "PreventUserIdleDisplaySleep",
        ),
        prevent_user_idle_system_sleep: parse_pmset_summary_bool(
            output,
            "PreventUserIdleSystemSleep",
        ),
        agent_blocks_display_sleep,
        assertions,
    }
}

fn parse_pmset_summary_bool(output: &str, key: &str) -> Option<bool> {
    output.lines().find_map(|line| {
        let trimmed = line.trim();
        if !trimmed.starts_with(key) {
            return None;
        }
        trimmed.split_whitespace().last().map(|value| value == "1")
    })
}

fn parse_pmset_assertion_line(line: &str) -> Option<PowerAssertion> {
    let trimmed = line.trim();
    let rest = trimmed.strip_prefix("pid ")?;
    let (pid_text, after_pid) = rest.split_once('(')?;
    let (process, after_process) = after_pid.split_once("):")?;
    let pid = pid_text.parse().ok()?;
    let after_bracket = after_process
        .split_once(']')
        .map(|(_, suffix)| suffix.trim())
        .unwrap_or(after_process.trim());
    let mut parts = after_bracket.split_whitespace();
    let age = parts.next().map(str::to_string);
    let kind = parts.next().unwrap_or("").to_string();
    let name = after_bracket
        .split_once("named:")
        .map(|(_, name)| name.trim().trim_matches('"').to_string())
        .filter(|name| !name.is_empty());

    Some(PowerAssertion {
        pid,
        process: process.to_string(),
        age,
        kind,
        name,
    })
}

pub(super) fn parse_defaults_bool(output: &str, key: &str) -> Option<bool> {
    output.lines().find_map(|line| {
        let trimmed = line.trim();
        if !trimmed.starts_with(key) {
            return None;
        }
        let (_, value) = trimmed.split_once('=')?;
        match value.trim().trim_end_matches(';') {
            "1" | "true" | "TRUE" | "YES" => Some(true),
            "0" | "false" | "FALSE" | "NO" => Some(false),
            _ => None,
        }
    })
}

pub(super) fn parse_defaults_string(output: &str, key: &str) -> Option<String> {
    output.lines().find_map(|line| {
        let trimmed = line.trim();
        if !trimmed.starts_with(key) {
            return None;
        }
        let (_, value) = trimmed.split_once('=')?;
        Some(
            value
                .trim()
                .trim_end_matches(';')
                .trim_matches('"')
                .to_string(),
        )
        .filter(|value| !value.is_empty())
    })
}