make autolink pattern configurable

src/modules/autolink.rs

@@ -17,8 +17,11 @@ use stc::searchers::mediawiki::MediawikiSearcher;
 use regex::Regex;
 use std::collections::BTreeMap;
 
+const DEFAULT_PATTERN: &str = r"\[\[([^\[\]]*)\]\]";
+
 pub struct AutolinkModule {
-    searcher_config: Table
+    searcher_config: Table,
+    pattern: Regex
 }
 
 impl AutolinkModule {
@@ -26,22 +29,40 @@ impl AutolinkModule {
         let searcher_config = configuration.get("searchers").expect("No configuration for searcher found")
                                            .as_table().expect("Searcher config must be a table");
 
+        let pattern = configuration.get("pattern")
+                                   .and_then(|value| value.as_str())
+                                   .or(Some(DEFAULT_PATTERN))
+                                   .map(String::from)
+                                   .and_then(|value| Regex::new(&value).ok())
+                                   .expect("Invalid value for pattern");
+
         Box::new(AutolinkModule {
-            searcher_config: searcher_config.clone()
+            searcher_config: searcher_config.clone(),
+            pattern: pattern
         })
     }
 }
 
 fn create_searcher (configuration: &Table) -> AggregateSearcher {
     let mut searchers = AggregateSearcher::new();
-    searchers.add_searcher("mtg", Box::new(MtgSearcher::new()));
+    for (prefix, searcher_config) in configuration.iter() {
-    searchers.add_searcher("ygo", Box::new(YugiohSearcher::new()));
+        if let Some(searcher_type) = searcher_config.get("type") {
-    searchers.add_searcher("ygp", Box::new(MediawikiSearcher::new(String::from("https://yugipedia.com/wiki/"))));
+            match searcher_type.as_str() {
-    searchers.add_searcher("pk", Box::new(MediawikiSearcher::new(String::from("https://bulbapedia.bulbagarden.net/wiki/"))));
+                Some("mtg") => searchers.add_searcher(prefix, Box::new(MtgSearcher::new())),
-    searchers.add_searcher("gp", Box::new(MediawikiSearcher::new(String::from("https://gammapedia.monarch-pass.net/wiki/"))));
+                Some("ygo") => searchers.add_searcher(prefix, Box::new(YugiohSearcher::new())),
-    searchers.add_searcher("ip", Box::new(MediawikiSearcher::new(String::from("http://infinitypedia.org/wiki/"))));
+                Some("wiki") => {
-    searchers.add_searcher("gcl", Box::new(MediawikiSearcher::new(String::from("https://glitchcity.info/wiki/"))));
+                    if let Some(url) = searcher_config.get("url") {
-    searchers.add_searcher("wp", Box::new(MediawikiSearcher::new(String::from("https://en.wikipedia.org/wiki/"))));
+                        match url.as_str() {
+                            Some(url) => searchers.add_searcher(prefix, Box::new(MediawikiSearcher::new(url.to_owned()))),
+                            None =>  warn!("Missing url for wiki searcher {}", prefix)
+                        }
+                    }
+                },
+                Some(unknown_type) => info!("Unrecognized searcher type {} for {}", unknown_type, prefix),
+                None => warn!("No searcher type given for {}", prefix)
+            }
+        }
+    }
     searchers
 }
 
@@ -105,7 +126,6 @@ fn print_any_link (link: &Link, message: &Message) {
 
 impl EventLoop for AutolinkModule {
     fn run (&self, _: Box<ExtSender<Event>>, receiver: Receiver<Arc<Envelope>>) {
-        let link_regex = Regex::new(r"\[\[([^\[\]]*)\]\]").expect("Invalid regex...");
         let searcher = create_searcher(&self.searcher_config);
         let mut searcher_cache = BTreeMap::new();
 
@@ -114,7 +134,7 @@ impl EventLoop for AutolinkModule {
                 Ok(envelope) => {
                     if let Event::Message { ref message } = envelope.event {
                         debug!("Received message from module {:?}... {:?}", envelope.from, message.content);
-                        for cap in link_regex.captures_iter(&message.content) {
+                        for cap in self.pattern.captures_iter(&message.content) {
                             let term = cap[1].to_owned();
                             if let &mut Some(ref mut item) = searcher_cache.entry(term.to_owned()).or_insert_with(|| searcher.exact_search(&term)) {
                                 print_any_link(item, message);