Add time pre-filter as argument

Author: tuplecats

README.md

@@ -18,7 +18,11 @@ cargo install --git https://github.com/tuplecats/1c-log-viewer
 ### Параметры
 ````
 -d, --directory=PATH       Путь к директории с файлами логов 
-                           (Также ищет файлы в поддиректориях)
+                           (Также ищет файлы в поддиректориях) 
+                                                     
+--from=TIME                Временая точка начала чтения логов.
+                           Формат: now-{digit}{s/m/h/d/w}
+                           Пример: now-1d или now-30s
 ````
 
 ````bash

src/app.rs

@@ -1,6 +1,7 @@
 use std::{error::Error, time::Duration};
 use std::cell::RefCell;
 use std::rc::Rc;
+use chrono::NaiveDateTime;
 use crossterm::{
     event,
     event::{Event, KeyCode},
@@ -30,9 +31,6 @@ enum ActiveWidget {
 }
 
 pub struct App {
-    // parse info
-    pub filepath: String,
-
     pub table: Rc<RefCell<TableView>>,
     pub search: Rc<RefCell<LineEdit>>,
     pub text: Rc<RefCell<KeyValueView>>,
@@ -44,14 +42,26 @@ pub struct App {
 }
 
 impl App {
-    pub fn new<T: Into<String>>(dir: T, widths: Vec<Constraint>) -> Self {
+    pub fn new<T: Into<String>>(dir: T, date: Option<NaiveDateTime>) -> Self {
         let dir = dir.into();
-        let log_data = Rc::new(RefCell::new(LogCollection::new(LogParser::parse(dir.clone()))));
+        let widths = vec![
+            Constraint::Percentage(20),
+            Constraint::Percentage(20),
+            Constraint::Percentage(20),
+            Constraint::Percentage(20),
+            Constraint::Percentage(20),
+        ];
+
+        let log_data = Rc::new(RefCell::new(
+            LogCollection::new(
+                LogParser::parse(dir, date)
+            )
+        ));
+
         let mut table_view = TableView::new(widths);
         table_view.set_model(log_data.clone());
 
         let app = Self {
-            filepath: dir.into(),
             table: Rc::new(RefCell::new(table_view)),
             search: Rc::new(RefCell::new(LineEdit::new("Filter".into()))),
             text: Rc::new(RefCell::new(KeyValueView::new())),

src/main.rs

@@ -18,37 +18,41 @@ use crossterm::{
     terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
 };
 use std::error::Error;
-use tui::{backend::CrosstermBackend, layout::Constraint, Terminal};
+use tui::{backend::CrosstermBackend, Terminal};
 
 
 use parser::logdata::LogCollection;
+use crate::util::parse_date;
 
 #[derive(Parser, Debug)]
-#[clap(author, version, about, long_about = None)]
+#[clap(author, version, about, long_about = None, verbatim_doc_comment)]
 struct Args {
-    #[clap(short, long, value_parser)]
+    /// Путь к директории с файлами логов
+    /// (Также ищет файлы в поддиректориях)
+    #[clap(short, long, value_parser, verbatim_doc_comment)]
     directory: String,
+
+    /// Временая точка начала чтения логов.
+    /// Формат: now-{digit}{s/m/h/d/w}
+    /// Пример: now-1d или now-30s
+    #[clap(long, value_parser, verbatim_doc_comment)]
+    from: Option<String>,
 }
 
 fn main() -> Result<(), Box<dyn Error>> {
     let args = Args::parse();
+    let date = match &args.from {
+        Some(value) => Some(parse_date(value.as_str())?),
+        None => None,
+    };
 
     enable_raw_mode()?;
     let mut stdout = std::io::stdout();
     execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
     let backend = CrosstermBackend::new(stdout);
     let mut terminal = Terminal::new(backend)?;
-    App::new(
-        args.directory.as_str(),
-        vec![
-            Constraint::Percentage(20),
-            Constraint::Percentage(20),
-            Constraint::Percentage(20),
-            Constraint::Percentage(20),
-            Constraint::Percentage(20),
-        ],
-    )
-    .run(&mut terminal)?;
+
+    App::new(args.directory.as_str(), date).run(&mut terminal)?;
 
     // restore terminal
     disable_raw_mode()?;

src/parser/mod.rs

@@ -287,14 +287,14 @@ impl Iterator for LineIter {
 pub struct LogParser;
 
 impl LogParser {
-    pub fn parse(dir: String) -> Receiver<LogString> {
+    pub fn parse(dir: String, date: Option<NaiveDateTime>) -> Receiver<LogString> {
         let (sender, receiver) = channel();
-        std::thread::spawn(move || LogParser::parse_dir(dir, sender));
+        std::thread::spawn(move || LogParser::parse_dir(dir, date, sender));
         receiver
     }
 
     // А может сделать итератор, который парсит
-    fn parse_dir(path: String, sender: Sender<LogString>) -> io::Result<()> {
+    fn parse_dir(path: String, date: Option<NaiveDateTime>, sender: Sender<LogString>) -> io::Result<()> {
         let walk = WalkDir::new(path)
             .follow_links(true)
             .into_iter()
@@ -312,7 +312,12 @@ impl LogParser {
                     let month = name[2..4].parse::<u32>().unwrap();
                     let day = name[4..6].parse::<u32>().unwrap();
                     let hour = name[6..8].parse::<u32>().unwrap();
-                    Some((e, NaiveDate::from_ymd(year, month, day).and_hms(hour, 0, 0)))
+
+                    let date_time = NaiveDate::from_ymd(year, month, day).and_hms(hour, 0, 0);
+                    match date {
+                        Some(date) if date_time < date => None,
+                        _ =>  Some((e, date_time))
+                    }
                 } else {
                     None
                 }
@@ -354,7 +359,18 @@ impl LogParser {
                         continue
                     }
 
-                    lines[index] = data.next();
+                    loop {
+                        match data.next() {
+                            Some(line) => match date {
+                                Some(date) if line.time < date => {},
+                                _ => {
+                                    lines[index] = Some(line);
+                                    break
+                                }
+                            },
+                            _ => lines[index] = None
+                        }
+                    }
                 }
 
                 let min = lines.iter()

src/util.rs

@@ -1,3 +1,43 @@
+use chrono::{Duration, Local, NaiveDateTime};
+use regex::Regex;
+
+pub fn parse_date(value: &str) -> Result<NaiveDateTime, regex::Error> {
+    let now = Local::now().naive_local();
+    let regex = Regex::new(r#"^now-(\d+)([smhdw])$"#)?;
+
+    match regex.captures(value) {
+        Some(captures) if captures.len() == 3 => {
+            match (captures.get(1), captures.get(2)) {
+                (Some(offset), Some(char)) => {
+                    let offset = offset.as_str().parse::<u64>()
+                        .map_err(|_| regex::Error::Syntax(String::from("Cannot parse number")))?;
+
+                    match char.as_str() {
+                        "s" => {
+                            Ok(now - Duration::seconds(offset as i64))
+                        }
+                        "m" => {
+                            Ok(now - Duration::minutes(offset as i64))
+                        }
+                        "h" => {
+                            Ok(now - Duration::hours(offset as i64))
+                        }
+                        "d" => {
+                            Ok(now - Duration::days(offset as i64))
+                        }
+                        "w" => {
+                            Ok(now - Duration::weeks(offset as i64))
+                        }
+                        _ => unreachable!(),
+                    }
+                },
+                _ => Err(regex::Error::Syntax("Invalid captures".to_string()))
+            }
+        },
+        _ => Err(regex::Error::Syntax("Invalid value".to_string()))
+    }
+}
+
 pub fn sub_strings(string: &str, sub_len: usize) -> Vec<&str> {
     let mut subs = Vec::with_capacity(string.len() * 2 / sub_len);
     let mut iter = string.chars();