termi 0.1.1

A modal terminal code editor written in Rust
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

//! `termi` — a modern, modular terminal code editor.
//!
//! The crate is split into layers that only depend downwards:
//!
//! - [`app`] drives the event loop and owns the state
//! - [`ui`] renders that state; [`renderer`] owns the terminal
//! - [`input`] turns keys into actions
//! - [`editor`] manipulates text and knows nothing about either
//! - [`config`], [`theme`], [`syntax`], [`search`], [`undo`], [`clipboard`] and
//!   [`filesystem`] are leaf services used by the layers above

mod app;
mod clipboard;
mod config;
mod editor;
mod filesystem;
mod input;
mod renderer;
mod search;
mod syntax;
mod theme;
mod ui;
mod undo;

use std::path::PathBuf;
use std::process::ExitCode;

use anyhow::Result;

const USAGE: &str = "\
termi — a terminal code editor

USAGE:
    termi [OPTIONS] [FILE]...

OPTIONS:
    -h, --help       Print this message
    -V, --version    Print the version

Configuration lives in <config-dir>/termi/config.toml, and themes in
<config-dir>/termi/themes/<name>.toml.";

fn main() -> ExitCode {
    match parse_arguments() {
        Arguments::Help => {
            println!("{USAGE}");
            ExitCode::SUCCESS
        }
        Arguments::Version => {
            println!("termi {}", env!("CARGO_PKG_VERSION"));
            ExitCode::SUCCESS
        }
        Arguments::Open(files) => match edit(files) {
            Ok(()) => ExitCode::SUCCESS,
            Err(error) => {
                // The terminal is already restored by this point, so a plain
                // stderr message is safe and is what a shell expects.
                eprintln!("termi: {error:#}");
                ExitCode::FAILURE
            }
        },
    }
}

/// What the command line asked for.
enum Arguments {
    Help,
    Version,
    Open(Vec<PathBuf>),
}

/// Parse `argv` by hand.
///
/// The editor takes two flags and a list of files; a full argument parser would
/// be more dependency than feature.
fn parse_arguments() -> Arguments {
    let mut files = Vec::new();
    for argument in std::env::args_os().skip(1) {
        match argument.to_str() {
            Some("-h" | "--help") => return Arguments::Help,
            Some("-V" | "--version") => return Arguments::Version,
            _ => files.push(PathBuf::from(argument)),
        }
    }
    Arguments::Open(files)
}

/// Set up the terminal, run the editor, and tear the terminal down again.
fn edit(files: Vec<PathBuf>) -> Result<()> {
    renderer::install_panic_hook();

    let mut editor = app::App::new();
    for file in files {
        // A file that cannot be opened is reported in the status bar rather than
        // aborting startup — the other files should still open.
        if let Err(error) = editor.open(file) {
            editor.error(error.to_string());
        }
    }

    let mut tui = renderer::Tui::new()?;
    let result = app::run(&mut editor, &mut tui);
    drop(tui);
    result
}