example implementation

Author: oriongonza

src/replacer/line_replacer.rs

@@ -0,0 +1,44 @@
+#[derive(Debug)]
+pub struct Pair {
+    regex: regex::Regex,
+    rep: String,
+}
+
+#[derive(Debug)]
+pub enum Opt {
+    ReplaceLineIfMatch,
+    AnotherOption,
+}
+
+pub fn replace_line<P: AsRef<[Pair]>, S: AsRef<str>>(
+    pairs: P,
+    opts: Vec<Opt>,
+    content: S,
+) -> Vec<String> {
+    let pairs = pairs.as_ref();
+    let content = content.as_ref();
+
+    let mut lines = content.lines().map(|x| x.to_owned()).collect::<Vec<_>>();
+
+    for opt in opts {
+        match opt {
+            Opt::ReplaceLineIfMatch => replace_line_if_match(pairs, &mut lines),
+            Opt::AnotherOption => other(pairs, &mut lines),
+        }
+    }
+    lines
+}
+
+fn replace_line_if_match(pairs: &[Pair], lines: &mut Vec<String>) {
+    for line in lines.iter_mut() {
+        for Pair { regex, rep } in pairs {
+            if regex.is_match(&line) {
+                *line = rep.clone();
+            }
+        }
+    }
+}
+
+fn other(pairs: &[Pair], lines: &mut Vec<String>) {
+    unimplemented!()
+}

src/replacer.rs src/replacer/mod.rs

@@ -1,39 +1,55 @@
+mod line_replacer;
+
 use crate::{utils, Error, Result};
 use regex::bytes::Regex;
-use std::{fs, fs::File, io::prelude::*, path::Path};
+use std::{borrow::Cow, fs, fs::File, io::prelude::*, path::Path};
 
-pub(crate) struct Replacer {
+#[derive(Debug)]
+struct Pair {
     regex: Regex,
-    replace_with: Vec<u8>,
-    is_literal: bool,
-    replacements: usize,
+    rep: Vec<u8>,
+}
+
+#[derive(Debug)]
+pub(crate) struct Replacer {
+    pairs: Vec<Pair>,
+    is_literal: bool, // -s
+    max_replacements: usize,
 }
 
+
 impl Replacer {
     pub(crate) fn new(
         look_for: String,
         replace_with: String,
         is_literal: bool,
         flags: Option<String>,
         replacements: Option<usize>,
+        extra: Vec<String>,
     ) -> Result<Self> {
-        let (look_for, replace_with) = if is_literal {
-            (regex::escape(&look_for), replace_with.into_bytes())
-        } else {
-            (
-                look_for,
-                utils::unescape(&replace_with)
-                    .unwrap_or(replace_with)
-                    .into_bytes(),
-            )
-        };
-
-        let mut regex = regex::bytes::RegexBuilder::new(&look_for);
-        regex.multi_line(true);
-
-        if let Some(flags) = flags {
-            flags.chars().for_each(|c| {
-                #[rustfmt::skip]
+        fn create(
+            look_for: String,
+            replace_with: String,
+            is_literal: bool,
+            flags: Option<&str>,
+        ) -> Result<Pair> {
+            let (look_for, replace_with) = if is_literal {
+                (regex::escape(&look_for), replace_with.into_bytes())
+            } else {
+                (
+                    look_for,
+                    utils::unescape(&replace_with)
+                        .unwrap_or(replace_with)
+                        .into_bytes(),
+                )
+            };
+
+            let mut regex = regex::bytes::RegexBuilder::new(&look_for);
+            regex.multi_line(true);
+
+            if let Some(flags) = flags {
+                for c in flags.chars() {
+                    #[rustfmt::skip]
                 match c {
                     'c' => { regex.case_insensitive(false); },
                     'i' => { regex.case_insensitive(true); },
@@ -53,19 +69,46 @@ impl Replacer {
                     },
                     _ => {},
                 };
-            });
-        };
+                }
+            };
+            Ok(Pair {
+                regex: regex.build()?,
+                rep: replace_with,
+            })
+        }
 
-        Ok(Self {
-            regex: regex.build()?,
+        let capacity = extra.len() / 2 + 1;
+        let mut pairs = Vec::with_capacity(capacity);
+        pairs.push(create(
+            look_for,
             replace_with,
             is_literal,
-            replacements: replacements.unwrap_or(0),
+            flags.as_deref(),
+        )?);
+
+        let mut it = extra.into_iter();
+        while let Some(look_for) = it.next() {
+            let replace_with = it
+                .next()
+                .expect("The extra pattern list doesn't have an even lenght");
+
+            pairs.push(create(
+                look_for,
+                replace_with,
+                is_literal,
+                flags.as_deref(),
+            )?);
+        }
+
+        Ok(Self {
+            pairs,
+            is_literal,
+            max_replacements: replacements.unwrap_or(0),
         })
     }
 
     pub(crate) fn has_matches(&self, content: &[u8]) -> bool {
-        self.regex.is_match(content)
+        self.pairs.iter().any(|r| r.regex.is_match(content))
     }
 
     pub(crate) fn check_not_empty(mut file: File) -> Result<()> {
@@ -74,50 +117,56 @@ impl Replacer {
         Ok(())
     }
 
-    pub(crate) fn replace<'a>(
-        &'a self,
-        content: &'a [u8],
-    ) -> std::borrow::Cow<'a, [u8]> {
-        if self.is_literal {
-            self.regex.replacen(
-                content,
-                self.replacements,
-                regex::bytes::NoExpand(&self.replace_with),
-            )
-        } else {
-            self.regex
-                .replacen(content, self.replacements, &*self.replace_with)
+    pub(crate) fn replace<'a>(&'a self, content: &'a [u8]) -> Cow<'a, [u8]> {
+        let mut result = Cow::Borrowed(content);
+        for Pair { regex, rep } in self.pairs.iter() {
+            let res = if self.is_literal {
+                let rep = regex::bytes::NoExpand(rep.as_slice());
+                regex.replacen(&result, self.max_replacements, rep)
+            } else {
+                regex.replacen(&result, self.max_replacements, rep)
+            };
+
+            result = Cow::Owned(res.into_owned());
         }
+        result
     }
 
     pub(crate) fn replace_preview<'a>(
         &'a self,
-        content: &[u8],
-    ) -> std::borrow::Cow<'a, [u8]> {
-        let mut v = Vec::<u8>::new();
-        let mut captures = self.regex.captures_iter(content);
-
-        self.regex.split(content).for_each(|sur_text| {
-            use regex::bytes::Replacer;
-
-            v.extend(sur_text);
-            if let Some(capture) = captures.next() {
-                v.extend_from_slice(
-                    ansi_term::Color::Green.prefix().to_string().as_bytes(),
-                );
-                if self.is_literal {
-                    regex::bytes::NoExpand(&self.replace_with)
-                        .replace_append(&capture, &mut v);
-                } else {
-                    (&*self.replace_with).replace_append(&capture, &mut v);
+        content: &'a [u8],
+    ) -> Cow<'a, [u8]> {
+        let mut content = Cow::Borrowed(content);
+
+        for Pair { regex, rep } in self.pairs.iter() {
+            let rep = rep.as_slice();
+
+            let mut v = Vec::<u8>::new();
+            let mut captures = regex.captures_iter(&content);
+
+            for sur_text in regex.split(&content) {
+                use regex::bytes::Replacer;
+
+                v.extend(sur_text);
+                if let Some(capture) = captures.next() {
+                    v.extend_from_slice(
+                        ansi_term::Color::Green.prefix().to_string().as_bytes(),
+                    );
+                    if self.is_literal {
+                        regex::bytes::NoExpand(&rep)
+                            .replace_append(&capture, &mut v);
+                    } else {
+                        (&*rep).replace_append(&capture, &mut v);
+                    }
+                    v.extend_from_slice(
+                        ansi_term::Color::Green.suffix().to_string().as_bytes(),
+                    );
                 }
-                v.extend_from_slice(
-                    ansi_term::Color::Green.suffix().to_string().as_bytes(),
-                );
             }
-        });
+            content = Cow::Owned(v);
+        }
 
-        return std::borrow::Cow::Owned(v);
+        content
     }
 
     pub(crate) fn replace_file(&self, path: &Path) -> Result<()> {
@@ -130,7 +179,7 @@ impl Replacer {
 
         let source = File::open(path)?;
         let meta = fs::metadata(path)?;
-        let mmap_source = unsafe { Mmap::map(&source)? };
+        let mmap_source = unsafe { Mmap::map(&source) }?;
         let replaced = self.replace(&mmap_source);
 
         let target = tempfile::NamedTempFile::new_in(
@@ -142,7 +191,7 @@ impl Replacer {
         file.set_permissions(meta.permissions())?;
 
         if !replaced.is_empty() {
-            let mut mmap_target = unsafe { MmapMut::map_mut(file)? };
+            let mut mmap_target = unsafe { MmapMut::map_mut(file) }?;
             mmap_target.deref_mut().write_all(&replaced)?;
             mmap_target.flush_async()?;
         }
@@ -173,6 +222,7 @@ mod tests {
             literal,
             flags.map(ToOwned::to_owned),
             None,
+            vec![],
         )
         .unwrap();
         assert_eq!(
@@ -216,4 +266,22 @@ mod tests {
     fn full_word_replace() {
         replace("abc", "def", false, Some("w"), "abcd abc", "abcd def");
     }
+
+    #[test]
+    fn test_multipattern() {
+        let replacer = Replacer::new(
+            "foo".to_owned(),
+            "bar".to_owned(),
+            false,
+            None,
+            None,
+            vec!["qux".into(), "quux".into(), "bing".into(), "bong".into()],
+        )
+        .unwrap();
+
+        assert_eq!(
+            std::str::from_utf8(&replacer.replace("foo qux bing".as_bytes())),
+            Ok("bar quux bong")
+        );
+    }
 }