Merge pull request #7 from mwln/examples-lib

update `puz.md` and improve some code logic.

Author: mwln

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
-name = "puz"
-version = "0.1.0"
+name = "puz_rs"
+version = "0.1.2"
 edition = "2021"
 
 [lib]
@@ -10,7 +10,10 @@ crate-type = ["cdylib", "rlib"]
 wasm-bindgen-futures = "0.4.37"
 wasm-bindgen = "0.2.87"
 gloo-file = {version = "0.3.0", features = ['futures'] }
-js-sys = "0.3.64"
-web-sys = { version = "0.3.64", features = ['File', 'FileReader', 'Blob', 'console'] }
+web-sys = { version = "0.3.64", features = ['File'] }
 byteorder = "1.4.3"
 serde_json = "1.0.107"
+
+[profile.release]
+lto = true
+opt-level = 's'

Cargo.toml

@@ -1,4 +1,4 @@
-use puz::parse_puz;
+use puz_rs::parse_puz;
 use std::{
     fs::File,
     io::{ErrorKind, Write},

examples/data/misc.puz

@@ -15,11 +15,8 @@ enum ExtraKind {
     GEXT,
 }
 
-#[derive(Debug)]
-enum BoardKind {
-    Blank,
-    Solution,
-}
+const FREE_SQUARE: char = '-';
+const TAKEN_SQUARE: char = '.';
 
 const EXTRAS: [(&str, ExtraKind); 3] = [
     ("GRBS", ExtraKind::GRBS),
@@ -28,13 +25,13 @@ const EXTRAS: [(&str, ExtraKind); 3] = [
 ];
 
 #[wasm_bindgen]
-pub async fn read_file(file: web_sys::File) -> JsValue {
+pub async fn read_file(file: web_sys::File) -> String {
     let data = gloo_file::futures::read_as_bytes(&file.into())
         .await
         .expect_throw("Error while reading the file");
     return match parse_puz(data.as_slice()) {
-        Ok(parsed) => JsValue::from_str(&parsed.to_string()),
-        Err(e) => JsValue::from_str(&e.to_string()),
+        Ok(parsed) => parsed.to_string(),
+        Err(e) => e.to_string(),
     };
 }
 
@@ -57,61 +54,55 @@ pub fn parse_puz(buffer: impl Read) -> std::io::Result<Value> {
         (0x02, None, "unknown_bitmask"),
         (0x02, None, "scrambled_tag"),
     ];
-    let mut header_data: Vec<(&str, String)> = vec![];
-    for (offset, conversion, label) in header_offsets.iter() {
+
+    let mut header_data: Vec<usize> = vec![];
+    for (offset, conversion, _) in header_offsets.iter() {
         let mut buffer = vec![0; *offset];
         reader.read_exact(&mut buffer)?;
         if let Some(c_type) = conversion {
             match c_type {
-                PieceKind::Natural => header_data.push((label, buffer[0].to_string())),
-                PieceKind::Number => {
-                    header_data.push((label, LittleEndian::read_u16(&buffer).to_string()))
-                }
+                PieceKind::Natural => header_data.push(buffer[0] as usize),
+                PieceKind::Number => header_data.push(LittleEndian::read_u16(&buffer) as usize),
             }
         }
     }
 
-    let width = header_data[0]
-        .1
-        .parse::<usize>()
-        .expect("Width was unable to be converted to a number.");
-    let height = header_data[1]
-        .1
-        .parse::<usize>()
-        .expect("Height was unable to be converted to a number.");
+    let width = header_data[0];
+    let height = header_data[1];
     let board_size = width * height;
 
-    let mut board_data: Vec<(&BoardKind, String)> = vec![];
-    let boards = vec![BoardKind::Solution, BoardKind::Blank];
-    for board in boards.iter() {
+    let mut boards = Vec::new();
+    // [solution, blank]
+    for _ in 0..2 {
         let mut buffer = vec![0; board_size];
         reader.read_exact(&mut buffer)?;
         if let Ok(s) = std::str::from_utf8(&buffer) {
-            board_data.push((board, s.to_owned()));
-        } else {
-            println!("Board (type: {:?}) could not read from the buffer.", board);
+            boards.push(
+                s.chars()
+                    .collect::<Vec<char>>()
+                    .chunks(width)
+                    .map(|chunk| chunk.iter().collect::<String>())
+                    .collect::<Vec<String>>(),
+            )
         }
     }
 
-    let mut info_data: Vec<(&str, String)> = vec![];
-    let info_items = vec!["title", "author", "copyright"];
-    for item in info_items.iter() {
-        info_data.push((item, read_string_till_nul(&mut reader)));
+    // [title, author, copyright, note]
+    let mut info_data = Vec::new();
+    for _ in 0..3 {
+        info_data.push(read_string_till_nul(&mut reader));
     }
 
-    let num_clues = header_data[2]
-        .1
-        .parse::<usize>()
-        .expect("Cannot parse number of clues as a number.");
+    let num_clues = header_data[2];
     let mut clue_data: Vec<String> = vec![];
     for _ in 1..=num_clues {
         clue_data.push(read_string_till_nul(&mut reader))
     }
 
-    // add in the note that's at the end of the clues
-    info_data.push(("note", read_string_till_nul(&mut reader)));
+    // add note after clues
+    info_data.push(read_string_till_nul(&mut reader));
 
-    let mut extras_data: Vec<u8> = Vec::new();
+    let mut extras_data = Vec::new();
     reader.read_to_end(&mut extras_data)?;
 
     let mut grbs = Vec::new();
@@ -155,64 +146,34 @@ pub fn parse_puz(buffer: impl Read) -> std::io::Result<Value> {
         }
     }
 
-    let mut empty: Vec<String> = Vec::new();
-    let mut solution: Vec<String> = Vec::new();
     let mut clues: Vec<Vec<Vec<String>>> =
         vec![vec![vec![String::new(), String::new()]; width]; height];
 
-    for (kind, data) in board_data.iter() {
-        let mut board_rows = data
-            .chars()
-            .collect::<Vec<char>>()
-            .chunks(15)
-            .map(|chunk| chunk.iter().collect::<String>())
-            .collect::<Vec<String>>();
-
-        match kind {
-            BoardKind::Blank => empty.append(&mut board_rows),
-            BoardKind::Solution => solution.append(&mut board_rows),
-        }
-    }
-
     for (row, cols) in clues.iter_mut().enumerate() {
         for (col, clue_tuple) in cols.iter_mut().enumerate() {
-            if let Some(current_tile) = empty[row].chars().nth(col) {
-                if current_tile != '.' {
-                    if row == 0 {
-                        clue_tuple[0] = clue_data.remove(0);
-                    } else {
-                        if let Some(square) = empty[row - 1].chars().nth(col) {
-                            if square == '.' {
-                                clue_tuple[0] = clue_data.remove(0);
-                            }
-                        }
-                    }
-                    if col == 0 {
-                        clue_tuple[1] = clue_data.remove(0);
-                    } else {
-                        if let Some(square) = empty[row].chars().nth(col - 1) {
-                            if square == '.' {
-                                clue_tuple[1] = clue_data.remove(0);
-                            }
-                        }
-                    }
-                }
+            if cell_needs_across_clue(&boards[1], row, col) {
+                clue_tuple[0] = clue_data.remove(0);
+            }
+            if cell_needs_down_clue(&boards[1], row, col) {
+                clue_tuple[1] = clue_data.remove(0);
             }
         }
     }
 
     let puz = json!({
         "info": {
-            "title": info_data[0].1,
-            "author": info_data[1].1,
+            "title": info_data[0],
+            "author": info_data[1],
+            "copyright": info_data[2],
+            "note": info_data[3],
         },
         "size": {
             "width": width,
             "height": height,
         },
         "boards": {
-            "blank": empty,
-            "solution": solution,
+            "blank": boards[1],
+            "solution": boards[0],
         },
         "clues": clues,
         "extras": {
@@ -225,6 +186,42 @@ pub fn parse_puz(buffer: impl Read) -> std::io::Result<Value> {
     Ok(puz)
 }
 
+fn cell_needs_across_clue(board: &Vec<String>, row: usize, col: usize) -> bool {
+    if let Some(this_square) = &board[row].chars().nth(col) {
+        if this_square == &FREE_SQUARE {
+            if let Some(next_square) = &board[row].chars().nth(col + 1) {
+                if next_square == &FREE_SQUARE {
+                    if col == 0 {
+                        return true;
+                    } else if let Some(previous_square) = &board[row].chars().nth(col - 1) {
+                        return previous_square == &TAKEN_SQUARE;
+                    }
+                }
+            }
+        }
+    }
+    false
+}
+
+fn cell_needs_down_clue(board: &Vec<String>, row: usize, col: usize) -> bool {
+    if let Some(this_square) = &board[row].chars().nth(col) {
+        if this_square == &FREE_SQUARE {
+            if let Some(next_row) = board.get(row + 1) {
+                if let Some(next_square) = &next_row.chars().nth(col) {
+                    if next_square == &FREE_SQUARE {
+                        if row == 0 {
+                            return true;
+                        } else if let Some(previous_square) = &board[row - 1].chars().nth(col) {
+                            return previous_square == &TAKEN_SQUARE;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    false
+}
+
 fn read_string_till_nul(reader: &mut BufReader<impl Read>) -> String {
     let mut text = String::new();
     loop {