refactor: wip alphabet & regexes

src/alphabets.rs

@@ -25,59 +25,73 @@ const ALPHABETS: [(&'static str, &'static str); 22] = [
     ("colemak-right-hand", "neioluymjhk"),
 ];
 
-// pub struct Alphabet<'a> {
-//   letters: &'a str,
-// }
-
 /// Type-safe string alphabet (newtype).
 #[derive(Debug)]
 pub struct Alphabet(pub String);
 
 impl Alphabet {
-  pub fn hints(&self, matches: usize) -> Vec<String> {
+    /// Create `n` hints.
+    ///
+    /// ```
+    /// // The algorithm works as follows:
+    /// //                                  --- lead ----
+    /// // initial state                 |  a   b   c   d
+    ///
+    /// // along as we need more hints, and still have capacity, do the following
+    ///
+    /// //                                  --- lead ----  --- gen --- -------------- prev ---------------
+    /// // pick d, generate da db dc dd  |  a   b   c  (d) da db dc dd
+    /// // pick c, generate ca cb cc cd  |  a   b  (c) (d) ca cb cc cd da db dc dd
+    /// // pick b, generate ba bb bc bd  |  a  (b) (c) (d) ba bb bc bd ca cb cc cd da db dc dd
+    /// // pick a, generate aa ab ac ad  | (a) (b) (c) (d) aa ab ac ad ba bb bc bd ca cb cc cd da db dc dd
+    /// ```
+    pub fn make_hints(&self, n: usize) -> Vec<String> {
         let letters: Vec<String> = self.0.chars().map(|s| s.to_string()).collect();
 
-    let mut expansion = letters.clone();
+        let mut lead = letters.clone();
-    let mut expanded: Vec<String> = Vec::new();
+        let mut prev: Vec<String> = Vec::new();
 
         loop {
-      if expansion.len() + expanded.len() >= matches {
+            if lead.len() + prev.len() >= n {
-        break;
-      }
-      if expansion.is_empty() {
                 break;
             }
 
-      let prefix = expansion.pop().expect("Ouch!");
+            if lead.is_empty() {
-      let sub_expansion: Vec<String> = letters
+                break;
+            }
+            let prefix = lead.pop().unwrap();
+
+            // generate characters pairs
+            let gen: Vec<String> = letters
                 .iter()
-        .take(matches - expansion.len() - expanded.len())
+                .take(n - lead.len() - prev.len())
                 .map(|s| prefix.clone() + s)
                 .collect();
 
-      expanded.splice(0..0, sub_expansion);
+            // Insert gen in front of prev
+            prev.splice(0..0, gen);
         }
 
-    expansion = expansion.iter().take(matches - expanded.len()).cloned().collect();
+        lead = lead.iter().take(n - prev.len()).cloned().collect();
-    expansion.append(&mut expanded);
+        lead.append(&mut prev);
-    expansion
+        lead
     }
 }
 
-// pub fn get_alphabet(alphabet_name: &str) -> Alphabet {
+/// Parse a name string into `Alphabet`, supporting the CLI.
-//   let alphabets: HashMap<&str, &str> = ALPHABETS.iter().cloned().collect();
+///
-
+/// # Note
-//   alphabets
+///
-//     .get(alphabet_name)
+/// Letters 'n' and 'N' are systematically removed to prevent conflict with
-//     .expect(format!("Unknown alphabet: {}", alphabet_name).as_str());
+/// navigation keys (arrows and 'n' 'N').
-
-//   Alphabet::new(alphabets[alphabet_name])
-// }
-
 pub fn parse_alphabet(src: &str) -> Result<Alphabet, error::ParseError> {
-  let alphabet = ALPHABETS.iter().find(|&(name, _letters)| name == &src);
+    let alphabet_pair = ALPHABETS.iter().find(|&(name, _letters)| name == &src);
-  match alphabet {
+
-    Some((_name, letters)) => Ok(Alphabet(letters.to_string())),
+    match alphabet_pair {
+        Some((_name, letters)) => {
+            let letters = letters.replace(&['n', 'N'][..], "");
+            Ok(Alphabet(letters.to_string()))
+        }
         None => Err(error::ParseError::UnknownAlphabet),
     }
 }
@@ -89,28 +103,39 @@ mod tests {
     #[test]
     fn simple_matches() {
         let alphabet = Alphabet("abcd".to_string());
-    let hints = alphabet.hints(3);
+        let hints = alphabet.make_hints(3);
         assert_eq!(hints, ["a", "b", "c"]);
     }
 
     #[test]
     fn composed_matches() {
         let alphabet = Alphabet("abcd".to_string());
-    let hints = alphabet.hints(6);
+        let hints = alphabet.make_hints(6);
         assert_eq!(hints, ["a", "b", "c", "da", "db", "dc"]);
     }
 
     #[test]
     fn composed_matches_multiple() {
         let alphabet = Alphabet("abcd".to_string());
-    let hints = alphabet.hints(8);
+        let hints = alphabet.make_hints(8);
         assert_eq!(hints, ["a", "b", "ca", "cb", "da", "db", "dc", "dd"]);
     }
 
     #[test]
-  fn composed_matches_max() {
+    fn composed_matches_max_2() {
         let alphabet = Alphabet("ab".to_string());
-    let hints = alphabet.hints(8);
+        let hints = alphabet.make_hints(8);
         assert_eq!(hints, ["aa", "ab", "ba", "bb"]);
     }
+
+    #[test]
+    fn composed_matches_max_4() {
+        let alphabet = Alphabet("abcd".to_string());
+        let hints = alphabet.make_hints(13);
+        assert_eq!(
+            hints,
+            ["a", "ba", "bb", "bc", "bd", "ca", "cb", "cc", "cd", "da", "db", "dc", "dd"]
+        );
+        // a (b) (c) (d) a ba bc bd ca cb cc cd da db dc dd
+    }
 }

src/lib.rs

@@ -59,7 +59,7 @@ pub struct CliOpt {
     /// Possible values are "{A}", "{A}-homerow", "{A}-left-hand",
     /// "{A}-right-hand", where "{A}" is one of "qwerty", "azerty", "qwertz",
     /// "dvorak", "colemak". Examples: "qwerty", "dvorak-homerow".
-    #[clap(short = "k", long, default_value = "qwerty",
+    #[clap(short = "k", long, default_value = "dvorak",
                 parse(try_from_str = alphabets::parse_alphabet))]
     alphabet: alphabets::Alphabet,
 

src/state.rs

@@ -1,8 +1,8 @@
-use super::alphabets::Alphabet;
 use regex::Regex;
 use std::collections::HashMap;
 use std::fmt;
 
+use crate::alphabets::Alphabet;
 use crate::regexes::{EXCLUDE_PATTERNS, PATTERNS};
 
 #[derive(Clone)]
@@ -37,19 +37,19 @@ impl<'a> PartialEq for Match<'a> {
 pub struct State<'a> {
     pub lines: &'a Vec<&'a str>,
     alphabet: &'a Alphabet,
-    regexp: &'a Vec<String>,
+    custom_regexes: &'a Vec<String>,
 }
 
 impl<'a> State<'a> {
     pub fn new(
         lines: &'a Vec<&'a str>,
         alphabet: &'a Alphabet,
-        regexp: &'a Vec<String>,
+        custom_regexes: &'a Vec<String>,
     ) -> State<'a> {
         State {
             lines,
             alphabet,
-            regexp,
+            custom_regexes,
         }
     }
 
@@ -62,7 +62,7 @@ impl<'a> State<'a> {
             .collect::<Vec<_>>();
 
         let custom_patterns = self
-            .regexp
+            .custom_regexes
             .iter()
             .map(|regexp| ("custom", Regex::new(regexp).expect("Invalid custom regexp")))
             .collect::<Vec<_>>();
@@ -123,8 +123,7 @@ impl<'a> State<'a> {
             }
         }
 
-        // let alphabet = super::alphabets::get_alphabet(self.alphabet);
+        let mut hints = self.alphabet.make_hints(matches.len());
-        let mut hints = self.alphabet.hints(matches.len());
 
         // This looks wrong but we do a pop after
         if !reverse {

src/view.rs

@@ -426,6 +426,9 @@ impl<'a> View<'a> {
                 event::Key::Left => self.prev(),
                 event::Key::Right => self.next(),
 
+                event::Key::Char(_ch @ 'n') => self.next(),
+                event::Key::Char(_ch @ 'N') => self.prev(),
+
                 // TODO: use a Trie or another data structure to determine
                 // if the entered key belongs to a longer hint.
                 // Attempts at finding a match with a corresponding hint.