lightshuttle 0.3.0

Lightweight developer-time orchestrator for polyglot teams
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

//! `lightshuttle alias`: manage the optional `lsh` shell alias.
//!
//! The command is split into a pure planner ([`plan`]) and a side
//! effecting layer ([`apply`]); this module wires them to the CLI and
//! owns the interactive confirmation and user-facing output.

mod apply;
mod plan;
pub(crate) mod shell;

use anyhow::{Result, anyhow};

use self::plan::AliasPlan;
use self::shell::Shell;
use super::ExitOutcome;
use crate::cli::AliasAction;

/// Entry point dispatched from `main::run`.
pub(crate) fn run(action: &AliasAction) -> Result<ExitOutcome> {
    match *action {
        AliasAction::Install { shell, yes } => install(shell, yes),
        AliasAction::Check { shell } => check(shell),
        AliasAction::Uninstall { shell, yes } => uninstall(shell, yes),
    }
}

fn install(shell: Option<Shell>, yes: bool) -> Result<ExitOutcome> {
    let shell = resolve_shell(shell)?;
    let path = apply::rc_path(shell)?;
    let contents = apply::read_rc(&path)?;

    match plan::plan_install(&contents, apply::lsh_on_path()) {
        AliasPlan::Conflict { reason } => Err(anyhow!(reason)),
        AliasPlan::AlreadyPresent => {
            println!(
                "ok: `lsh` alias already present in {} ({})",
                path.display(),
                shell.label()
            );
            Ok(ExitOutcome::Success)
        }
        AliasPlan::WillAdd => {
            let line = shell.alias_line();
            println!("Detected shell: {}", shell.label());
            println!("Will add `{line}` to {}", path.display());
            if !yes && !apply::confirm("Proceed?")? {
                println!("aborted: nothing was written");
                return Ok(ExitOutcome::Success);
            }
            let updated = plan::with_block_added(&contents, &line);
            apply::write_rc(&path, &updated)?;
            println!(
                "ok: added `lsh` alias. Restart your shell or reload {}",
                path.display()
            );
            Ok(ExitOutcome::Success)
        }
        AliasPlan::WillRemove | AliasPlan::NotPresent => {
            unreachable!("install never plans removal")
        }
    }
}

fn check(shell: Option<Shell>) -> Result<ExitOutcome> {
    let shell = resolve_shell(shell)?;
    let path = apply::rc_path(shell)?;
    let contents = apply::read_rc(&path)?;

    match plan::plan_install(&contents, apply::lsh_on_path()) {
        AliasPlan::Conflict { reason } => {
            println!("conflict: {reason}");
            Ok(ExitOutcome::Success)
        }
        AliasPlan::AlreadyPresent => {
            println!(
                "present: `lsh` alias is installed in {} ({})",
                path.display(),
                shell.label()
            );
            Ok(ExitOutcome::Success)
        }
        AliasPlan::WillAdd => {
            println!(
                "absent: `install` would add `{}` to {} ({})",
                shell.alias_line(),
                path.display(),
                shell.label()
            );
            Ok(ExitOutcome::Success)
        }
        AliasPlan::WillRemove | AliasPlan::NotPresent => unreachable!("check uses plan_install"),
    }
}

fn uninstall(shell: Option<Shell>, yes: bool) -> Result<ExitOutcome> {
    let shell = resolve_shell(shell)?;
    let path = apply::rc_path(shell)?;
    let contents = apply::read_rc(&path)?;

    match plan::plan_uninstall(&contents) {
        AliasPlan::NotPresent => {
            println!(
                "ok: no `lsh` alias in {} ({})",
                path.display(),
                shell.label()
            );
            Ok(ExitOutcome::Success)
        }
        AliasPlan::WillRemove => {
            println!("Will remove the `lsh` alias from {}", path.display());
            if !yes && !apply::confirm("Proceed?")? {
                println!("aborted: nothing was written");
                return Ok(ExitOutcome::Success);
            }
            let updated = plan::with_block_removed(&contents);
            apply::write_rc(&path, &updated)?;
            println!("ok: removed `lsh` alias from {}", path.display());
            Ok(ExitOutcome::Success)
        }
        AliasPlan::AlreadyPresent | AliasPlan::WillAdd | AliasPlan::Conflict { .. } => {
            unreachable!("uninstall uses plan_uninstall")
        }
    }
}

/// Resolve the shell from an explicit `--shell` flag, falling back to
/// auto-detection. Errors with guidance when detection fails.
fn resolve_shell(flag: Option<Shell>) -> Result<Shell> {
    flag.or_else(Shell::detect).ok_or_else(|| {
        anyhow!("could not determine your shell; pass `--shell <bash|zsh|fish|powershell>`")
    })
}