[board] Re-do the Square implementation

- Rank and file are 0-indexed values
- Add an index property, a 1D index into an array
- Add from_index() and from_algebraic_string()

board/src/square.rs

@@ -3,19 +3,20 @@
 use std::str::FromStr;
 
 #[derive(Debug)]
-struct ParseSquareError;
+pub struct ParseSquareError;
 
 #[derive(Debug)]
-struct SquareIndexOutOfBoundsError;
+pub struct SquareIndexOutOfBoundsError;
 
 #[derive(Debug, Eq, PartialEq)]
-struct Square {
-    rank: u8,
-    file: u8,
+pub struct Square {
+    pub rank: u8,
+    pub file: u8,
+    pub index: u8,
 }
 
 impl Square {
-    fn from_index(index: u8) -> Result<Square, SquareIndexOutOfBoundsError> {
+    pub fn from_index(index: u8) -> Result<Square, SquareIndexOutOfBoundsError> {
         if index >= 64 {
             return Err(SquareIndexOutOfBoundsError);
         }
@@ -23,18 +24,19 @@ impl Square {
         Ok(Square {
             rank: index / 8,
             file: index % 8,
+            index: index,
         })
     }
 
-    fn from_algebraic_string(s: &str) -> Result<Square, ParseSquareError> {
+    pub fn from_algebraic_string(s: &str) -> Result<Square, ParseSquareError> {
         s.parse()
     }
 
-    fn rank_index(&self) -> usize {
+    pub fn rank_index(&self) -> usize {
         self.rank.into()
     }
 
-    fn file_index(&self) -> usize {
+    pub fn file_index(&self) -> usize {
         self.file.into()
     }
 }
@@ -53,17 +55,21 @@ impl FromStr for Square {
             return Err(ParseSquareError);
         }
 
-        let rank = (rank_char as u8) - ('a' as u8) + 1;
-        if rank < 1 || rank > 8 {
+        let rank = (rank_char as u8) - ('a' as u8);
+        if rank >= 8 {
             return Err(ParseSquareError);
         }
 
-        let file = u8::try_from(chars[1].to_digit(10).ok_or(ParseSquareError)?)
-            .map_err(|_| ParseSquareError)?;
+        let converted_file_digit = chars[1]
+            .to_digit(10)
+            .and_then(|x| if x != 0 { Some(x) } else { None })
+            .ok_or(ParseSquareError)?;
+        let file = u8::try_from(converted_file_digit).map_err(|_| ParseSquareError)? - 1;
 
         Ok(Square {
-            rank: rank - 1,
-            file: file - 1,
+            rank: rank,
+            file: file,
+            index: rank * 8 + file,
         })
     }
 }
@@ -84,7 +90,7 @@ mod tests {
     }
 
     #[test]
-    fn parse_good_input() {
+    fn good_algebraic_input() {
         let sq1 = Square::from_algebraic_string("a4").expect("Failed to parse 'a4' square");
         assert_eq!(sq1.rank, 0);
         assert_eq!(sq1.file, 3);
@@ -94,6 +100,16 @@ mod tests {
         assert_eq!(sq2.file, 7);
     }
 
+    #[test]
+    fn bad_algebraic_input() {
+        Square::from_algebraic_string("a0").expect_err("Got valid Square for 'a0'");
+        Square::from_algebraic_string("j3").expect_err("Got valid Square for 'j3'");
+        Square::from_algebraic_string("a11").expect_err("Got valid Square for 'a11'");
+        Square::from_algebraic_string("b-1").expect_err("Got valid Square for 'b-1'");
+        Square::from_algebraic_string("a 1").expect_err("Got valid Square for 'a 1'");
+        Square::from_algebraic_string("").expect_err("Got valid Square for ''");
+    }
+
     #[test]
     fn from_index() {
         let sq1 = Square::from_index(4).expect("Unable to get Square from index");