sastri 0.1.0

Scaffold multi-ecosystem packaging and CI/CD for Rust CLIs (Homebrew, Scoop, PyPI, npm, Hex, mise, asdf, …)
Documentation
//! Progress UI while mechanisms generate files.

use std::io::{self, stdout};
use std::time::Duration;

use anyhow::Result;
use crossterm::event::{self, Event, KeyCode};
use crossterm::execute;
use crossterm::terminal::{
    disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen,
};
use ratatui::prelude::*;
use ratatui::widgets::{Block, Borders, Gauge, List, ListItem, Paragraph};

#[derive(Debug, Clone)]
pub struct ProgressState {
    pub title: String,
    pub total: usize,
    pub done: usize,
    pub current: String,
    pub log: Vec<String>,
    pub finished: bool,
}

impl ProgressState {
    pub fn new(title: impl Into<String>, total: usize) -> Self {
        Self {
            title: title.into(),
            total,
            done: 0,
            current: String::new(),
            log: Vec::new(),
            finished: false,
        }
    }

    pub fn ratio(&self) -> f64 {
        if self.total == 0 {
            1.0
        } else {
            self.done as f64 / self.total as f64
        }
    }
}

/// Run a TUI that polls `update` until it returns Ok(true) (finished).
pub fn run_progress<F>(mut update: F) -> Result<()>
where
    F: FnMut(&mut ProgressState) -> Result<bool>,
{
    enable_raw_mode()?;
    let mut out = stdout();
    execute!(out, EnterAlternateScreen)?;
    let mut terminal = Terminal::new(CrosstermBackend::new(out))?;

    let mut state = ProgressState::new("sastri generate", 1);
    let result = (|| -> Result<()> {
        loop {
            let finished = update(&mut state)?;
            terminal.draw(|frame| draw(frame, &state))?;

            if finished {
                state.finished = true;
                terminal.draw(|frame| draw(frame, &state))?;
                // brief pause so the user sees 100%
                if event::poll(Duration::from_millis(800))? {
                    let _ = event::read()?;
                }
                break;
            }

            if event::poll(Duration::from_millis(16))? {
                if let Event::Key(key) = event::read()? {
                    if key.code == KeyCode::Char('q') || key.code == KeyCode::Esc {
                        break;
                    }
                }
            }
        }
        Ok(())
    })();

    disable_raw_mode()?;
    execute!(terminal.backend_mut(), LeaveAlternateScreen)?;
    terminal.show_cursor()?;
    result
}

fn draw(frame: &mut Frame, state: &ProgressState) {
    let area = frame.area();
    let chunks = Layout::default()
        .direction(Direction::Vertical)
        .constraints([
            Constraint::Length(3),
            Constraint::Length(3),
            Constraint::Min(5),
            Constraint::Length(2),
        ])
        .split(area);

    let title = Paragraph::new(state.title.as_str())
        .block(Block::default().borders(Borders::ALL).title("sastri"));
    frame.render_widget(title, chunks[0]);

    let label = format!("{}/{}  {}", state.done, state.total, state.current);
    let gauge = Gauge::default()
        .block(Block::default().borders(Borders::ALL).title("progress"))
        .gauge_style(Style::default().fg(Color::Cyan))
        .ratio(state.ratio().clamp(0.0, 1.0))
        .label(label);
    frame.render_widget(gauge, chunks[1]);

    let items: Vec<ListItem> = state
        .log
        .iter()
        .rev()
        .take(chunks[2].height.saturating_sub(2) as usize)
        .map(|line| ListItem::new(line.as_str()))
        .collect();
    let list = List::new(items).block(Block::default().borders(Borders::ALL).title("log"));
    frame.render_widget(list, chunks[2]);

    let hint = if state.finished {
        "done — press any key"
    } else {
        "generating…  q/esc to abort view"
    };
    frame.render_widget(
        Paragraph::new(hint).block(Block::default().borders(Borders::ALL)),
        chunks[3],
    );
}

/// Non-TUI fallback using indicatif.
pub fn run_spinner_list(steps: &[String], mut each: impl FnMut(usize) -> Result<()>) -> Result<()> {
    use indicatif::{ProgressBar, ProgressStyle};
    let pb = ProgressBar::new(steps.len() as u64);
    pb.set_style(
        ProgressStyle::with_template("{spinner:.cyan} [{bar:40}] {pos}/{len} {msg}")?
            .progress_chars("=>-"),
    );
    for (i, name) in steps.iter().enumerate() {
        pb.set_message(name.clone());
        each(i)?;
        pb.inc(1);
    }
    pb.finish_with_message("done");
    let _ = io::Write::flush(&mut io::stderr());
    Ok(())
}