Merge pull request #135 from YuukiToriyama/feature/use-js-sys/master

JS側のRegExpを使用するをrelease/v0.1.0-beta.4にマージ

Cargo.toml

@@ -23,6 +23,7 @@ debug = []
 [dependencies]
 console_error_panic_hook = "0.1.7"
 itertools = "0.12.0"
+js-sys = "0.3.67"
 nom = "7.1.3"
 regex = "1.10.2"
 reqwest = { version = "0.11.23", default-features = false, features = ["json", "rustls-tls", "blocking"] }

src/parser/filter/invalid_town_name_format.rs

@@ -1,18 +1,23 @@
 use crate::parser::filter::Filter;
 use crate::util::converter::JapaneseNumber;
-use regex::Regex;
 
 pub struct InvalidTownNameFormatFilter {}
 
 impl Filter for InvalidTownNameFormatFilter {
+    #[cfg(not(target_arch = "wasm32"))]
     fn apply(self, input: String) -> String {
-        extract_town_name(&input).unwrap_or(input)
+        extract_town_name_with_regex(&input).unwrap_or(input)
+    }
+    #[cfg(target_arch = "wasm32")]
+    fn apply(self, input: String) -> String {
+        extract_town_name_with_js_sys_regexp(&input).unwrap_or(input)
     }
 }
 
-fn extract_town_name(input: &str) -> Option<String> {
+#[cfg(not(target_arch = "wasm32"))]
+fn extract_town_name_with_regex(input: &str) -> Option<String> {
     let expression =
-        Regex::new(r"^(?<town_name>\D+)(?<block_number>\d+)[-ー－]*(?<rest>.*)$").unwrap();
+        regex::Regex::new(r"^(?<town_name>\D+)(?<block_number>\d+)[-ー－]*(?<rest>.*)$").unwrap();
     let captures = expression.captures(input)?;
     let town_name = if let Some(matched) = captures.name("town_name") {
         matched.as_str()
@@ -36,26 +41,72 @@ fn extract_town_name(input: &str) -> Option<String> {
     Some(format!("{}{}丁目{}", town_name, block_number, rest))
 }
 
-#[cfg(test)]
-mod invalid_town_name_format_test {
-    use crate::parser::filter::invalid_town_name_format::InvalidTownNameFormatFilter;
-    use crate::parser::filter::Filter;
+#[cfg(target_arch = "wasm32")]
+fn extract_town_name_with_js_sys_regexp(input: &str) -> Option<String> {
+    let expression = js_sys::RegExp::new(r"^(\D+)(\d+)[-ー－]*(.*)$", "");
+    let captures = expression.exec(input)?;
+    let town_name = captures.get(1).as_string()?;
+    let block_number = captures
+        .get(2)
+        .as_string()?
+        .parse::<i32>()
+        .ok()?
+        .to_japanese_form()?;
+    let rest = captures
+        .get(3)
+        .as_string()
+        .unwrap_or_else(|| "".to_string());
+    Some(format!("{}{}丁目{}", town_name, block_number, rest))
+}
+
+#[cfg(all(test, not(target_arch = "wasm32")))]
+mod tests {
+    use crate::parser::filter::invalid_town_name_format::extract_town_name_with_regex;
 
     #[test]
-    fn 有楽町一丁目() {
-        let result = InvalidTownNameFormatFilter {}.apply("有楽町1".to_string());
-        assert_eq!(result, "有楽町一丁目")
+    fn extract_town_name_with_regex_success() {
+        let result = extract_town_name_with_regex("有楽町1");
+        assert!(result.is_some());
+        assert_eq!(result.unwrap(), "有楽町一丁目");
+
+        let result = extract_town_name_with_regex("有楽町1-1");
+        assert!(result.is_some());
+        assert_eq!(result.unwrap(), "有楽町一丁目1");
+
+        let result = extract_town_name_with_regex("有楽町1-1-2");
+        assert!(result.is_some());
+        assert_eq!(result.unwrap(), "有楽町一丁目1-2");
     }
+}
 
-    #[test]
-    fn 有楽町一丁目1番() {
-        let result = InvalidTownNameFormatFilter {}.apply("有楽町1-1".to_string());
-        assert_eq!(result, "有楽町一丁目1")
+#[cfg(all(test, target_arch = "wasm32"))]
+mod wasm_tests {
+    use crate::parser::filter::invalid_town_name_format::extract_town_name_with_js_sys_regexp;
+    use wasm_bindgen_test::{wasm_bindgen_test, wasm_bindgen_test_configure};
+
+    wasm_bindgen_test_configure!(run_in_browser);
+
+    #[wasm_bindgen_test]
+    fn extract_town_name_with_js_sys_regexp_success() {
+        let result = extract_town_name_with_js_sys_regexp("有楽町1");
+        assert!(result.is_some());
+        assert_eq!(result.unwrap(), "有楽町一丁目");
+
+        let result = extract_town_name_with_js_sys_regexp("有楽町1-1");
+        assert!(result.is_some());
+        assert_eq!(result.unwrap(), "有楽町一丁目1");
+
+        let result = extract_town_name_with_js_sys_regexp("有楽町1-1-2");
+        assert!(result.is_some());
+        assert_eq!(result.unwrap(), "有楽町一丁目1-2");
     }
 
-    #[test]
-    fn 有楽町一丁目1番2() {
-        let result = InvalidTownNameFormatFilter {}.apply("有楽町1-1-2".to_string());
-        assert_eq!(result, "有楽町一丁目1-2")
+    #[wasm_bindgen_test]
+    fn extract_town_name_with_js_sys_regexp_fail() {
+        let result = extract_town_name_with_js_sys_regexp("1-1");
+        assert!(result.is_none());
+
+        let result = extract_town_name_with_js_sys_regexp("有楽町");
+        assert!(result.is_none());
     }
 }

src/parser/filter/non_kanji_block_number.rs

@@ -1,24 +1,101 @@
-use regex::Regex;
-
 use crate::parser::filter::Filter;
 use crate::util::converter::JapaneseNumber;
 
 pub struct NonKanjiBlockNumberFilter {}
 
 impl Filter for NonKanjiBlockNumberFilter {
+    #[cfg(not(target_arch = "wasm32"))]
+    fn apply(self, input: String) -> String {
+        filter_with_regex(input)
+    }
+    #[cfg(target_arch = "wasm32")]
     fn apply(self, input: String) -> String {
-        let expression = Regex::new(r"\D+(?<block_number>\d+)丁目").unwrap();
-        match expression.captures(&input) {
-            Some(captures) => {
-                let capture_block_number = &captures.name("block_number").unwrap().as_str();
-                let block_number = capture_block_number.parse::<i32>().unwrap();
-                input.replacen(
-                    capture_block_number,
-                    block_number.to_japanese_form().unwrap().as_str(),
-                    1,
-                )
-            }
-            None => input,
+        filter_with_js_sys_regexp(input)
+    }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+fn filter_with_regex(input: String) -> String {
+    let expression = regex::Regex::new(r"\D+(?<block_number>\d+)丁目").unwrap();
+    match expression.captures(&input) {
+        Some(captures) => {
+            let capture_block_number = &captures.name("block_number").unwrap().as_str();
+            let block_number = match capture_block_number.parse::<i32>() {
+                Ok(x) => x,
+                Err(_) => return input,
+            };
+            input.replacen(
+                capture_block_number,
+                block_number.to_japanese_form().unwrap().as_str(),
+                1,
+            )
         }
+        None => input,
+    }
+}
+
+#[cfg(target_arch = "wasm32")]
+fn filter_with_js_sys_regexp(input: String) -> String {
+    let expression = js_sys::RegExp::new(r"\D+(\d+)丁目", "");
+    match expression.exec(&input) {
+        Some(result) => {
+            let capture_block_number = match result.get(1).as_string() {
+                Some(x) => x,
+                None => return input,
+            };
+            let block_number = match capture_block_number.parse::<i32>() {
+                Ok(x) => x,
+                Err(_) => return input,
+            };
+            let block_number_in_japanese_form = match block_number.to_japanese_form() {
+                Some(x) => x,
+                None => return input,
+            };
+            input.replacen(&capture_block_number, &block_number_in_japanese_form, 1)
+        }
+        None => input,
+    }
+}
+
+#[cfg(all(test, not(target_arch = "wasm32")))]
+mod tests {
+    use crate::parser::filter::non_kanji_block_number::filter_with_regex;
+
+    #[test]
+    fn filter_with_regex_成功() {
+        let result = filter_with_regex("銀座1丁目".to_string());
+        assert_eq!(result, "銀座一丁目");
+    }
+
+    #[test]
+    fn filter_with_regex_失敗() {
+        let result = filter_with_regex("銀座１丁目".to_string());
+        assert_ne!(result, "銀座一丁目");
+    }
+}
+
+#[cfg(all(test, target_arch = "wasm32"))]
+mod wasm_tests {
+    use crate::parser::filter::non_kanji_block_number::filter_with_js_sys_regexp;
+    use wasm_bindgen_test::{wasm_bindgen_test, wasm_bindgen_test_configure};
+
+    wasm_bindgen_test_configure!(run_in_browser);
+
+    #[wasm_bindgen_test]
+    fn filter_with_js_sys_regexp_input_value_will_be_filtered() {
+        let result = filter_with_js_sys_regexp("銀座1丁目".to_string());
+        assert_eq!(result, "銀座一丁目");
+
+        let result = filter_with_js_sys_regexp("銀座1丁目1-1".to_string());
+        assert_eq!(result, "銀座一丁目1-1");
+    }
+
+    #[wasm_bindgen_test]
+    fn filter_with_js_sys_regexp_return_original_value() {
+        let result = filter_with_js_sys_regexp("銀座A丁目".to_string());
+        assert_eq!(result, "銀座A丁目");
+
+        let result = filter_with_js_sys_regexp("銀座2147483648丁目".to_string());
+        assert_eq!(result, "銀座2147483648丁目");
     }
 }

src/parser/read_house_number.rs

@@ -1,8 +1,7 @@
-use regex::Regex;
-
 #[allow(dead_code)]
-pub fn read_house_number(input: &str) -> Option<(String, String)> {
-    let expression = Regex::new(r"(?<house_number>\d+)\D*(?<rest>.*)$").unwrap();
+#[cfg(not(target_arch = "wasm32"))]
+fn read_house_number_with_regex(input: &str) -> Option<(String, String)> {
+    let expression = regex::Regex::new(r"(?<house_number>\d+)\D*(?<rest>.*)$").unwrap();
     let captures = expression.captures(input)?;
     let house_number = if let Some(matched) = captures.name("house_number") {
         matched.as_str()
@@ -17,20 +16,52 @@ pub fn read_house_number(input: &str) -> Option<(String, String)> {
     Some((rest.to_string(), format!("{}番", house_number)))
 }
 
-#[cfg(test)]
-mod read_house_number_tests {
-    use crate::parser::read_house_number::read_house_number;
+#[allow(dead_code)]
+#[cfg(target_arch = "wasm32")]
+fn read_house_number_with_js_sys_regexp(input: &str) -> Option<(String, String)> {
+    let expression = js_sys::RegExp::new(r"(?<house_number>\d+)\D*(?<rest>.*)$", "");
+    let captures = expression.exec(input)?;
+    let house_number = captures.get(1).as_string()?;
+    let rest = captures
+        .get(2)
+        .as_string()
+        .unwrap_or_else(|| "".to_string());
+    Some((rest, format!("{}番", house_number)))
+}
+
+#[cfg(all(test, not(target_arch = "wasm32")))]
+mod tests {
+    use crate::parser::read_house_number::read_house_number_with_regex;
 
     #[test]
     fn read_house_number_1番() {
-        let (rest, house_number) = read_house_number("1").unwrap();
+        let (rest, house_number) = read_house_number_with_regex("1").unwrap();
         assert_eq!(house_number, "1番");
         assert_eq!(rest, "");
     }
 
     #[test]
     fn read_house_number_3番2() {
-        let (rest, house_number) = read_house_number("3-2").unwrap();
+        let (rest, house_number) = read_house_number_with_regex("3-2").unwrap();
+        assert_eq!(house_number, "3番");
+        assert_eq!(rest, "2");
+    }
+}
+
+#[cfg(all(test, target_arch = "wasm32"))]
+mod wasm_tests {
+    use crate::parser::read_house_number::read_house_number_with_js_sys_regexp;
+    use wasm_bindgen_test::{wasm_bindgen_test, wasm_bindgen_test_configure};
+
+    wasm_bindgen_test_configure!(run_in_browser);
+
+    #[wasm_bindgen_test]
+    fn read_house_number_with_js_sys_regexp_success() {
+        let (rest, house_number) = read_house_number_with_js_sys_regexp("1").unwrap();
+        assert_eq!(house_number, "1番");
+        assert_eq!(rest, "");
+
+        let (rest, house_number) = read_house_number_with_js_sys_regexp("3-2").unwrap();
         assert_eq!(house_number, "3番");
         assert_eq!(rest, "2");
     }