change comment detection logic

en_GB contains the rule `COMPOUNDRULE #*0{`.
unfortunately any word starting with a # was detected as a comment

the new logic skips all lines starting with # and then
allows unparsed data at the end of each line

Author: Gentle

src/aff/parser.rs

@@ -550,13 +550,6 @@ fn parse_compound_syllable<'aff>(
             }))
         }
     };
-    let remaining_words = words.count();
-    if remaining_words > 0 {
-        return Err(lines.error(ParseDictionaryErrorKind::MismatchedArity {
-            expected: 2,
-            actual: 2 + remaining_words,
-        }));
-    }
 
     cx.options.compound_syllable_max = max
         .parse::<u16>()
@@ -656,14 +649,6 @@ fn parse_compound_pattern_table(cx: &mut AffLineParser, lines: &mut Lines) -> Pa
         };
         let replacement = words.next();
 
-        let remaining_words = words.count();
-        if remaining_words > 0 {
-            return Err(lines.error(ParseDictionaryErrorKind::MismatchedArity {
-                expected: 3,
-                actual: 3 + remaining_words,
-            }));
-        }
-
         let (first_word_end, first_word_flag) = split_word_and_flagset_naive(first_word_end);
         let (second_word_begin, second_word_flag) = split_word_and_flagset_naive(second_word_begin);
         let first_word_flag = (!first_word_flag.is_empty())
@@ -742,7 +727,7 @@ fn parse_map(cx: &mut AffLineParser, lines: &mut Lines) -> ParseResult {
 
 /// A helper type that means "words on a line split by whitespace with comments
 /// dropped." This is a concretion of `impl Iterator<Item = &'a str>`.
-type Words<'text> = TakeWhile<SplitWhitespace<'text>, for<'b, 'c> fn(&'b &'c str) -> bool>;
+type Words<'text> = SplitWhitespace<'text>;
 
 struct Lines<'text> {
     lines: Peekable<Enumerate<core::str::Lines<'text>>>,
@@ -754,10 +739,11 @@ impl<'text> Lines<'text> {
     fn new(text: &'text str, source: ParseDictionaryErrorSource) -> Self {
         let text = text.strip_prefix('\u{feff}').unwrap_or(text);
         let mut lines = text.lines().enumerate().peekable();
-        let words = lines.peek().map(|(_line_no, line)| {
-            line.split_whitespace()
-                .take_while((|word| !word.starts_with('#')) as for<'b, 'c> fn(&'b &'c str) -> bool)
-        });
+        while lines
+            .next_if(|(_line_no, line)| line.trim_start().starts_with('#'))
+            .is_some()
+        {}
+        let words = lines.peek().map(|(_line_no, line)| line.split_whitespace());
 
         Self {
             lines,
@@ -772,10 +758,15 @@ impl<'text> Lines<'text> {
 
     fn advance_line(&mut self) {
         self.lines.next();
-        self.words = self.lines.peek().map(|(_line_no, line)| {
-            line.split_whitespace()
-                .take_while((|word| !word.starts_with('#')) as for<'b, 'c> fn(&'b &'c str) -> bool)
-        });
+        while self
+            .lines
+            .next_if(|(_line_no, line)| line.trim_start().starts_with('#'))
+            .is_some()
+        {}
+        self.words = self
+            .lines
+            .peek()
+            .map(|(_line_no, line)| line.split_whitespace());
     }
 
     fn line(&mut self) -> Option<&str> {
@@ -813,19 +804,6 @@ impl<'text> Lines<'text> {
     }
 
     fn parse_bool(&mut self) -> Result<bool> {
-        // Boolean flags are specified by just the key. For example if you see `COMPLEXPREFIXES`
-        // as a line, `complex_prefixes` is true. Otherwise it's false.
-        let count = self
-            .words
-            .take()
-            .map(|words| words.count())
-            .unwrap_or_default();
-        if count > 0 {
-            return Err(self.error(ParseDictionaryErrorKind::MismatchedArity {
-                expected: 0,
-                actual: count,
-            }));
-        }
         Ok(true)
     }
 
@@ -872,13 +850,6 @@ impl<'text> Lines<'text> {
                     }))
                 }
             };
-            let remaining_words = words.count();
-            if remaining_words > 0 {
-                return Err(self.error(ParseDictionaryErrorKind::MismatchedArity {
-                    expected: 1,
-                    actual: 1 + remaining_words,
-                }));
-            }
 
             f(word).map_err(|kind| self.error(kind))?;
         }
@@ -932,13 +903,6 @@ impl<'text> Lines<'text> {
                     }))
                 }
             };
-            let remaining_words = words.count();
-            if remaining_words > 0 {
-                return Err(self.error(ParseDictionaryErrorKind::MismatchedArity {
-                    expected: 2,
-                    actual: 2 + remaining_words,
-                }));
-            }
 
             f(word1, word2).map_err(|kind| self.error(kind))?;
         }
@@ -1006,14 +970,6 @@ impl<'text> Lines<'text> {
             }
         };
 
-        let remaining_words = words.count();
-        if remaining_words > 0 {
-            return Err(self.error(ParseDictionaryErrorKind::MismatchedArity {
-                expected: 3,
-                actual: 3 + remaining_words,
-            }));
-        }
-
         for row in 1..=row_count {
             // Each row takes the shape:
             // PFX flag stripping prefix [condition [morphological_fields...]]