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
|
use std::collections::HashMap;
use std::fs::File;
use std::io::{self, BufRead, BufWriter, Write};
use std::path::{Path, PathBuf};
use crate::fm_error::{ErrorVariant, FmError, FmResult};
static MARKS_FILEPATH: &str = "~/.config/fm/marks.cfg";
/// Holds the marks created by the user.
/// It's a map between any char (except :) and a PathBuf.
pub struct Marks {
save_path: PathBuf,
marks: HashMap<char, PathBuf>,
}
impl Marks {
/// Reads the marks stored in the config file (~/.config/fm/marks.cfg).
/// If an invalid marks is read, only the valid ones are kept
/// and the file is saved again.
pub fn read_from_config_file() -> Self {
let path = PathBuf::from(shellexpand::tilde(&MARKS_FILEPATH).to_string());
Self::read_from_file(path)
}
fn read_from_file(save_path: PathBuf) -> Self {
let mut marks = HashMap::new();
let mut must_save = false;
if let Ok(lines) = read_lines(&save_path) {
for line in lines {
if let Ok((ch, path)) = Self::parse_line(line) {
marks.insert(ch, path);
} else {
must_save = true;
}
}
}
let marks = Self { save_path, marks };
if must_save {
eprintln!("Wrong marks found, will save it again");
let _ = marks.save_marks();
}
marks
}
/// Returns an optional marks associated to a char bind.
pub fn get(&self, ch: char) -> Option<&PathBuf> {
self.marks.get(&ch)
}
fn parse_line(line: Result<String, io::Error>) -> FmResult<(char, PathBuf)> {
let line = line?;
let sp: Vec<&str> = line.split(':').collect();
if sp.len() <= 1 {
return Err(FmError::new(
ErrorVariant::CUSTOM("marks: parse_line".to_owned()),
"Invalid mark line",
));
}
if let Some(ch) = sp[0].chars().next() {
let path = PathBuf::from(sp[1]);
Ok((ch, path))
} else {
Err(FmError::new(
ErrorVariant::CUSTOM("marks: parse line".to_owned()),
"Invalid char",
))
}
}
/// Store a new mark in the config file.
/// All the marks are saved again.
pub fn new_mark(&mut self, ch: char, path: PathBuf) -> FmResult<()> {
if ch == ':' {
return Err(FmError::new(
ErrorVariant::CUSTOM("new_mark".to_owned()),
"':' can't be used as a mark",
));
}
self.marks.insert(ch, path);
self.save_marks()
}
fn save_marks(&self) -> FmResult<()> {
let file = std::fs::File::create(&self.save_path)?;
let mut buf = BufWriter::new(file);
for (ch, path) in self.marks.iter() {
writeln!(buf, "{}:{}", ch, Self::path_as_string(path)?)?;
}
Ok(())
}
fn path_as_string(path: &Path) -> FmResult<String> {
Ok(path
.to_str()
.ok_or_else(|| {
FmError::new(
ErrorVariant::CUSTOM("path_as_string".to_owned()),
"Unreadable path",
)
})?
.to_owned())
}
/// Returns a vector of strings like "d: /dev" for every mark.
pub fn as_strings(&self) -> Vec<String> {
self.marks
.iter()
.map(|(ch, path)| Self::format_mark(ch, path))
.collect()
}
fn format_mark(ch: &char, path: &Path) -> String {
format!("{} {}", ch, path.to_string_lossy())
}
}
fn read_lines<P>(filename: P) -> io::Result<io::Lines<io::BufReader<File>>>
where
P: AsRef<Path>,
{
let file = File::open(filename)?;
Ok(io::BufReader::new(file).lines())
}
|
