Make regex an optional dependency

Author: belltoy

Cargo.toml

@@ -17,7 +17,7 @@ path = "src/lib.rs"
 
 [dependencies]
 slog = "2"
-regex = "0.1"
+regex = { version = "0.1", optional = true }
 slog-term = "2"
 slog-stdlog = "2"
 slog-scope = "3"
@@ -28,3 +28,5 @@ log = "0.3.6"
 name = "regexp_filter"
 harness = false
 
+[features]
+default = ["regex"]

src/lib.rs

@@ -71,7 +71,6 @@
        html_root_url = "http://doc.rust-lang.org/env_logger/")]
 #![cfg_attr(test, deny(warnings))]
 
-extern crate regex;
 #[macro_use]
 extern crate slog;
 extern crate slog_term;
@@ -80,11 +79,18 @@ extern crate slog_scope;
 extern crate slog_async;
 extern crate log;
 
-use regex::Regex;
 use std::{env, result, sync};
 use std::cell::RefCell;
 use slog::*;
 
+#[cfg(feature = "regex")]
+#[path = "regex.rs"]
+mod filter;
+
+#[cfg(not(feature = "regex"))]
+#[path = "string.rs"]
+mod filter;
+
 thread_local! {
     static TL_BUF: RefCell<String> = RefCell::new(String::new())
 }
@@ -93,7 +99,7 @@ thread_local! {
 pub struct EnvLogger<T : Drain> {
     drain : T,
     directives: Vec<LogDirective>,
-    filter: Option<Regex>,
+    filter: Option<filter::Filter>,
 }
 
 /// LogBuilder acts as builder for initializing the EnvLogger.
@@ -102,7 +108,7 @@ pub struct EnvLogger<T : Drain> {
 pub struct LogBuilder<T : Drain> {
     drain : T,
     directives: Vec<LogDirective>,
-    filter: Option<Regex>,
+    filter: Option<filter::Filter>,
 }
 
 impl<T : Drain> LogBuilder<T> {
@@ -271,7 +277,7 @@ pub fn init() -> std::result::Result<slog_scope::GlobalLoggerGuard, log::SetLogg
 
 /// Parse a logging specification string (e.g: "crate1,crate2::mod3,crate3::x=error/foo")
 /// and return a vector with log directives.
-fn parse_logging_spec(spec: &str) -> (Vec<LogDirective>, Option<Regex>) {
+fn parse_logging_spec(spec: &str) -> (Vec<LogDirective>, Option<filter::Filter>) {
     let mut dirs = Vec::new();
 
     let mut parts = spec.split('/');
@@ -318,7 +324,7 @@ fn parse_logging_spec(spec: &str) -> (Vec<LogDirective>, Option<Regex>) {
     }});
 
     let filter = filter.map_or(None, |filter| {
-        match Regex::new(filter) {
+        match filter::Filter::new(filter) {
             Ok(re) => Some(re),
             Err(e) => {
                 println!("warning: invalid regex filter - {}", e);

src/regex.rs

@@ -0,0 +1,28 @@
+extern crate regex;
+
+use std::fmt;
+
+use self::regex::Regex;
+
+pub struct Filter {
+    inner: Regex,
+}
+
+impl Filter {
+    pub fn new(spec: &str) -> Result<Filter, String> {
+        match Regex::new(spec){
+            Ok(r) => Ok(Filter { inner: r }),
+            Err(e) => Err(e.to_string()),
+        }
+    }
+
+    pub fn is_match(&self, s: &str) -> bool {
+        self.inner.is_match(s)
+    }
+}
+
+impl fmt::Display for Filter {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.inner.fmt(f)
+    }
+}

src/string.rs

@@ -0,0 +1,21 @@
+use std::fmt;
+
+pub struct Filter {
+    inner: String,
+}
+
+impl Filter {
+    pub fn new(spec: &str) -> Result<Filter, String> {
+        Ok(Filter { inner: spec.to_string() })
+    }
+
+    pub fn is_match(&self, s: &str) -> bool {
+        s.contains(&self.inner)
+    }
+}
+
+impl fmt::Display for Filter {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.inner.fmt(f)
+    }
+}