127 lines
3.6 KiB
Rust
127 lines
3.6 KiB
Rust
use std::io::Write;
|
|
use std::str;
|
|
use std::fs::File;
|
|
use std::fs::OpenOptions;
|
|
use std::io::{prelude::*, BufReader};
|
|
|
|
|
|
pub fn write_to_history(command: &str) -> Result<(), std::io::Error> {
|
|
//Write a command to history
|
|
let filepath = dirs::home_dir().unwrap().join(".history.sqish");
|
|
let mut file = OpenOptions::new()
|
|
.write(true)
|
|
.append(true)
|
|
.create(true)
|
|
.open(&filepath)?;
|
|
|
|
|
|
let number = match get_history_number() {
|
|
Ok(n) => n + 1,
|
|
Err(_) => 1
|
|
};
|
|
|
|
let command = command.replace('\n', "\\n");
|
|
|
|
writeln!(file, "{} {}", number, command.trim())?;
|
|
return Ok(())
|
|
}
|
|
|
|
pub fn get_history_number() -> Result<i32, std::io::Error> {
|
|
//Get the latest number found in history file
|
|
let filepath = dirs::home_dir().unwrap().join(".history.sqish");
|
|
let file = File::open(filepath)?;
|
|
let reader = BufReader::new(file).lines();
|
|
let myline = String::from(reader.last().unwrap_or(Ok(String::from("1")))?);
|
|
let number = myline.split(' ').next().expect("???").parse().unwrap();
|
|
return Ok(number);
|
|
}
|
|
|
|
pub fn get_curr_history_number() -> i32 {
|
|
//Returns CURRENT history number, AKA the one for the command we are typing
|
|
let mynumber = match get_history_number() {
|
|
Ok(n) => n + 1,
|
|
Err(_) => 1,
|
|
};
|
|
|
|
return mynumber;
|
|
}
|
|
|
|
pub fn get_history() -> Result<String, std::io::Error> {
|
|
let filepath = dirs::home_dir().unwrap().join(".history.sqish");
|
|
let file = File::open(filepath)?;
|
|
let contents = BufReader::new(file).lines();
|
|
let mut res = String::new();
|
|
for line in contents {
|
|
let myline = format!("\r\n{}", line.unwrap());
|
|
res.push_str(&myline);
|
|
}
|
|
res.push_str("\r\n");
|
|
return Ok(res);
|
|
}
|
|
|
|
pub fn get_hist_from_number(number: &i32) -> Option<String> {
|
|
//Returns a command from its number in hist file
|
|
let filepath = dirs::home_dir().unwrap().join(".history.sqish");
|
|
|
|
if filepath.exists() == false {
|
|
return None;
|
|
}
|
|
|
|
let file = File::open(filepath)
|
|
.expect("Error opening history file...");
|
|
|
|
if file.metadata().unwrap().len() < 1 {
|
|
return None;
|
|
}
|
|
|
|
let reader = BufReader::new(file).lines();
|
|
|
|
for line in reader {
|
|
let current_line = line
|
|
.expect("Empty history file ? Please rm it");
|
|
let mut s = current_line.split_whitespace();
|
|
let n: i32 = s.next()
|
|
.expect("Error reading a line in hist file")
|
|
.parse()
|
|
.unwrap();
|
|
//let c = s.next().expect("No command!");
|
|
if &n == number {
|
|
let remainder: String = s.map(|c| c.to_string()).collect::<Vec<_>>().join(" ");
|
|
return Some(String::from(remainder));
|
|
}
|
|
}
|
|
return None;
|
|
}
|
|
|
|
pub fn treat_history_callback(line: &str) -> Option<String> {
|
|
let mut mystring = String::from(line);
|
|
let temp = mystring.split_whitespace().collect::<Vec<&str>>();
|
|
let mystring = temp.first().unwrap_or(&line);
|
|
let mut chars = mystring.chars();
|
|
let args = &temp[1..];
|
|
//Skip the !
|
|
chars.next();
|
|
let mynbr: i32 = chars.as_str().parse().unwrap();
|
|
match get_hist_from_number(&mynbr) {
|
|
Some(h) => return Some(format!("{} {}", h, args.join(" "))),
|
|
None => return None,
|
|
}
|
|
}
|
|
|
|
pub fn get_prev_arg() -> Option<String> {
|
|
let nbr = get_history_number();
|
|
match nbr {
|
|
Ok(r) => {
|
|
let prev_cmd = get_hist_from_number(&r).unwrap_or(String::new());
|
|
let last_arg = prev_cmd.split_whitespace().last().unwrap();
|
|
return Some(String::from(last_arg));
|
|
},
|
|
Err(_) => {
|
|
return None
|
|
},
|
|
};
|
|
}
|
|
|
|
|
|
|