smart-patcher 0.7.0

use regex::{Regex, Replacer as ReplacerTrait};
use serde::{Deserialize, Serialize};
use std::borrow::Cow;

#[derive(Clone, Debug)]
/// Regular expression.
///
/// It is just the wrapper for [regex](https://docs.rs/regex/) for serialization/deserialization.
pub struct RegexIR {
  re: Regex,
}

impl PartialEq for RegexIR {
  fn eq(&self, right: &RegexIR) -> bool {
    self.re.as_str().eq(right.re.as_str())
  }
}

impl RegexIR {
  /// Creates new regex from string.
  pub fn new(re: impl AsRef<str>) -> Result<Self, regex::Error> {
    Ok(Self {
      re: Regex::new(re.as_ref())?,
    })
  }

  /// Returns regex as string.
  pub fn as_str(&self) -> &str {
    self.re.as_str()
  }

  /// Returns inner regex object.
  pub fn inner(&self) -> &Regex {
    &self.re
  }

  /// Replaces all non-overlapping matches in the haystack with the replacement provided.
  ///
  /// See [Regex::replace_all](https://docs.rs/regex/latest/regex/struct.Regex.html#method.replace_all).
  pub fn replace_all<'h, R: ReplacerTrait>(&'h self, content: &'h str, replacer: R) -> Cow<'h, str> {
    self.re.replace_all(content, replacer)
  }
}

impl<'de> Deserialize<'de> for RegexIR {
  fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
    use serde::de::Error;
    RegexIR::new(String::deserialize(deserializer)?.as_str()).map_err(|err| Error::custom(err.to_string()))
  }
}

impl Serialize for RegexIR {
  fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
    serializer.serialize_str(self.as_str())
  }
}

pub(crate) fn is_verbose() -> bool {
  std::env::var("SMPTCHVERBOSE").is_ok_and(|val| val.as_str().eq("1"))
}