chore: replace CharIterator struct with IteratorCharExt trait (#315)

Author: joshleeb

src/utils/char_iterator.rs

@@ -1,80 +1,43 @@
-// todo: This is not good at all and very specific to it's use at the moment.
-// Over time this should be improved.
-
-pub struct CharIterator<'a> {
-  chars: std::str::Chars<'a>,
-  next_char: Option<char>,
-}
-
-impl<'a> CharIterator<'a> {
-  pub fn new(chars: std::str::Chars<'a>) -> CharIterator<'a> {
-    CharIterator { chars, next_char: None }
+use std::{iter::Peekable, str::Chars};
+
+pub trait IteratorCharExt: Iterator<Item = char> {
+  fn peek(&mut self) -> Option<&char>;
+
+  fn check_text(&mut self, text: &str) -> bool {
+    let mut text_iter = text.chars();
+    while let Some(text_ch) = text_iter.next() {
+      match self.peek() {
+        Some(ch) if *ch == text_ch => self.next(),
+        _ => return false,
+      };
+    }
+    true
   }
 
-  pub fn skip_whitespace(&mut self) {
-    while let Some(c) = self.peek_next() {
-      if !c.is_whitespace() {
-        return;
-      } else {
-        self.move_next();
-      }
-    }
+  fn skip_whitespace(&mut self) {
+    self.skip_while(char::is_whitespace);
   }
 
-  pub fn skip_spaces(&mut self) {
-    while let Some(c) = self.peek_next() {
-      if c != ' ' {
-        return;
-      } else {
-        self.move_next();
-      }
-    }
+  fn skip_spaces(&mut self) {
+    self.skip_while(|c| c == ' ');
   }
 
-  pub fn skip_all_until_new_line(&mut self) {
-    while let Some(c) = self.move_next() {
-      if c == '\r' {
-        if self.peek_next() == Some('\n') {
-          self.move_next();
-        }
-        return;
-      } else if c == '\n' {
-        return;
-      }
-    }
+  fn skip_all_until_new_line(&mut self) {
+    self.skip_while(|c| c != '\n');
   }
 
-  pub fn check_text(&mut self, text: &str) -> bool {
-    for c in text.chars() {
-      if let Some(comparison_char) = self.peek_next() {
-        if comparison_char != c {
-          return false;
-        } else {
-          self.move_next();
-        }
-      } else {
-        return false;
+  fn skip_while<P: Fn(char) -> bool>(&mut self, predicate: P) {
+    while let Some(ch) = self.peek() {
+      if !predicate(*ch) {
+        break;
       }
+      self.next();
     }
-
-    true
-  }
-
-  pub fn move_next(&mut self) -> Option<char> {
-    self.ensure_next_char();
-    let current_char = self.next_char;
-    self.next_char = self.chars.next();
-    current_char
-  }
-
-  pub fn peek_next(&mut self) -> Option<char> {
-    self.ensure_next_char();
-    self.next_char
   }
+}
 
-  fn ensure_next_char(&mut self) {
-    if self.next_char.is_none() {
-      self.next_char = self.chars.next();
-    }
+impl<'a> IteratorCharExt for Peekable<Chars<'a>> {
+  fn peek(&mut self) -> Option<&char> {
+    self.peek()
   }
 }

src/utils/file_text_has_ignore_comment.rs

@@ -1,59 +1,62 @@
+use crate::utils::char_iterator::IteratorCharExt;
+use std::{
+  iter::{Iterator, Peekable},
+  str::Chars,
+};
+
 pub fn file_text_has_ignore_comment(file_text: &str, ignore_text: &str) -> bool {
-  let mut iterator = super::CharIterator::new(file_text.chars());
+  let mut chars = file_text.chars().peekable();
 
   // skip over the shebang
   if file_text.starts_with("#!") {
-    iterator.move_next();
-    iterator.move_next();
-    iterator.skip_all_until_new_line();
+    chars.next();
+    chars.next();
+    chars.skip_all_until_new_line();
   }
 
   // now handle the comments
-  while iterator.peek_next().is_some() {
-    iterator.skip_whitespace();
-    if iterator.move_next() != Some('/') {
+  while chars.peek().is_some() {
+    chars.skip_whitespace();
+    if chars.next() != Some('/') {
       return false;
     }
-    match iterator.move_next() {
+    match chars.next() {
       Some('/') => {
-        if check_single_line_comment(&mut iterator, ignore_text) {
+        if check_single_line_comment(&mut chars, ignore_text) {
           return true;
         }
       }
       Some('*') => {
-        if check_multi_line_comment(&mut iterator, ignore_text) {
+        if check_multi_line_comment(&mut chars, ignore_text) {
           return true;
         }
       }
       _ => return false,
     }
   }
-
   return false;
 
-  fn check_single_line_comment(iterator: &mut super::CharIterator, ignore_text: &str) -> bool {
-    iterator.skip_spaces(); // only spaces, not whitespace
-    if iterator.check_text(ignore_text) {
+  fn check_single_line_comment(chars: &mut Peekable<Chars>, ignore_text: &str) -> bool {
+    chars.skip_spaces(); // only spaces, not whitespace
+    if chars.check_text(ignore_text) {
       return true;
     }
-
-    iterator.skip_all_until_new_line();
-
+    chars.skip_all_until_new_line();
     false
   }
 
-  fn check_multi_line_comment(iterator: &mut super::CharIterator, ignore_text: &str) -> bool {
-    iterator.skip_whitespace();
-    if iterator.check_text(ignore_text) {
+  fn check_multi_line_comment(chars: &mut Peekable<Chars>, ignore_text: &str) -> bool {
+    chars.skip_whitespace();
+    if chars.check_text(ignore_text) {
       return true;
     }
-    while let Some(c) = iterator.move_next() {
-      if c == '*' && iterator.peek_next() == Some('/') {
-        iterator.move_next();
+
+    while let Some(c) = chars.next() {
+      if c == '*' && chars.peek() == Some(&'/') {
+        chars.next();
         return false;
       }
     }
-
     false
   }
 }