filter lines with: Has, Excludes, Glob & Regex\!

Author: PedroManse

bin/filter

@@ -0,0 +1 @@
+target

filte-rs/.gitignore

@@ -0,0 +1,15 @@
+[package]
+name = "filte-rs"
+version = "0.1.0"
+edition = "2021"
+default-run = "filter"
+
+[[bin]]
+name = "filter"
+path = "src/filter.rs"
+
+[dependencies]
+eyre = "0.6.12"
+glob = "0.3.1"
+regex = "1.10.5"
+thiserror = "1.0.61"

filte-rs/Cargo.lock

@@ -0,0 +1,21 @@
+use filte_rs::*;
+use std::io::{stdin, BufRead};
+
+fn match_all(filters: &[Filter], text: &str) -> bool {
+    filters.iter().all(|f| f.compare(text))
+}
+
+fn main() -> eyre::Result<()> {
+    let filters: Vec<Filter> = std::env::args()
+        .skip(1)
+        .map(Filter::try_from)
+        .collect::<Result<_, _>>()?;
+    let stdin = stdin();
+    for line in stdin.lock().lines() {
+        let line = line?;
+        if match_all(&filters, &line) {
+            println!("{line}");
+        }
+    }
+    Ok(())
+}

filte-rs/Cargo.toml

@@ -0,0 +1,80 @@
+#[derive(thiserror::Error, Debug)]
+pub enum FilterError {
+    #[error(transparent)]
+    RegexSyntax(#[from] regex::Error),
+    #[error(transparent)]
+    GlobSyntax(#[from] glob::PatternError),
+
+    #[error("No such filter mode {0}'")]
+    NoFilter(char),
+    #[error("No text in filter")]
+    NoText,
+}
+
+enum FilterType {
+    Equals,
+    Has,
+    Excludes,
+    Regex,
+    Glob,
+}
+
+#[derive(Debug)]
+pub enum Filter {
+    Equals(String),      // =
+    Has(String),         // +
+    Excludes(String),    // -
+    Regex(regex::Regex), // .
+    Glob(glob::Pattern), // ?
+}
+
+impl TryFrom<String> for Filter {
+    type Error = FilterError;
+    fn try_from(text: String) -> Result<Filter, FilterError> {
+        let mut chars = text.chars();
+        let mode = chars.next().ok_or(FilterError::NoText)?;
+        let mode = FilterType::try_from(mode)?;
+        let pattern: String = chars.collect();
+        mode.fill(pattern)
+    }
+}
+
+impl FilterType {
+    fn fill(self, pattern: String) -> Result<Filter, FilterError> {
+        Ok(match self {
+            FilterType::Equals => Filter::Equals(pattern),
+            FilterType::Has => Filter::Has(pattern),
+            FilterType::Excludes => Filter::Excludes(pattern),
+            FilterType::Regex => Filter::Regex(pattern.try_into()?),
+            FilterType::Glob => Filter::Glob(glob::Pattern::new(&pattern)?),
+        })
+    }
+}
+
+impl TryFrom<char> for FilterType {
+    type Error = FilterError;
+    fn try_from(v: char) -> Result<FilterType, FilterError> {
+        Ok(match v {
+            '=' => FilterType::Equals,
+            '+' => FilterType::Has,
+            '-' => FilterType::Excludes,
+            '~' => FilterType::Regex,
+            '?' => FilterType::Glob,
+            x => Err(FilterError::NoFilter(x))?,
+        })
+    }
+}
+
+impl Filter {
+    pub fn compare(&self, text: &str) -> bool {
+        use Filter::*;
+        match self {
+            Equals(rf) => rf == text,
+            Has(rf) => text.contains(rf),
+            Excludes(rf) => !text.contains(rf),
+            Regex(rf) => rf.is_match(text),
+            Glob(rf) => rf.matches(text),
+        }
+    }
+}
+

filte-rs/src/filter.rs

@@ -0,0 +1,20 @@
+use filte_rs::*;
+use std::io::{stdin, BufRead};
+
+fn match_all(filters: &[Filter], text: &str) -> bool {
+    filters.iter().all(|f| f.compare(text))
+}
+
+fn main() -> eyre::Result<()> {
+    let args: Vec<Filter> = std::env::args()
+        .skip(1)
+        .map(Filter::try_from)
+        .collect::<Result<_, _>>()?;
+    println!("{args:?}");
+    let stdin = stdin();
+    let mut line_count = 0;
+    for line in stdin.lock().lines() {
+        println!("{:?}", line);
+    }
+    Ok(())
+}