rename Nibbler to Pig as per latest code in Taskwarrior

src/tdb2/ff4.rs

@@ -1,7 +1,7 @@
 use std::str;
 use std::io::{Result, Error, ErrorKind};
 
-use super::nibbler::Nibbler;
+use super::pig::Pig;
 use task::{TaskBuilder, Task};
 
 /// Rust implementation of part of utf8_codepoint from Taskwarrior's src/utf8.cpp
@@ -86,28 +86,28 @@ fn decode(value: String) -> String {
 ///
 /// While Taskwarrior supports additional formats, this is the only format supported by rask.
 pub(super) fn parse_ff4(line: &str) -> Result<Task> {
-    let mut nib = Nibbler::new(line.as_bytes());
+    let mut pig = Pig::new(line.as_bytes());
     let mut builder = TaskBuilder::new();
 
-    if !nib.skip(b'[') {
+    if !pig.skip(b'[') {
         return Err(Error::new(ErrorKind::Other, "bad line"));
     }
-    if let Some(line) = nib.get_until(b']') {
-        let mut nib = Nibbler::new(line);
-        while !nib.depleted() {
-            if let Some(name) = nib.get_until(b':') {
+    if let Some(line) = pig.get_until(b']') {
+        let mut pig = Pig::new(line);
+        while !pig.depleted() {
+            if let Some(name) = pig.get_until(b':') {
                 let name = str::from_utf8(name).unwrap();
-                if !nib.skip(b':') {
+                if !pig.skip(b':') {
                     return Err(Error::new(ErrorKind::Other, "bad line"));
                 }
-                if let Some(value) = nib.get_quoted(b'"') {
+                if let Some(value) = pig.get_quoted(b'"') {
                     let value = json_decode(value);
                     let value = decode(value);
                     builder = builder.set(name, value);
                 } else {
                     return Err(Error::new(ErrorKind::Other, "bad line"));
                 }
-                nib.skip(b' ');
+                pig.skip(b' ');
             } else {
                 return Err(Error::new(ErrorKind::Other, "bad line"));
             }
@@ -115,10 +115,10 @@ pub(super) fn parse_ff4(line: &str) -> Result<Task> {
     } else {
         return Err(Error::new(ErrorKind::Other, "bad line"));
     }
-    if !nib.skip(b']') {
+    if !pig.skip(b']') {
         return Err(Error::new(ErrorKind::Other, "bad line"));
     }
-    if !nib.depleted() {
+    if !pig.depleted() {
         return Err(Error::new(ErrorKind::Other, "bad line"));
     }
     Ok(builder.finish())

src/tdb2/mod.rs

@@ -1,4 +1,4 @@
-mod nibbler;
+mod pig;
 mod ff4;
 
 use std::io::{BufRead, Result};

src/tdb2/pig.rs

@@ -1,14 +1,14 @@
-//! A minimal implementation of the "Nibbler" parsing utility from the Taskwarrior
+//! A minimal implementation of the "Pig" parsing utility from the Taskwarrior
 //! source.
 
-pub struct Nibbler<'a> {
+pub struct Pig<'a> {
     input: &'a [u8],
     cursor: usize,
 }
 
-impl<'a> Nibbler<'a> {
+impl<'a> Pig<'a> {
     pub fn new(input: &'a [u8]) -> Self {
-        Nibbler {
+        Pig {
             input: input,
             cursor: 0,
         }
@@ -136,160 +136,160 @@ impl<'a> Nibbler<'a> {
 
 #[cfg(test)]
 mod test {
-    use super::Nibbler;
+    use super::Pig;
 
     #[test]
     fn test_get_until() {
         let s = b"abc:123";
-        let mut nib = Nibbler::new(s);
-        assert_eq!(nib.get_until(b':'), Some(&s[..3]));
+        let mut pig = Pig::new(s);
+        assert_eq!(pig.get_until(b':'), Some(&s[..3]));
     }
 
     #[test]
     fn test_get_until_empty() {
         let s = b"abc:123";
-        let mut nib = Nibbler::new(s);
-        assert_eq!(nib.get_until(b'a'), Some(&s[..0]));
+        let mut pig = Pig::new(s);
+        assert_eq!(pig.get_until(b'a'), Some(&s[..0]));
     }
 
     #[test]
     fn test_get_until_not_found() {
         let s = b"abc:123";
-        let mut nib = Nibbler::new(s);
-        assert_eq!(nib.get_until(b'/'), Some(&s[..]));
+        let mut pig = Pig::new(s);
+        assert_eq!(pig.get_until(b'/'), Some(&s[..]));
     }
 
     #[test]
     fn test_get_until_eos() {
         let s = b"abc:123";
-        let mut nib = Nibbler::new(s);
-        assert_eq!(nib.get_until_eos(), Some(&s[..]));
+        let mut pig = Pig::new(s);
+        assert_eq!(pig.get_until_eos(), Some(&s[..]));
     }
 
     #[test]
     fn test_get_quoted() {
         let s = b"'abcd'efg";
-        let mut nib = Nibbler::new(s);
-        assert_eq!(nib.get_quoted(b'\''), Some(&s[1..5]));
-        assert_eq!(nib.next(), Some(b'e'));
+        let mut pig = Pig::new(s);
+        assert_eq!(pig.get_quoted(b'\''), Some(&s[1..5]));
+        assert_eq!(pig.next(), Some(b'e'));
     }
 
     #[test]
     fn test_get_quoted_unopened() {
         let s = b"abcd'efg";
-        let mut nib = Nibbler::new(s);
-        assert_eq!(nib.get_quoted(b'\''), None);
-        assert_eq!(nib.next(), Some(b'a')); // nothing consumed
+        let mut pig = Pig::new(s);
+        assert_eq!(pig.get_quoted(b'\''), None);
+        assert_eq!(pig.next(), Some(b'a')); // nothing consumed
     }
 
     #[test]
     fn test_get_quoted_unclosed() {
         let s = b"'abcdefg";
-        let mut nib = Nibbler::new(s);
-        assert_eq!(nib.get_quoted(b'\''), None);
-        assert_eq!(nib.next(), Some(b'\'')); // nothing consumed
+        let mut pig = Pig::new(s);
+        assert_eq!(pig.get_quoted(b'\''), None);
+        assert_eq!(pig.next(), Some(b'\'')); // nothing consumed
     }
 
     #[test]
     fn test_get_quoted_escaped() {
         let s = b"'abc\\'de'fg";
-        let mut nib = Nibbler::new(s);
-        assert_eq!(nib.get_quoted(b'\''), Some(&s[1..8]));
-        assert_eq!(nib.next(), Some(b'f'));
+        let mut pig = Pig::new(s);
+        assert_eq!(pig.get_quoted(b'\''), Some(&s[1..8]));
+        assert_eq!(pig.next(), Some(b'f'));
     }
 
     #[test]
     fn test_get_quoted_double_escaped() {
         let s = b"'abc\\\\'de'fg";
-        let mut nib = Nibbler::new(s);
-        assert_eq!(nib.get_quoted(b'\''), Some(&s[1..6]));
-        assert_eq!(nib.next(), Some(b'd'));
+        let mut pig = Pig::new(s);
+        assert_eq!(pig.get_quoted(b'\''), Some(&s[1..6]));
+        assert_eq!(pig.next(), Some(b'd'));
     }
 
     #[test]
     fn test_get_quoted_triple_escaped() {
         let s = b"'abc\\\\\\'de'fg";
-        let mut nib = Nibbler::new(s);
-        assert_eq!(nib.get_quoted(b'\''), Some(&s[1..10]));
-        assert_eq!(nib.next(), Some(b'f'));
+        let mut pig = Pig::new(s);
+        assert_eq!(pig.get_quoted(b'\''), Some(&s[1..10]));
+        assert_eq!(pig.next(), Some(b'f'));
     }
 
     #[test]
     fn test_get_quoted_all_escapes() {
         let s = b"'\\\\\\'\\\\'fg";
-        let mut nib = Nibbler::new(s);
-        assert_eq!(nib.get_quoted(b'\''), Some(&s[1..7]));
-        assert_eq!(nib.next(), Some(b'f'));
+        let mut pig = Pig::new(s);
+        assert_eq!(pig.get_quoted(b'\''), Some(&s[1..7]));
+        assert_eq!(pig.next(), Some(b'f'));
     }
 
     #[test]
     fn test_skip_n() {
         let s = b"abc:123";
-        let mut nib = Nibbler::new(s);
-        assert!(nib.skip_n(3));
-        assert_eq!(nib.get_until_eos(), Some(&s[3..]));
+        let mut pig = Pig::new(s);
+        assert!(pig.skip_n(3));
+        assert_eq!(pig.get_until_eos(), Some(&s[3..]));
     }
 
     #[test]
     fn test_skip_n_too_long() {
         let s = b"abc:123";
-        let mut nib = Nibbler::new(s);
-        assert!(!nib.skip_n(33));
+        let mut pig = Pig::new(s);
+        assert!(!pig.skip_n(33));
         // nothing is consumed
-        assert_eq!(nib.get_until_eos(), Some(&s[..]));
+        assert_eq!(pig.get_until_eos(), Some(&s[..]));
     }
 
     #[test]
     fn test_skip_n_exact_eos() {
         let s = b"abc:123";
-        let mut nib = Nibbler::new(s);
-        assert!(nib.skip_n(7));
-        assert_eq!(nib.get_until_eos(), None);
+        let mut pig = Pig::new(s);
+        assert!(pig.skip_n(7));
+        assert_eq!(pig.get_until_eos(), None);
     }
 
     #[test]
     fn test_skip_match() {
         let s = b"foo";
-        let mut nib = Nibbler::new(s);
-        assert!(nib.skip(b'f'));
-        assert_eq!(nib.get_until_eos(), Some(&s[1..]));
+        let mut pig = Pig::new(s);
+        assert!(pig.skip(b'f'));
+        assert_eq!(pig.get_until_eos(), Some(&s[1..]));
     }
 
     #[test]
     fn test_skip_no_match() {
         let s = b"foo";
-        let mut nib = Nibbler::new(s);
-        assert!(!nib.skip(b'x'));
-        assert_eq!(nib.get_until_eos(), Some(&s[..]));
+        let mut pig = Pig::new(s);
+        assert!(!pig.skip(b'x'));
+        assert_eq!(pig.get_until_eos(), Some(&s[..]));
     }
 
     #[test]
     fn test_skip_eos() {
         let s = b"foo";
-        let mut nib = Nibbler::new(s);
-        assert!(nib.skip_n(3));
-        assert!(!nib.skip(b'x'));
+        let mut pig = Pig::new(s);
+        assert!(pig.skip_n(3));
+        assert!(!pig.skip(b'x'));
     }
 
     #[test]
     fn test_next() {
         let s = b"foo";
-        let mut nib = Nibbler::new(s);
-        assert_eq!(nib.next(), Some(b'f'));
-        assert_eq!(nib.next(), Some(b'o'));
-        assert_eq!(nib.next(), Some(b'o'));
-        assert_eq!(nib.next(), None);
-        assert_eq!(nib.next(), None);
+        let mut pig = Pig::new(s);
+        assert_eq!(pig.next(), Some(b'f'));
+        assert_eq!(pig.next(), Some(b'o'));
+        assert_eq!(pig.next(), Some(b'o'));
+        assert_eq!(pig.next(), None);
+        assert_eq!(pig.next(), None);
     }
 
     #[test]
     fn test_depleted() {
         let s = b"xy";
-        let mut nib = Nibbler::new(s);
-        assert!(!nib.depleted());
-        assert_eq!(nib.next(), Some(b'x'));
-        assert!(!nib.depleted());
-        assert_eq!(nib.next(), Some(b'y'));
-        assert!(nib.depleted());
+        let mut pig = Pig::new(s);
+        assert!(!pig.depleted());
+        assert_eq!(pig.next(), Some(b'x'));
+        assert!(!pig.depleted());
+        assert_eq!(pig.next(), Some(b'y'));
+        assert!(pig.depleted());
     }
 }