Skip to main content

salary_parser_jp/
normalize.rs

1//! 給与テキストの正規化。
2//!
3//! 求人票の実データで鍛えられた置換パターン群を、正規表現ループではなく
4//! 「文字正規化 → トークン列の書き換えパス」として実装している。panic 経路を
5//! 持たず、1 パスあたり線形時間で完了する。
6//!
7//! 出力の不変条件は次の 2 つ。
8//!
9//! 1. **金額表現は** `N円` / `N円~` / `N円~M円` のいずれかに揃う(N, M は半角数字列)
10//! 2. **金額でない数値は金額の形にしない**。時刻(`9:00~18:00`)や郵便番号
11//!    (`〒150~0001`)へ「円」を補うと、後段が給与として拾ってしまうため
12
13/// 範囲区切りの正準文字。`〜` `-` `以上` などはすべてこの文字へ揃える。
14pub(crate) const RANGE_CHAR: char = '~';
15
16/// 「万」展開で桁合わせに使う倍率(1 万 = 10,000 円)。
17const MAN_YEN: u64 = 10_000;
18/// 「千」展開で桁合わせに使う倍率(1 千 = 1,000 円)。
19const SEN_YEN: u64 = 1_000;
20/// 「億」展開で桁合わせに使う倍率(1 億 = 100,000,000 円)。
21const OKU_YEN: u64 = 100_000_000;
22/// 「x.y万」の小数部が取り得る最大桁数(万 = 10^4 の位取りに収まる範囲)。
23const MAX_MAN_FRACTION_DIGITS: usize = 4;
24/// 「x.y億」の小数部が取り得る最大桁数(億 = 10^8 の位取りに収まる範囲)。
25const MAX_OKU_FRACTION_DIGITS: usize = 8;
26/// 「x万y千」の「千」の直前に許す桁数。2 桁以上(例: `2万55千`)は
27/// 千の位取りに収まらない破損データとみなし、展開しない。
28const MAX_SEN_DIGITS: usize = 1;
29/// 数値を区切るだけで通貨の文脈を持たない記号。
30///
31/// 末尾の数値へ「円」を補ってよいかの判定から除外する。これらしか含まない
32/// 並び(例: `9:00~18:00`)は金額表現ではないため、補うと時刻が金額に化ける。
33const STRUCTURAL_CHARS: [char; 4] = [':', RANGE_CHAR, '?', '.'];
34
35/// 正規化途中のトークン。数字の連続を 1 トークンに束ね、それ以外は 1 文字ずつ持つ。
36#[derive(Clone)]
37enum Tok {
38    /// 半角数字の連続(先頭 0 も保持)。
39    Num(String),
40    /// 数字以外の 1 文字。
41    Ch(char),
42}
43
44/// 給与テキストを解析用の正準形へ正規化する。
45///
46/// 全角数字・記号ゆれ・カンマ区切り・「万円」「千円」表記・「以上」などを
47/// 半角数字と `円` / `~` に揃える。解析に不要な装飾記号と空白は取り除く。
48///
49/// 金額表現は `N円` / `N円~` / `N円~M円` のいずれか(N, M は半角数字列)へ揃うため、
50/// [`SalaryParser::parse`](crate::SalaryParser::parse) がどの金額をどう読んだかを、
51/// この関数の出力と突き合わせて監査できる。金額以外の語は種別語の判定に必要なので
52/// 残る点に注意(下の「賞与」のように、数値だけが落ちる)。
53///
54/// 金額でない数値には「円」を補わない。時刻や郵便番号を金額の形にすると
55/// 後段が給与として拾ってしまうため、そこは原文の並びのまま残す。
56///
57/// ```
58/// use salary_parser_jp::normalize;
59///
60/// // 万の展開と範囲区切りの正準化
61/// assert_eq!(normalize("月給21万円〜26万円"), "月給210000円~260000円");
62/// // 「以上」は上限のない範囲へ
63/// assert_eq!(normalize("時給1,200円以上"), "時給1200円~");
64/// // 範囲の右側にだけ付いた単位は左へ分配する
65/// assert_eq!(normalize("年収300〜400万円"), "年収3000000円~4000000円");
66/// // 装飾記号・空白の除去と全角数字の半角化
67/// assert_eq!(normalize("【月給】 210000円"), "月給210000円");
68/// // 賞与などの給与外数値は落とす(語そのものは残る)
69/// assert_eq!(normalize("月給20万円(賞与年2回)"), "月給200000円賞与");
70/// ```
71#[must_use]
72pub fn normalize(text: &str) -> String {
73    let mapped: String = text.chars().filter_map(map_char).collect();
74    // 「以上」は下限のみ指定の意味なので範囲区切りへ揃える
75    let mapped = mapped.replace("以上", "~");
76    // 数字以外の文脈(種別語・万・円記号・カンマなど)が 1 つでもあれば、
77    // 末尾に残った数値へ「円」を補ってよいと判断する。ただし区切り記号は
78    // 文脈に数えない。数えると「9:00~18:00」のような区切りだけの並びが
79    // 通貨表記とみなされ、末尾へ「円」が付いてしまう
80    let has_context = mapped
81        .chars()
82        .any(|c| !c.is_ascii_digit() && !STRUCTURAL_CHARS.contains(&c));
83    let toks = tokenize(&mapped);
84    let toks = strip_colons(&toks);
85    let toks = merge_comma_runs(toks);
86    let toks = strip_bonus_noise(&toks);
87    let toks = rewrite_yen_symbol(&toks);
88    let toks = distribute_range_man(&toks);
89    let toks = expand_oku(&toks);
90    let toks = expand_man(&toks);
91    let toks = rewrite_mojibake_range(toks);
92    let toks = align_units(&toks, has_context);
93    render(&toks)
94}
95
96/// 文字単位の正規化。`None` は削除を意味する。
97fn map_char(c: char) -> Option<char> {
98    if c.is_whitespace() {
99        return None;
100    }
101    match c {
102        // 全角数字(U+FF10〜FF19)→ 半角
103        '\u{FF10}' => Some('0'),
104        '\u{FF11}' => Some('1'),
105        '\u{FF12}' => Some('2'),
106        '\u{FF13}' => Some('3'),
107        '\u{FF14}' => Some('4'),
108        '\u{FF15}' => Some('5'),
109        '\u{FF16}' => Some('6'),
110        '\u{FF17}' => Some('7'),
111        '\u{FF18}' => Some('8'),
112        '\u{FF19}' => Some('9'),
113        // カンマ類(数字間の桁区切りとしてのみ後段で消費される)。\u{FF0C} は全角カンマ
114        ',' | '、' | '、' | '\u{FF0C}' => Some(','),
115        // 小数点類。\u{FF0E} は全角ピリオド
116        '.' | '\u{FF0E}' => Some('.'),
117        // 範囲区切り類(チルダ・ハイフン一族)→ 正準形。\u{FF0D} は全角ハイフン
118        '~' | '~' | '〜' | '-' | '‐' | '‑' | '–' | '—' | '−' | '\u{FF0D}' => {
119            Some(RANGE_CHAR)
120        }
121        // エンコード破損由来の「?」区切りは数字間の場合のみ後段で範囲扱いする
122        '?' | '\u{FF1F}' => Some('?'),
123        // 円記号 → 後段で「円」へ揃える
124        '¥' | '¥' => Some('¥'),
125        // 装飾記号は削除。
126        // \u{FF08}\u{FF09} は全角括弧、\u{FF1A}\u{FF1B} は全角コロン・セミコロン
127        '☆' | '★' | '【' | '】' | '[' | ']' | '(' | ')' | '\u{FF08}' | '\u{FF09}' | '≪' | '≫'
128        | '《' | '》' | '〈' | '〉' | '「' | '」' | '『' | '』' | ';' | '\u{FF1B}' | '・'
129        | '\\' | '※' => None,
130        // コロンは一律削除しない。「時給:1200円」の区切りは不要だが、
131        // 「9:00~18:00」で消すと数字が連結し架空の金額(900)になるため、
132        // 数字に挟まれた場合だけ barrier として残す(strip_colons が判定)
133        ':' | '\u{FF1A}' => Some(':'),
134        _ => Some(c),
135    }
136}
137
138/// 数字の連続を 1 トークンへ束ねる。
139fn tokenize(s: &str) -> Vec<Tok> {
140    let mut toks: Vec<Tok> = Vec::new();
141    for c in s.chars() {
142        if c.is_ascii_digit() {
143            if let Some(Tok::Num(run)) = toks.last_mut() {
144                run.push(c);
145            } else {
146                toks.push(Tok::Num(c.to_string()));
147            }
148        } else {
149            toks.push(Tok::Ch(c));
150        }
151    }
152    toks
153}
154
155/// 数字に挟まれていないコロンを落とす。
156///
157/// 「時給:1200円」の区切りコロンは解析に不要なので削除するが、
158/// 「9:00~18:00」のような時刻表記でも消すと数字が連結して `900` という
159/// 実在しうる時給額に化け、勤務時間が給与として誤読される。数字に挟まれた
160/// コロンだけは残し、数字連結を防ぐ barrier として機能させる。
161fn strip_colons(toks: &[Tok]) -> Vec<Tok> {
162    let mut out: Vec<Tok> = Vec::new();
163    for (i, tok) in toks.iter().enumerate() {
164        if matches!(tok, Tok::Ch(':')) {
165            let between_digits = matches!(out.last(), Some(Tok::Num(_)))
166                && matches!(toks.get(i + 1), Some(Tok::Num(_)));
167            if !between_digits {
168                continue;
169            }
170        }
171        out.push(tok.clone());
172    }
173    out
174}
175
176/// 数字に挟まれたカンマを桁区切りとして除去し、数字列を結合する。
177/// `1,000,000` のような連鎖にも対応する。
178fn merge_comma_runs(toks: Vec<Tok>) -> Vec<Tok> {
179    let mut out: Vec<Tok> = Vec::new();
180    let mut it = toks.into_iter().peekable();
181    while let Some(tok) = it.next() {
182        match tok {
183            Tok::Ch(',') => {
184                if let (Some(Tok::Num(run)), Some(Tok::Num(_))) = (out.last_mut(), it.peek()) {
185                    if let Some(Tok::Num(next)) = it.next() {
186                        run.push_str(&next);
187                    }
188                } else {
189                    out.push(Tok::Ch(','));
190                }
191            }
192            other => out.push(other),
193        }
194    }
195    out
196}
197
198/// 賞与などの給与外数値を除去する(「年n回」「nヵ月」の形)。
199/// `年2回` と `4.45ヶ月分` のような表現をトークン列から落とす。
200fn strip_bonus_noise(toks: &[Tok]) -> Vec<Tok> {
201    let mut out: Vec<Tok> = Vec::new();
202    let mut i = 0;
203    while i < toks.len() {
204        // 「年 <数> 回」
205        if let (Some(Tok::Ch('年')), Some(Tok::Num(_)), Some(Tok::Ch('回'))) =
206            (toks.get(i), toks.get(i + 1), toks.get(i + 2))
207        {
208            i += 3;
209            continue;
210        }
211        // 「<数> [. <数>] (ヶ|ヵ|カ|か|ケ) 月 [分]」
212        if let Some(Tok::Num(_)) = toks.get(i) {
213            let mut j = i + 1;
214            if let (Some(Tok::Ch('.')), Some(Tok::Num(_))) = (toks.get(j), toks.get(j + 1)) {
215                j += 2;
216            }
217            if let (Some(Tok::Ch(counter)), Some(Tok::Ch('月'))) = (toks.get(j), toks.get(j + 1))
218                && matches!(counter, 'ヶ' | 'ヵ' | 'カ' | 'か' | 'ケ')
219            {
220                j += 2;
221                if let Some(Tok::Ch('分')) = toks.get(j) {
222                    j += 1;
223                }
224                i = j;
225                continue;
226            }
227        }
228        if let Some(tok) = toks.get(i) {
229            out.push(tok.clone());
230        }
231        i += 1;
232    }
233    out
234}
235
236/// `¥N` → `N円`。
237///
238/// 直後に「万」「千」「.」が続く場合(例: `¥20万`)は円を補わず記号だけを
239/// 落とし、万の展開後に単位揃えへ委ねる。
240fn rewrite_yen_symbol(toks: &[Tok]) -> Vec<Tok> {
241    let mut out: Vec<Tok> = Vec::new();
242    let mut i = 0;
243    while i < toks.len() {
244        if let (Some(Tok::Ch('¥')), Some(Tok::Num(run))) = (toks.get(i), toks.get(i + 1)) {
245            out.push(Tok::Num(run.clone()));
246            let needs_yen = !matches!(toks.get(i + 2), Some(Tok::Ch('円' | '万' | '千' | '.')));
247            if needs_yen {
248                out.push(Tok::Ch('円'));
249            }
250            i += 2;
251            continue;
252        }
253        if let Some(Tok::Ch('¥')) = toks.get(i) {
254            // 数字を伴わない円記号は情報を持たないため落とす
255            i += 1;
256            continue;
257        }
258        if let Some(tok) = toks.get(i) {
259            out.push(tok.clone());
260        }
261        i += 1;
262    }
263    out
264}
265
266/// 範囲の右側にだけ付いた「万」を左側の数値へも分配する
267/// (「20~25万円」→「20万~25万円」)。
268///
269/// 求人票で頻出の「月給20〜25万円」「年収300〜400万円」形への対応。区切りは
270/// 正準の `~` に加え、後段で範囲へ救済される数字間の `?` も対象にする。
271/// 右側は `<数> [. <数>] 万` の形のみ認め、「万」を左の数値の直後へ補って
272/// 続く [`expand_man`] の展開へ委ねる(左側の小数もそのまま展開される)。
273fn distribute_range_man(toks: &[Tok]) -> Vec<Tok> {
274    let mut out: Vec<Tok> = Vec::new();
275    for (i, tok) in toks.iter().enumerate() {
276        out.push(tok.clone());
277        if !matches!(tok, Tok::Num(_)) {
278            continue;
279        }
280        let Some(Tok::Ch(sep)) = toks.get(i + 1) else {
281            continue;
282        };
283        if !matches!(*sep, RANGE_CHAR | '?') {
284            continue;
285        }
286        let Some(Tok::Num(_)) = toks.get(i + 2) else {
287            continue;
288        };
289        let mut j = i + 3;
290        if let (Some(Tok::Ch('.')), Some(Tok::Num(_))) = (toks.get(j), toks.get(j + 1)) {
291            j += 2;
292        }
293        if matches!(toks.get(j), Some(Tok::Ch('万'))) {
294            out.push(Tok::Ch('万'));
295        }
296    }
297    out
298}
299
300/// 単位展開で得た金額を出力し、直後が「円」でなければ補う。
301///
302/// 単位(万・億・千)から換算した値は必ず円建てなので、範囲の右側がどんな形でも
303/// 独立して「円」を確定できる。これを展開側で行わないと、`20万~応相談` のように
304/// 右側が金額でない場合に左側の単位が失われる。
305fn push_expanded(out: &mut Vec<Tok>, value: u64, next: Option<&Tok>) {
306    out.push(Tok::Num(value.to_string()));
307    if !matches!(next, Some(Tok::Ch('円'))) {
308        out.push(Tok::Ch('円'));
309    }
310}
311
312/// 「億」を桁へ展開する。
313///
314/// - `1.5億` → `150000000`(小数は億の位取りへ換算)
315/// - `1億2000万` → `120000000`(億の後の万を合算)
316/// - `1億` → `100000000`
317///
318/// 年収 1 億円級の役員求人向け。[`expand_man`] より先に走らせることで、
319/// 「億」の後ろの「万」を先に消費されずに合算できる。桁あふれする破損データは
320/// 展開せず原文のまま残し、金額として読まれないことで fail-closed とする。
321fn expand_oku(toks: &[Tok]) -> Vec<Tok> {
322    let mut out: Vec<Tok> = Vec::new();
323    let mut i = 0;
324    while i < toks.len() {
325        if let Some(Tok::Num(whole)) = toks.get(i) {
326            // 「<数> . <数> 億」
327            if let (Some(Tok::Ch('.')), Some(Tok::Num(frac)), Some(Tok::Ch('億'))) =
328                (toks.get(i + 1), toks.get(i + 2), toks.get(i + 3))
329                && let Some(value) =
330                    unit_with_fraction(whole, frac, OKU_YEN, MAX_OKU_FRACTION_DIGITS)
331            {
332                push_expanded(&mut out, value, toks.get(i + 4));
333                i += 4;
334                continue;
335            }
336            if let Some(Tok::Ch('億')) = toks.get(i + 1) {
337                // 「<数> 億 <数> 万」
338                if let (Some(Tok::Num(man)), Some(Tok::Ch('万'))) =
339                    (toks.get(i + 2), toks.get(i + 3))
340                    && let Some(value) = oku_with_man(whole, man)
341                {
342                    push_expanded(&mut out, value, toks.get(i + 4));
343                    i += 4;
344                    continue;
345                }
346                // 「<数> 億」単独。直後に数値が続く場合は展開すると桁が連結して
347                // 架空の金額になるため展開しない([`expand_man`] と同じ理由)
348                if !matches!(toks.get(i + 2), Some(Tok::Num(_)))
349                    && let Some(value) = parse_u64(whole).and_then(|w| w.checked_mul(OKU_YEN))
350                {
351                    push_expanded(&mut out, value, toks.get(i + 2));
352                    i += 2;
353                    continue;
354                }
355            }
356        }
357        if let Some(tok) = toks.get(i) {
358            out.push(tok.clone());
359        }
360        i += 1;
361    }
362    out
363}
364
365/// 「万」「千」を桁へ展開する。
366///
367/// - `21.5万` → `215000`(小数は万の位取りへ換算)
368/// - `21万5千` → `215000`
369/// - `21万5000円` → `215000円`(万の後の端数を合算)
370/// - `21万` → `210000`
371///
372/// 桁あふれする破損データは展開せずそのまま残し、後段の抽出で
373/// 金額として読まれないことにより fail-closed とする。
374fn expand_man(toks: &[Tok]) -> Vec<Tok> {
375    let mut out: Vec<Tok> = Vec::new();
376    let mut i = 0;
377    while i < toks.len() {
378        if let Some(Tok::Num(whole)) = toks.get(i) {
379            // 「<数> . <数> 万」
380            if let (Some(Tok::Ch('.')), Some(Tok::Num(frac)), Some(Tok::Ch('万'))) =
381                (toks.get(i + 1), toks.get(i + 2), toks.get(i + 3))
382                && let Some(value) =
383                    unit_with_fraction(whole, frac, MAN_YEN, MAX_MAN_FRACTION_DIGITS)
384            {
385                push_expanded(&mut out, value, toks.get(i + 4));
386                i += 4;
387                continue;
388            }
389            if let Some(Tok::Ch('万')) = toks.get(i + 1) {
390                // 「<数> 万 <数> 千」
391                if let (Some(Tok::Num(sen)), Some(Tok::Ch('千'))) =
392                    (toks.get(i + 2), toks.get(i + 3))
393                    && let Some(value) = man_with_sen(whole, sen)
394                {
395                    push_expanded(&mut out, value, toks.get(i + 4));
396                    i += 4;
397                    continue;
398                }
399                // 「<数> 万 <数>」で直後が円・範囲・末尾なら端数として合算
400                if let Some(Tok::Num(rest)) = toks.get(i + 2) {
401                    let boundary =
402                        matches!(toks.get(i + 3), None | Some(Tok::Ch('円' | RANGE_CHAR)));
403                    if boundary
404                        && rest.len() <= MAX_MAN_FRACTION_DIGITS
405                        && let Some(value) = man_with_rest(whole, rest)
406                    {
407                        out.push(Tok::Num(value.to_string()));
408                        i += 3;
409                        continue;
410                    }
411                }
412                // 「<数> 万」単独。直後に数値が続く場合(例: `5万12345円`)は、
413                // 展開すると `50000` と `12345` が隣接し render で
414                // `5000012345` へ連結してしまう。原文のまま残して
415                // 金額として読ませない(fail-closed)
416                if !matches!(toks.get(i + 2), Some(Tok::Num(_)))
417                    && let Some(value) = parse_u64(whole).and_then(|w| w.checked_mul(MAN_YEN))
418                {
419                    push_expanded(&mut out, value, toks.get(i + 2));
420                    i += 2;
421                    continue;
422                }
423            }
424        }
425        if let Some(tok) = toks.get(i) {
426            out.push(tok.clone());
427        }
428        i += 1;
429    }
430    out
431}
432
433/// 数字間の `?` を範囲区切りへ救済する。
434/// エンコード破損で `〜` が `?` になったデータへの対処。万の展開後に
435/// 実行することで `20万?25万円` のような表現も救済できる。
436fn rewrite_mojibake_range(toks: Vec<Tok>) -> Vec<Tok> {
437    let mut out: Vec<Tok> = Vec::new();
438    let mut it = toks.into_iter().peekable();
439    while let Some(tok) = it.next() {
440        // 直前は数値そのもの(`1200?1500`)か、単位展開が補った「円」
441        // (`20万?25万` → `200000円?250000円`)のどちらもありうる
442        if matches!(tok, Tok::Ch('?'))
443            && matches!(out.last(), Some(Tok::Num(_) | Tok::Ch('円')))
444            && matches!(it.peek(), Some(Tok::Num(_)))
445        {
446            out.push(Tok::Ch(RANGE_CHAR));
447        } else {
448            out.push(tok);
449        }
450    }
451    out
452}
453
454/// 単位を揃える仕上げ。
455///
456/// - `1.200円` のような桁区切り誤記の小数点を除去
457/// - 範囲区切り直前の数値へ `円` を補う(`210000~260000円` → `210000円~260000円`)
458/// - 末尾が数値で終わる場合は `円` を補う(`月給20万` → `月給200000円`)。
459///   ただし元テキストが数字のみ(`has_context` が偽)の場合は文脈が無いため補わない
460fn align_units(toks: &[Tok], has_context: bool) -> Vec<Tok> {
461    // 桁区切り誤記: 「<数> . <数> 円」→ 数字列を結合
462    let mut merged: Vec<Tok> = Vec::new();
463    let mut i = 0;
464    while i < toks.len() {
465        if let (Some(Tok::Num(a)), Some(Tok::Ch('.')), Some(Tok::Num(b)), Some(Tok::Ch('円'))) = (
466            toks.get(i),
467            toks.get(i + 1),
468            toks.get(i + 2),
469            toks.get(i + 3),
470        ) {
471            let mut joined = a.clone();
472            joined.push_str(b);
473            merged.push(Tok::Num(joined));
474            i += 3; // 「円」は次の周回で通常どおり出力する
475            continue;
476        }
477        if let Some(tok) = toks.get(i) {
478            merged.push(tok.clone());
479        }
480        i += 1;
481    }
482    // 範囲区切り直前の数値へ円を補う。ただし範囲の右側が金額のときに限る
483    let mut out: Vec<Tok> = Vec::new();
484    for (i, tok) in merged.iter().enumerate() {
485        out.push(tok.clone());
486        if matches!(tok, Tok::Num(_))
487            && matches!(merged.get(i + 1), Some(Tok::Ch(RANGE_CHAR)))
488            && range_right_is_amount(&merged, i + 2)
489        {
490            out.push(Tok::Ch('円'));
491        }
492    }
493    // 末尾の数値へ円を補う(数字のみのテキスト・金額でない範囲の右端は対象外)
494    if has_context && matches!(out.last(), Some(Tok::Num(_))) && !ends_with_bare_range(&out) {
495        out.push(Tok::Ch('円'));
496    }
497    out
498}
499
500/// 末尾が「金額でない範囲」の右端で終わっているか。
501///
502/// `<数> ~ <数>` で終わる並びの左側に「円」が付いていなければ、その範囲は金額の
503/// レンジではない(郵便番号 `〒150~0001`、住所 `渋谷区1~2~3` など)。ここで
504/// 右端にだけ「円」を補うと、片側だけ通貨という不整合な形になり、
505/// [`crate::parse`] の診断も `NoAmount` ではなく `UnknownType` へ化ける。
506fn ends_with_bare_range(toks: &[Tok]) -> bool {
507    let len = toks.len();
508    len >= 3
509        && matches!(toks.get(len - 2), Some(Tok::Ch(RANGE_CHAR)))
510        && matches!(toks.get(len - 3), Some(Tok::Num(_)))
511}
512
513/// 範囲区切りの右側が金額として読める形か。
514///
515/// 左側の数値へ「円」を補ってよいのは、範囲そのものが金額のレンジである場合に
516/// 限る。これを判定せずに補うと「9:00~18:00」の `9` が `9円` になり、勤務時間が
517/// 給与額として誤読される。受理するのは次の 2 形のみ:
518///
519/// - `<数> 円` — 上限が金額(例: `210000~260000円`)
520/// - 何も続かない — 「以上」由来の上限なし範囲(例: `1200以上` → `1200~`)
521fn range_right_is_amount(toks: &[Tok], start: usize) -> bool {
522    match toks.get(start) {
523        None => true,
524        Some(Tok::Num(_)) => matches!(toks.get(start + 1), Some(Tok::Ch('円'))),
525        Some(Tok::Ch(_)) => false,
526    }
527}
528
529/// トークン列を文字列へ戻す。
530fn render(toks: &[Tok]) -> String {
531    let mut s = String::new();
532    for tok in toks {
533        match tok {
534            Tok::Num(run) => s.push_str(run),
535            Tok::Ch(c) => s.push(*c),
536        }
537    }
538    s
539}
540
541/// 桁あふれを失敗として扱う数値変換。
542fn parse_u64(digits: &str) -> Option<u64> {
543    digits.parse::<u64>().ok()
544}
545
546/// 「x.y<単位>」→ 円換算。小数部は単位の位取りへ換算する
547/// (`21.5万` → 215,000 / `1.5億` → 150,000,000)。
548///
549/// `max_digits` は単位の位取りに収まる小数部の桁数(万なら 4、億なら 8)。
550/// これを超える小数部は破損データとみなし `None` を返す。
551fn unit_with_fraction(whole: &str, frac: &str, unit_yen: u64, max_digits: usize) -> Option<u64> {
552    if frac.len() > max_digits {
553        return None;
554    }
555    let scale = 10_u64.pow(u32::try_from(max_digits - frac.len()).ok()?);
556    let base = parse_u64(whole)?.checked_mul(unit_yen)?;
557    let fraction = parse_u64(frac)?.checked_mul(scale)?;
558    base.checked_add(fraction)
559}
560
561/// 「x億y万」→ 円換算(`1億2000万` → 120,000,000)。
562fn oku_with_man(whole: &str, man: &str) -> Option<u64> {
563    let base = parse_u64(whole)?.checked_mul(OKU_YEN)?;
564    let man_part = parse_u64(man)?.checked_mul(MAN_YEN)?;
565    base.checked_add(man_part)
566}
567
568/// 「x万y千」→ 円換算(`21万5千` → 215,000)。
569fn man_with_sen(whole: &str, sen: &str) -> Option<u64> {
570    if sen.len() != MAX_SEN_DIGITS {
571        return None;
572    }
573    let base = parse_u64(whole)?.checked_mul(MAN_YEN)?;
574    let sen_part = parse_u64(sen)?.checked_mul(SEN_YEN)?;
575    base.checked_add(sen_part)
576}
577
578/// 「x万y円」→ 円換算(`21万5000円` → 215,000 円)。
579fn man_with_rest(whole: &str, rest: &str) -> Option<u64> {
580    let base = parse_u64(whole)?.checked_mul(MAN_YEN)?;
581    base.checked_add(parse_u64(rest)?)
582}
583
584#[cfg(test)]
585mod tests {
586    use super::normalize;
587
588    #[test]
589    fn 全角数字とカンマ連鎖を半角へ揃える() {
590        assert_eq!(normalize("1,000,000円"), "1000000円");
591        assert_eq!(normalize("210000円"), "210000円");
592        assert_eq!(normalize("1234567890円"), "1234567890円");
593        assert_eq!(normalize("1、000円"), "1000円");
594        // 数字に挟まれていないカンマは桁区切りではないため保持する
595        assert_eq!(normalize("応相談、経験による"), "応相談,経験による");
596    }
597
598    #[test]
599    fn 万と千の表記を桁へ展開する() {
600        assert_eq!(normalize("21万円"), "210000円");
601        assert_eq!(normalize("21.5万円"), "215000円");
602        assert_eq!(normalize("21.05万円"), "210500円");
603        assert_eq!(normalize("21万5千円"), "215000円");
604        assert_eq!(normalize("21万5000円"), "215000円");
605        assert_eq!(normalize("月給20万"), "月給200000円");
606    }
607
608    #[test]
609    fn 範囲区切りのゆれを正準形へ揃える() {
610        assert_eq!(normalize("20万〜25万円"), "200000円~250000円");
611        assert_eq!(normalize("20万-25万円"), "200000円~250000円");
612        assert_eq!(normalize("20万?25万円"), "200000円~250000円");
613        assert_eq!(normalize("1200円以上"), "1200円~");
614        // 単位のない「以上」も、上限のない金額範囲として「円」を補う
615        assert_eq!(normalize("1200以上"), "1200円~");
616    }
617
618    #[test]
619    fn 範囲の右側だけの万を左へ分配する() {
620        assert_eq!(normalize("20~25万円"), "200000円~250000円");
621        assert_eq!(normalize("300〜400万円"), "3000000円~4000000円");
622        assert_eq!(normalize("20.5~25万円"), "205000円~250000円");
623        assert_eq!(normalize("20~25.5万円"), "200000円~255000円");
624        // 右側に「万」がなければ分配しない
625        assert_eq!(normalize("1200~1500円"), "1200円~1500円");
626        // 範囲の右側が金額でなければ左へ「円」も補わない。
627        // 補うと金額でない数値が金額に化ける
628        assert_eq!(normalize("20~応相談"), "20~応相談");
629    }
630
631    #[test]
632    fn 円記号を円表記へ揃える() {
633        assert_eq!(normalize("¥1200"), "1200円");
634        assert_eq!(normalize("¥1200円"), "1200円");
635        assert_eq!(normalize("¥20万"), "200000円");
636        assert_eq!(normalize("値段は¥です"), "値段はです");
637    }
638
639    #[test]
640    fn 賞与などの給与外数値を落とす() {
641        assert_eq!(normalize("月給20万円(賞与年2回)"), "月給200000円賞与");
642        assert_eq!(normalize("月給20万円 賞与4.45ヶ月分"), "月給200000円賞与");
643        assert_eq!(normalize("賞与3カ月"), "賞与");
644    }
645
646    #[test]
647    fn 装飾記号と空白を取り除く() {
648        assert_eq!(normalize("【月給】 210,000円"), "月給210000円");
649        assert_eq!(normalize("☆時給:1200円☆"), "時給1200円");
650    }
651
652    #[test]
653    fn 桁区切り誤記の小数点を救済する() {
654        assert_eq!(normalize("1.200円"), "1200円");
655    }
656
657    #[test]
658    fn 桁あふれする破損データは展開しない() {
659        // u64 に収まらない「万」は展開されず、金額として読まれない形のまま残る
660        let huge = "99999999999999999999万円";
661        assert_eq!(normalize(huge), huge);
662        // 端数付き(x万y円)でも同様に展開しない
663        let huge_rest = "99999999999999999999万5000円";
664        assert_eq!(normalize(huge_rest), huge_rest);
665    }
666
667    #[test]
668    fn 位取りに収まらない万表記は展開しない() {
669        // 小数部が万の位取り(4 桁)を超える場合は「万」を単独展開へ回す。
670        // 破損データであり、後段の妥当範囲検証で拒否される
671        assert_eq!(normalize("1.55555万円"), "1555550000円");
672        // 「千」の前が 1 桁でない場合は千を展開しない。さらに直後に数値が
673        // 続くため「万」の単独展開も行わない。展開すると 20000 と 55 が
674        // 隣接して "2000055" へ連結し、架空の金額になるため(fail-closed)
675        assert_eq!(normalize("2万55千円"), "2万55千円");
676    }
677
678    #[test]
679    fn 単位展開で桁が連結する形は展開しない() {
680        // 端数が万の位取りを超える場合、単独展開すると 50000 と 12345 が
681        // 隣接し "5000012345" という実在しない金額になる。原文のまま残す
682        assert_eq!(normalize("月給5万12345円"), "月給5万12345円");
683        assert_eq!(normalize("1億23456789円"), "1億23456789円");
684    }
685
686    #[test]
687    fn 億を桁へ展開する() {
688        assert_eq!(normalize("年収1億円"), "年収100000000円");
689        assert_eq!(normalize("年収1億2000万円"), "年収120000000円");
690        assert_eq!(normalize("年収1.5億円"), "年収150000000円");
691        // 桁あふれする破損データは展開しない
692        let huge = "99999999999999999999億円";
693        assert_eq!(normalize(huge), huge);
694    }
695
696    #[test]
697    fn 金額でない範囲の右端へは円を補わない() {
698        // 郵便番号・住所・電話番号はハイフンが範囲区切りへ揃うが金額ではない。
699        // 右端にだけ「円」を補うと片側だけ通貨という不整合な形になる
700        assert_eq!(normalize("〒150-0001"), "〒150~0001");
701        assert_eq!(normalize("東京都渋谷区1-2-3"), "東京都渋谷区1~2~3");
702        assert_eq!(normalize("03-1234-5678"), "03~1234~5678");
703        // 単位が付いていれば従来どおり補う
704        assert_eq!(normalize("月給20~25万"), "月給200000円~250000円");
705    }
706
707    #[test]
708    fn 数字に挟まれたコロンだけ残す() {
709        // 区切りのコロンは落とす
710        assert_eq!(normalize("時給:1200円"), "時給1200円");
711        // 時刻のコロンは残す。落とすと "900" へ連結し時給に化ける
712        assert_eq!(normalize("9:00~18:00"), "9:00~18:00");
713        assert_eq!(normalize("9:00~18:00 月給25万円"), "9:00~18:00月給250000円");
714    }
715
716    #[test]
717    fn 数値のみのテキストへは円を補わない() {
718        assert_eq!(normalize("210000"), "210000");
719        // カンマ区切りは通貨表記の文脈とみなし、円を補う
720        assert_eq!(normalize("210,000"), "210000円");
721    }
722}