rsvim_core 0.1.1-alpha.10

The core library for RSVIM text editor.
Documentation 
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

//! Command line.

use clap::Parser;

// #[clap(
//   value_name = "CMD",
//   long = "cmd",
//   help = "Execute <CMD> before loading any config"
// )]
// cmd_before: Option<Vec<String>>,
//
// #[clap(
//   value_name = "CMD",
//   short = 'c',
//   help = "Execute <CMD> after loading config and first file"
// )]
// cmd_after: Option<Vec<String>>,
//
// #[arg(short = 'd', long, help = "Run in diff mode")]
// diff: bool,
//
// #[arg(long, help = "Run in headless mode, without a user interface")]
// headless: bool,
//
// #[arg(long, help = "Run in verbose mode")]
// verbose: bool,
//
// #[arg(long, help = "Run in debug mode")]
// debug: bool,

const ABOUT: &str = "The VIM editor reinvented in Rust+TypeScript.";

#[derive(Parser, Debug, Clone, Default)]
#[command(
  disable_version_flag = true,
  about = ABOUT,
  long_about = ABOUT,
)]
/// Command line options.
pub struct CliOpt {
  #[arg(short = 'V', long = "version", help = "Print version")]
  version: bool,

  #[arg(help = "Edit file(s)")]
  file: Vec<String>,
}

impl CliOpt {
  /// Input files.
  pub fn file(&self) -> &Vec<String> {
    &self.file
  }

  /// Version.
  pub fn version(&self) -> bool {
    self.version
  }

  // /// Commands should be execute before loading any config.
  // pub fn cmd_before(&self) -> &Option<Vec<String>> {
  //   &self.cmd_before
  // }
  //
  // /// Commands should be execute after loading any config and first line.
  // pub fn cmd_after(&self) -> &Option<Vec<String>> {
  //   &self.cmd_after
  // }
  //
  // /// Run in diff mode.
  // pub fn diff(&self) -> bool {
  //   self.diff
  // }
  //
  // /// Run in headless mode, without TUI.
  // pub fn headless(&self) -> bool {
  //   self.headless
  // }
  //
  // /// Run in verbose mode.
  // pub fn verbose(&self) -> bool {
  //   self.verbose
  // }
  //
  // /// Run in debug mode.
  // pub fn debug(&self) -> bool {
  //   self.debug
  // }
}

#[cfg(test)]
mod tests {
  use super::*;

  #[test]
  fn cli_opt1() {
    let input = [
      vec!["rsvim".to_string()],
      vec!["rsvim".to_string(), "--version".to_string()],
      vec!["rsvim".to_string(), "README.md".to_string()],
    ];

    let expect = [
      CliOpt {
        file: vec![],
        version: false,
      },
      CliOpt {
        file: vec![],
        version: true,
      },
      CliOpt {
        file: vec!["README.md".to_string()],
        version: false,
      },
    ];

    assert_eq!(input.len(), expect.len());
    let n = input.len();
    for i in 0..n {
      let actual = CliOpt::parse_from(&input[i]);
      assert_eq!(actual.file, expect[i].file);
      assert_eq!(actual.version(), expect[i].version());
    }
  }
}