Merge pull request #346 from YuukiToriyama/release/v0.1.5

release/v0.1.5をmainブランチにマージ

Cargo.toml

@@ -8,7 +8,7 @@ members = [
 resolver = "2"
 
 [workspace.package]
-version = "0.1.4"
+version = "0.1.5"
 edition = "2021"
 description = "A Rust Library to parse japanese addresses."
 repository = "https://github.com/YuukiToriyama/japanese-address-parser"

core/Cargo.toml

@@ -28,6 +28,5 @@ reqwest = { version = "0.12.3", default-features = false, features = ["json", "r
 serde = { version = "1.0.192", features = ["derive"] }
 
 [dev-dependencies]
-test-case = "3.3.1"
 tokio = { version = "1.38.0", features = ["rt", "macros"] }
 wasm-bindgen-test = { workspace = true }

core/src/lib.rs

@@ -7,4 +7,5 @@ pub mod api;
 pub mod entity;
 mod err;
 pub mod parser;
+mod tokenizer;
 mod util;

core/src/parser.rs

@@ -5,16 +5,22 @@ use crate::api::AsyncApi;
 use crate::api::BlockingApi;
 use crate::entity::{Address, ParseResult};
 use crate::err::{Error, ParseErrorKind};
-use crate::parser::read_city::read_city;
-use crate::parser::read_prefecture::read_prefecture;
-use crate::parser::read_town::read_town;
+use crate::tokenizer::Tokenizer;
 
-mod adapter;
-mod filter;
-mod read_city;
+pub(crate) mod adapter;
+pub(crate) mod filter;
 mod read_house_number;
-mod read_prefecture;
-mod read_town;
+
+impl<T> From<Tokenizer<T>> for Address {
+    fn from(value: Tokenizer<T>) -> Self {
+        Self {
+            prefecture: value.prefecture_name.unwrap_or("".to_string()),
+            city: value.city_name.unwrap_or("".to_string()),
+            town: value.town_name.unwrap_or("".to_string()),
+            rest: value.rest,
+        }
+    }
+}
 
 /// An asynchronous `Parser` to process addresses.
 ///
@@ -69,56 +75,61 @@ impl Parser {
 ///
 /// publicにしていますが、直接の使用は推奨されません。[Parser]の利用を検討してください。
 pub async fn parse(api: Arc<AsyncApi>, input: &str) -> ParseResult {
+    let tokenizer = Tokenizer::new(input);
     // 都道府県を特定
-    let (rest, prefecture_name) = if let Some(result) = read_prefecture(input) {
-        result
-    } else {
+    let Ok(tokenizer) = tokenizer.read_prefecture() else {
         return ParseResult {
-            address: Address::new("", "", "", input),
+            address: Address::from(tokenizer),
             error: Some(Error::new_parse_error(ParseErrorKind::Prefecture)),
         };
     };
     // その都道府県の市町村名リストを取得
-    let prefecture = match api.get_prefecture_master(prefecture_name).await {
+    let prefecture = match api
+        .get_prefecture_master(tokenizer.prefecture_name.as_ref().unwrap())
+        .await
+    {
         Err(error) => {
             return ParseResult {
-                address: Address::new(prefecture_name, "", "", rest),
+                address: Address::from(tokenizer),
                 error: Some(error),
             };
         }
         Ok(result) => result,
     };
     // 市町村名を特定
-    let (rest, city_name) = if let Some(result) = read_city(rest, prefecture) {
-        result
-    } else {
+    let Ok(tokenizer) = tokenizer.read_city(prefecture.cities) else {
         return ParseResult {
-            address: Address::new(prefecture_name, "", "", rest),
+            address: Address::from(tokenizer),
             error: Some(Error::new_parse_error(ParseErrorKind::City)),
         };
     };
     // その市町村の町名リストを取得
-    let city = match api.get_city_master(prefecture_name, &city_name).await {
+    let city = match api
+        .get_city_master(
+            tokenizer.prefecture_name.as_ref().unwrap(),
+            tokenizer.city_name.as_ref().unwrap(),
+        )
+        .await
+    {
         Err(error) => {
             return ParseResult {
-                address: Address::new(prefecture_name, &city_name, "", &rest),
+                address: Address::from(tokenizer),
                 error: Some(error),
             };
         }
         Ok(result) => result,
     };
     // 町名を特定
-    let (rest, town_name) = if let Some(result) = read_town(&rest, &city) {
-        result
-    } else {
+    let Ok(tokenizer) = tokenizer.read_town(city.towns.iter().map(|x| x.name.clone()).collect())
+    else {
         return ParseResult {
-            address: Address::new(prefecture_name, &city_name, "", &rest),
+            address: Address::from(tokenizer),
             error: Some(Error::new_parse_error(ParseErrorKind::Town)),
         };
     };
 
     ParseResult {
-        address: Address::new(prefecture_name, &city_name, &town_name, &rest),
+        address: Address::from(tokenizer),
         error: None,
     }
 }
@@ -226,54 +237,50 @@ mod tests {
 /// publicにしていますが、直接の使用は推奨されません。[Parser]の利用を検討してください。
 #[cfg(feature = "blocking")]
 pub fn parse_blocking(api: Arc<BlockingApi>, input: &str) -> ParseResult {
-    let (rest, prefecture_name) = match read_prefecture(input) {
-        None => {
-            return ParseResult {
-                address: Address::new("", "", "", input),
-                error: Some(Error::new_parse_error(ParseErrorKind::Prefecture)),
-            };
-        }
-        Some(result) => result,
+    let tokenizer = Tokenizer::new(input);
+    let Ok(tokenizer) = tokenizer.read_prefecture() else {
+        return ParseResult {
+            address: Address::from(tokenizer),
+            error: Some(Error::new_parse_error(ParseErrorKind::Prefecture)),
+        };
     };
-    let prefecture = match api.get_prefecture_master(prefecture_name) {
+    let prefecture = match api.get_prefecture_master(tokenizer.prefecture_name.as_ref().unwrap()) {
         Err(error) => {
             return ParseResult {
-                address: Address::new(prefecture_name, "", "", rest),
+                address: Address::from(tokenizer),
                 error: Some(error),
             };
         }
         Ok(result) => result,
     };
-    let (rest, city_name) = match read_city(rest, prefecture) {
-        None => {
-            return ParseResult {
-                address: Address::new(prefecture_name, "", "", rest),
-                error: Some(Error::new_parse_error(ParseErrorKind::City)),
-            };
-        }
-        Some(result) => result,
+    let Ok(tokenizer) = tokenizer.read_city(prefecture.cities) else {
+        return ParseResult {
+            address: Address::from(tokenizer),
+            error: Some(Error::new_parse_error(ParseErrorKind::City)),
+        };
     };
-    let city = match api.get_city_master(prefecture_name, &city_name) {
+    let city = match api.get_city_master(
+        tokenizer.prefecture_name.as_ref().unwrap(),
+        tokenizer.city_name.as_ref().unwrap(),
+    ) {
         Err(error) => {
             return ParseResult {
-                address: Address::new(prefecture_name, &city_name, "", &rest),
+                address: Address::from(tokenizer),
                 error: Some(error),
             };
         }
         Ok(result) => result,
     };
-    let (rest, town_name) = match read_town(&rest, &city) {
-        None => {
-            return ParseResult {
-                address: Address::new(prefecture_name, &city_name, "", &rest),
-                error: Some(Error::new_parse_error(ParseErrorKind::Town)),
-            };
-        }
-        Some(result) => result,
+    let Ok(tokenizer) = tokenizer.read_town(city.towns.iter().map(|x| x.name.clone()).collect())
+    else {
+        return ParseResult {
+            address: Address::from(tokenizer),
+            error: Some(Error::new_parse_error(ParseErrorKind::Town)),
+        };
     };
 
     ParseResult {
-        address: Address::new(prefecture_name, &city_name, &town_name, &rest),
+        address: Address::from(tokenizer),
         error: None,
     }
 }

core/src/parser/adapter/orthographical_variant_adapter.rs

@@ -28,6 +28,7 @@ pub trait OrthographicalVariants {
     const 穂: Variant;
     const 梼: Variant;
     const 葛: Variant;
+    const 蛍: Variant;
 }
 
 impl OrthographicalVariants for Variant {
@@ -53,6 +54,7 @@ impl OrthographicalVariants for Variant {
     const 穂: Variant = &["穂", "穗"];
     const 梼: Variant = &["梼", "檮"];
     const 葛: Variant = &["葛󠄀", "葛"];
+    const 蛍: Variant = &["蛍", "螢"];
 }
 
 pub struct OrthographicalVariantAdapter {