feat: ignore pattern for store (#25)

* feat: ignore entries matching given regex pattern(s)

* test: ensure regex ignore patterns are respected

* docs(readme): include mention of ignore patterns for filtering

* chore: avoid using deprecated `assert_cmd` function

Author: Rolv-Apneseth

Cargo.lock

@@ -19,7 +19,7 @@ argfile = { version = "0.2" }
 dirs = { version = "6.0" }
 humantime = { version = "2.3" }
 
-# MIME types
+# Binary data
 image = "0.25"
 mime-sniffer = "0.1"
 content_inspector = "0.2"
@@ -37,8 +37,9 @@ tracing-subscriber = { features = [
 tracing-appender = { version = "0.2", git = "https://github.com/tokio-rs/tracing.git" }
 
 # Misc
-unicode-segmentation = "1.10"                      # Limit preview width by grapheme clusters
+unicode-segmentation = { version = "1.12" }        # Limit preview width by grapheme clusters
 miette = { version = "7.6", features = ["fancy"] } # Fancy errors
+regex = { version = "1.12" }                       # Support ignore patterns defined by the user
 
 [dev-dependencies]
 pretty_assertions = "1.4"

Cargo.toml

@@ -27,7 +27,8 @@ In addition:
 - **Relative positions:** support for getting/deleting items by relative position in the saved history
 - **Entry size limits**: configurable minimum and maximum size for stored entries
 - **Entry age limit:** configurable max age for entries - automatically remove old clipboard entries
-- **Informative previews:** previews for binary data support many more types e.g. `video/mp4`, `application/pdf`, etc.
+- **Ignore entries:** avoid storing certain text data using regex patterns, e.g. `^<meta http-equiv=`
+- **Informative previews:** previews for binary data support many more types, e.g. `video/mp4`, `application/pdf`, etc.
 
 ## Requirements
 
@@ -104,14 +105,15 @@ wl-paste --type image --watch clipvault store # Forward raw image data
 ### Image data from browsers
 
 When copying images from browsers, `wl-paste` will usually pass the data to `clipvault` as `text/html`.
-This is not ideal for copying images, and you may wish to have the raw image data copied instead.
-If so, you can either *only* forward image data, or, more realistically, use the below and filter
-out entries which start with `<meta http-equiv=` in your picker (check out some of the scripts
-in [extras](./extras) - I personally use the [rofi script](./extras/clipvault_rofi.sh)):
+This is not ideal for copying images, and you probably want to have the raw image data copied instead.
+If so, you can either *only* forward image data, or, more realistically, use the commands below to
+copy the image data directly, and ignore the `text/html`:
 
 ```sh
-wl-paste --watch clipvault store # Forward all data 
-wl-paste --type image --watch clipvault store # Forward specifically raw image data 
+# Forward all data, ignoring text that starts with "<meta http-equiv="
+wl-paste --watch clipvault store --ignore-pattern '^<meta http-equiv='
+# Forward specifically raw image data 
+wl-paste --type image --watch clipvault store
 ```
 
 ## Usage

README.md

@@ -1,6 +1,7 @@
 use std::path::PathBuf;
 
 use clap::{Parser, Subcommand, ValueHint, command};
+use regex::Regex;
 
 use crate::defaults;
 
@@ -72,6 +73,18 @@ pub struct StoreArgs {
     /// Store sensitive values, ignoring e.g. CLIPBOARD_STATE="sensitive" set by wl-clipboard.
     #[arg(long, action, env = "CLIPVAULT_STORE_SENSITIVE")]
     pub store_sensitive: bool,
+
+    /// Entries which include any match for the given regex pattern will not be stored.
+    ///
+    /// To specify multiple patterns, simply call the argument again with a new pattern. Be mindful
+    /// of the fact that every regex pattern given will be tested against every text input.
+    ///
+    /// e.g. clipvault --store --ignore-pattern '^<meta http-equiv=' --ignore-pattern 'ignore\n$'
+    ///
+    /// Note that look-around and backreferences are not supported, as the Rust implementation
+    /// of a regex engine used does not support those features.
+    #[arg(long, action, env = "CLIPVAULT_IGNORE_PATTERN", num_args = 1)]
+    pub ignore_pattern: Option<Vec<Regex>>,
 }
 
 #[derive(Debug, clap::Args)]
@@ -110,7 +123,3 @@ pub struct GetDelArgs {
     #[arg(long, conflicts_with("input"), allow_hyphen_values(true))]
     pub index: Option<isize>,
 }
-
-// impl Cli {
-//     fn to_config
-// }

src/cli.rs

@@ -3,6 +3,7 @@ use std::{
     path::Path,
 };
 
+use content_inspector::ContentType;
 use miette::{Context, IntoDiagnostic, Result, miette};
 use tracing::instrument;
 
@@ -23,6 +24,7 @@ pub fn execute(path_db: &Path, args: StoreArgs) -> Result<()> {
         max_entry_length: max_bytes,
         min_entry_length: min_bytes,
         store_sensitive,
+        ignore_pattern,
     } = args;
 
     // Min conflicts with max
@@ -78,12 +80,27 @@ pub fn execute(path_db: &Path, args: StoreArgs) -> Result<()> {
         );
         return Ok(());
     }
+
     // Ignore purely whitespace content
     if buf.trim_ascii().is_empty() {
         tracing::debug!("only ASCII whitespace content");
         return Ok(());
     }
 
+    // Check user-provided ignore pattern
+    if let Some(regexes) = ignore_pattern
+        && matches!(
+            content_inspector::inspect(&buf),
+            ContentType::UTF_8 | ContentType::UTF_8_BOM
+        )
+        && regexes
+            .iter()
+            .any(|re| re.is_match(&String::from_utf8_lossy(&buf)))
+    {
+        tracing::debug!("content matched an ignore pattern");
+        return Ok(());
+    }
+
     // Only get DB connection after parsing STDIN - avoid locking
     let conn = &init_db(path_db)?;
 

src/commands/store.rs

@@ -1,6 +1,6 @@
-use std::{os::unix::fs::MetadataExt, sync::LazyLock, time::Duration};
+use std::{io::BufRead, os::unix::fs::MetadataExt, sync::LazyLock, time::Duration};
 
-use assert_cmd::Command;
+use assert_cmd::{Command, cargo_bin};
 use base64::{
     Engine, alphabet,
     engine::{self, GeneralPurposeConfig},
@@ -20,8 +20,7 @@ fn get_db() -> NamedTempFile {
 
 /// Builds the command to be run, pointing at the given temporary file for the database.
 fn get_cmd(db: &NamedTempFile) -> Command {
-    let mut cmd = Command::cargo_bin("clipvault").expect("failed to build cmd");
-
+    let mut cmd = Command::new(cargo_bin!());
     cmd.args(["--database", &db.path().to_string_lossy()]);
     cmd
 }
@@ -58,7 +57,7 @@ const ENCODED_BINARY: &[(&str, &[u8])] = &[
 ];
 
 #[test]
-fn test_cmd_store() {
+fn test_store_basic() {
     let db = &get_db();
 
     // TEXT
@@ -107,10 +106,7 @@ fn test_store_max_entries() {
         }
         let assert = get_cmd(db).arg("list").assert();
         let output = assert.get_output();
-        assert_eq!(
-            limit as usize,
-            String::from_utf8_lossy(&output.stdout).lines().count()
-        );
+        assert_eq!(limit as usize, output.stdout.lines().count());
         assert.success();
     }
 
@@ -209,6 +205,76 @@ fn test_store_min_max_conflict() {
         .failure();
 }
 
+#[test]
+fn test_store_ignore_pattern() {
+    let db = &get_db();
+
+    let store_ignore = |patterns: &[&str], input: &[u8]| {
+        let mut args = Vec::from(["store"]);
+        for pat in patterns {
+            args.push("--ignore-pattern");
+            args.push(pat);
+        }
+        get_cmd(db).args(args).write_stdin(input).assert().success();
+    };
+    let count_stored = || {
+        get_cmd(db)
+            .arg("list")
+            .output()
+            .expect("couldn't list entries")
+            .stdout
+            .lines()
+            .count()
+    };
+
+    let mut expected = 0;
+
+    store_ignore(&["test"], b"testing");
+    assert_eq!(count_stored(), expected);
+
+    expected += 1;
+    store_ignore(&["test"], b"hello");
+    assert_eq!(count_stored(), expected);
+
+    store_ignore(&["^abc"], b"abcdefg");
+    assert_eq!(count_stored(), expected);
+
+    expected += 1;
+    store_ignore(&["^abc"], b"def");
+    assert_eq!(count_stored(), expected);
+
+    store_ignore(&["world$"], b"hello world");
+    assert_eq!(count_stored(), expected);
+
+    expected += 1;
+    store_ignore(&["world$"], b"goodbye earth");
+    assert_eq!(count_stored(), expected);
+
+    let http_image = r#"<meta http-equiv="content-type" content="text/html; charset=utf-8"><img src="https://external-content.duckduckgo.com/iu/?u=https%3A%2F%2Ftse4.mm.bing.net%2Fth%2Fid%2FOIP.NHEHZBx37DjUVrFOwDUNugHaE8%3Fpid%3DApi&amp;f=1&amp;ipt=dcffa9260288ea62423251c252ecf228037d6317b7911a5365b03d36ca0590fb&amp;ipo=images" alt="alsdkf dlas by dannicalifornia on DeviantArt" style="width: 100%; height: 180px; min-height: 180px; max-height: 180px;" loading="lazy">"#;
+    store_ignore(
+        &[r"^<meta http-equiv=", r"ignore\n$"],
+        http_image.as_bytes(),
+    );
+    assert_eq!(count_stored(), expected);
+
+    store_ignore(
+        &[r"^<meta http-equiv=", r"ignore\n$"],
+        b"\nplease\tignore\n",
+    );
+    assert_eq!(count_stored(), expected);
+
+    expected += 1;
+    store_ignore(&[r"^<meta http-equiv=", r"ignore\n$"], b"control");
+    assert_eq!(count_stored(), expected);
+
+    // Fails with invalid regex
+    get_cmd(db)
+        .args(["store", "--ignore-pattern", "[["])
+        .assert()
+        .failure()
+        .stderr(contains("regex parse error"));
+}
+
 #[test]
 fn test_get_del() {
     let db = &get_db();
@@ -247,8 +313,7 @@ fn test_get_del() {
     get_cmd(db).arg("get").write_stdin("1").assert().failure();
 
     let stdout = get_cmd(db).arg("list").output().unwrap().stdout;
-    let str = String::from_utf8_lossy(&stdout);
-    assert_eq!(str.lines().count(), (u8::MAX - 3) as usize);
+    assert_eq!(stdout.lines().count(), (u8::MAX - 3) as usize);
 }
 
 #[test]