rff 0.3.0

rff is a fast, simple fuzzy text selector for the terminal.
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

use std::fmt::{Display, Formatter, Result};

/// Move the cursor to (row, col) position [(1, 1)-based]
#[derive(Copy, Clone)]
pub struct GoTo(pub u16, pub u16);

impl Display for GoTo {
    fn fmt(&self, f: &mut Formatter) -> Result {
        debug_assert!(self.0 > 0 && self.1 > 0, "ANSI coordinates are 1-based");
        write!(f, csi!("{};{}H"), self.0, self.1)
    }
}

/// Move the cursor up N rows
generate_csi_struct!(Up, "A", u16);

/// Move the cursor down N rows
generate_csi_struct!(Down, "B", u16);

/// Move the cursor left N columns
generate_csi_struct!(Left, "D", u16);

/// Move the cursor right N columns
generate_csi_struct!(Right, "C", u16);

/// Move the cursor up N lines, and to the beginning of the line
generate_csi_struct!(UpLine, "F", u16);

/// Move the cursor down N lines, and to the beginning of the line
generate_csi_struct!(DownLine, "E", u16);

/// Set cursor column
#[derive(Copy, Clone)]
pub struct Column(pub u16);

impl Display for Column {
    fn fmt(&self, f: &mut Formatter) -> Result {
        debug_assert!(self.0 > 0, "ANSI coordinates are 1-based");
        write!(f, csi!("{}G"), self.0)
    }
}

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

    #[test]
    fn goto() {
        let s = format!("{}", GoTo(1, 2));
        assert_eq!(s, "\x1b[1;2H");
    }

    #[test]
    fn up() {
        let s = format!("{}", Up(2));
        assert_eq!(s, "\x1b[2A");
    }

    #[test]
    fn down() {
        let s = format!("{}", Down(2));
        assert_eq!(s, "\x1b[2B");
    }

    #[test]
    fn left() {
        let s = format!("{}", Left(2));
        assert_eq!(s, "\x1b[2D");
    }

    #[test]
    fn right() {
        let s = format!("{}", Right(2));
        assert_eq!(s, "\x1b[2C");
    }

    #[test]
    fn up_line() {
        let s = format!("{}", UpLine(2));
        assert_eq!(s, "\x1b[2F");
    }

    #[test]
    fn down_line() {
        let s = format!("{}", DownLine(2));
        assert_eq!(s, "\x1b[2E");
    }

    #[test]
    fn column() {
        let s = format!("{}", Column(1));
        assert_eq!(s, "\x1b[1G");
    }
}