Skip to main content

salary_parser_jp/
extract.rs

1//! 正規化済みテキストからの金額抽出と給与種別判定。
2//!
3//! 「種別語 + 金額」の優先度付きパターン群による抽出。種別語の直後に
4//! 金額が続く場合のみ採用する隣接性ルールにより、無関係な数値の誤読を防ぐ
5//! (精度優先・fail-closed)。
6
7use crate::normalize::RANGE_CHAR;
8use crate::{ParseError, Salary, SalaryBounds, SalaryType};
9
10/// 金額読み取りの結果。`(下限, 上限)` または桁あふれエラー。
11type AmountOutcome = Result<(u64, Option<u64>), ParseError>;
12
13/// 月給系の種別語。同一位置では長い語を優先するため長い順。
14const MONTHLY_KEYWORDS: &[&str] = &[
15    "月収手当込",
16    "月額平均",
17    "月額合計",
18    "月固定給",
19    "月給額",
20    "月給月",
21    "固定給",
22    "月給",
23    "月額",
24    "月収",
25];
26/// 年収系の種別語。
27const YEARLY_KEYWORDS: &[&str] = &["年俸制", "年収例", "年収", "年俸", "年棒"];
28/// 種別が曖昧な語。金額の桁から種別を推定する。
29/// 複数の給与が混在しやすいため、日給・時給より優先する。
30const BASE_KEYWORDS: &[&str] = &[
31    "基本給月額平均又は時間額",
32    "初任給",
33    "総支給",
34    "基本給",
35    "正社員",
36    "正職員",
37    "給与",
38    "給料",
39    "基本",
40    "総額",
41    "本給",
42    "常勤",
43];
44/// 日給系の種別語。
45const DAILY_KEYWORDS: &[&str] = &["日給"];
46/// 時給系の種別語。
47const HOURLY_KEYWORDS: &[&str] = &["時間給", "時給制", "時給"];
48
49/// 種別語グループの優先順。`None` は桁からの推定。
50const GROUPS: &[(&[&str], Option<SalaryType>)] = &[
51    (MONTHLY_KEYWORDS, Some(SalaryType::Monthly)),
52    (YEARLY_KEYWORDS, Some(SalaryType::Yearly)),
53    (BASE_KEYWORDS, None),
54    (DAILY_KEYWORDS, Some(SalaryType::Daily)),
55    (HOURLY_KEYWORDS, Some(SalaryType::Hourly)),
56];
57
58/// 給与以外の金額を指す語(新規: 文頭の裸金額を給与と誤認しないためのガード)。
59///
60/// 種別語がまったく無いテキストで文頭の金額を桁から推定するのは、その数値が
61/// そもそも給与なのかを確かめずに行う推測である。これらの語が同居していれば
62/// 「その金額は給与ではないかもしれない」証拠なので、精度優先の方針に従って
63/// 推測を放棄する(`100,000円 支度金` を月給 100,000 円と読まないため)。
64///
65/// 種別語がある場合はそちらが優先されるので、この一覧は影響しない
66/// (`月給20万円 賞与年2回` は従来どおり月給 200,000 円として解析される)。
67const NON_SALARY_KEYWORDS: &[&str] = &[
68    "支度金",
69    "祝い金",
70    "祝金",
71    "一時金",
72    "報奨金",
73    "見舞金",
74    "寸志",
75    "交通費",
76    "通勤費",
77    "退職金",
78    "資本金",
79    "年商",
80    "保証金",
81    "賞与",
82    "手当",
83];
84
85/// 種別語と金額の間に挟まっていてよい文字(「月給約210000円」「月給/210000円」に対応)。
86const KEYWORD_GAP_CHARS: [char; 3] = ['約', '例', '/'];
87
88/// 桁からの種別推定: これ以上なら年収。
89const INFER_YEARLY_MIN_YEN: u64 = 1_000_000;
90/// 桁からの種別推定: これ以上なら月給。
91const INFER_MONTHLY_MIN_YEN: u64 = 60_000;
92/// 桁からの種別推定: 時給とみなす下限。
93const INFER_HOURLY_MIN_YEN: u64 = 820;
94/// 桁からの種別推定: 時給とみなす上限。
95const INFER_HOURLY_MAX_YEN: u64 = 5_000;
96
97/// 正規化済みテキストから給与を抽出する。
98///
99/// 優先順: 文頭「月<数>」特例 → 種別語グループ順 → 文頭の金額(種別語なし)。
100///
101/// 種別語は書き手による種別の申告なので、桁からの推定より常に優先する。
102/// 文頭の裸金額を先に採ると「9:00~18:00 月給25万円」のような入力で
103/// 勤務時間を時給として拾い、明示された月給を無視してしまう。
104///
105/// どの候補も妥当範囲を通らなかった場合は、最初に金額まで読めた候補の
106/// エラーを返す(最も主要な金額に対する診断が得られるため)。
107pub(crate) fn extract(normalized: &str, bounds: &SalaryBounds) -> Result<Salary, ParseError> {
108    let chars: Vec<char> = normalized.chars().collect();
109    let mut deferred: Option<ParseError> = None;
110
111    // 1) 文頭「月<数>」特例(「月210000円」の形)。「月」も種別の申告なので
112    //    種別語グループと同格に扱う
113    if chars.first() == Some(&'月')
114        && chars.get(1).is_some_and(char::is_ascii_digit)
115        && let Some(outcome) = parse_amount_at(&chars, 1)
116        && let Some(parsed) =
117            try_candidate(outcome, Some(SalaryType::Monthly), bounds, &mut deferred)
118    {
119        return Ok(parsed);
120    }
121    // 2) 種別語(優先度順)+ 直後の金額
122    for (keywords, salary_type) in GROUPS {
123        for keyword in *keywords {
124            let keyword_chars: Vec<char> = keyword.chars().collect();
125            for pos in keyword_positions(&chars, &keyword_chars) {
126                let Some(outcome) = parse_amount_at(&chars, pos + keyword_chars.len()) else {
127                    continue;
128                };
129                if let Some(parsed) = try_candidate(outcome, *salary_type, bounds, &mut deferred) {
130                    return Ok(parsed);
131                }
132            }
133        }
134    }
135    // 3) 文頭金額(種別語なし): 桁から種別を推定する最後の手段。
136    //    給与以外の金額を指す語が同居していれば、その数値が給与だという確証が
137    //    ないため推測を放棄する(あいまいなものは拾わない)
138    if chars.first().is_some_and(char::is_ascii_digit)
139        && !contains_non_salary_keyword(&chars)
140        && let Some(outcome) = parse_amount_at(&chars, 0)
141        && let Some(parsed) = try_candidate(outcome, None, bounds, &mut deferred)
142    {
143        return Ok(parsed);
144    }
145
146    if let Some(error) = deferred {
147        return Err(error);
148    }
149    if has_amount(&chars) {
150        return Err(ParseError::UnknownType {
151            normalized: normalized.to_string(),
152        });
153    }
154    Err(ParseError::NoAmount)
155}
156
157/// 金額候補を種別解決 → 妥当範囲検証にかける。不合格のエラーは最初の 1 件だけ
158/// `deferred` に保持する(候補の優先順 = 診断の優先順)。
159fn try_candidate(
160    outcome: AmountOutcome,
161    salary_type: Option<SalaryType>,
162    bounds: &SalaryBounds,
163    deferred: &mut Option<ParseError>,
164) -> Option<Salary> {
165    let (min_yen, max_yen) = match outcome {
166        Ok(amounts) => amounts,
167        Err(error) => {
168            defer(deferred, error);
169            return None;
170        }
171    };
172    let resolved = salary_type.or_else(|| infer_type(min_yen, max_yen))?;
173    match validate(resolved, min_yen, max_yen, bounds) {
174        Ok(()) => Some(Salary {
175            salary_type: resolved,
176            min_yen,
177            max_yen,
178        }),
179        Err(error) => {
180            defer(deferred, error);
181            None
182        }
183    }
184}
185
186/// 最初のエラーのみを保持する。
187fn defer(slot: &mut Option<ParseError>, error: ParseError) {
188    if slot.is_none() {
189        *slot = Some(error);
190    }
191}
192
193/// `start` 位置から金額表現を読む。
194///
195/// 正準形 `N円` / `N円~` / `N円~M円` のみを受理する。構造が一致しなければ
196/// `None`(その位置に金額はない)。数値が u64 に収まらなければ
197/// [`ParseError::AmountTooLarge`]。
198fn parse_amount_at(chars: &[char], start: usize) -> Option<AmountOutcome> {
199    let mut i = start;
200    while matches!(chars.get(i), Some(c) if KEYWORD_GAP_CHARS.contains(c)) {
201        i += 1;
202    }
203    let (min_digits, after_min) = read_digits(chars, i);
204    if min_digits.is_empty() {
205        return None;
206    }
207    i = after_min;
208    if chars.get(i) != Some(&'円') {
209        return None;
210    }
211    i += 1;
212    let min_yen = match parse_amount(&min_digits) {
213        Ok(value) => value,
214        Err(error) => return Some(Err(error)),
215    };
216    if chars.get(i) != Some(&RANGE_CHAR) {
217        return Some(Ok((min_yen, None)));
218    }
219    i += 1;
220    let (max_digits, after_max) = read_digits(chars, i);
221    if max_digits.is_empty() || chars.get(after_max) != Some(&'円') {
222        // 上限が金額の形をしていなければ下限のみの指定として扱う
223        return Some(Ok((min_yen, None)));
224    }
225    match parse_amount(&max_digits) {
226        Ok(max_yen) => Some(Ok((min_yen, Some(max_yen)))),
227        Err(error) => Some(Err(error)),
228    }
229}
230
231/// `start` から連続する数字を読み、(数字列, 次の位置) を返す。
232fn read_digits(chars: &[char], start: usize) -> (String, usize) {
233    let mut digits = String::new();
234    let mut i = start;
235    while let Some(c) = chars.get(i) {
236        if !c.is_ascii_digit() {
237            break;
238        }
239        digits.push(*c);
240        i += 1;
241    }
242    (digits, i)
243}
244
245/// 数字列を金額へ変換する。u64 に収まらない桁は破損データとして拒否する。
246fn parse_amount(digits: &str) -> Result<u64, ParseError> {
247    digits
248        .parse::<u64>()
249        .map_err(|_| ParseError::AmountTooLarge {
250            digits: digits.to_string(),
251        })
252}
253
254/// 給与以外の金額を指す語([`NON_SALARY_KEYWORDS`])が含まれるか。
255fn contains_non_salary_keyword(chars: &[char]) -> bool {
256    NON_SALARY_KEYWORDS.iter().any(|word| {
257        let word_chars: Vec<char> = word.chars().collect();
258        !keyword_positions(chars, &word_chars).is_empty()
259    })
260}
261
262/// テキスト中の種別語の開始位置をすべて返す。
263fn keyword_positions(chars: &[char], keyword: &[char]) -> Vec<usize> {
264    if chars.len() < keyword.len() {
265        return Vec::new();
266    }
267    (0..=chars.len() - keyword.len())
268        .filter(|&i| chars[i..i + keyword.len()] == *keyword)
269        .collect()
270}
271
272/// 金額の桁から給与種別を推定する。
273///
274/// 推定できない金額帯(例: 5,001〜59,999 円)は `None` を返し fail-closed
275/// とする。
276///
277/// ここは種別語がない場合の推測なので、[`SalaryType::valid_yen_range`] の健全性チェックより
278/// 狭い帯だけを採る(推定は保守的に、検証は寛容に)。種別語があるなら書き手の
279/// 申告を信じて明らかな破損だけを弾き、種別語がないなら確信できる帯に限定する。
280fn infer_type(min_yen: u64, max_yen: Option<u64>) -> Option<SalaryType> {
281    let max_yen = max_yen.unwrap_or(0);
282    if min_yen >= INFER_YEARLY_MIN_YEN || max_yen >= INFER_YEARLY_MIN_YEN {
283        return Some(SalaryType::Yearly);
284    }
285    if min_yen >= INFER_MONTHLY_MIN_YEN || max_yen >= INFER_MONTHLY_MIN_YEN {
286        return Some(SalaryType::Monthly);
287    }
288    if (INFER_HOURLY_MIN_YEN..=INFER_HOURLY_MAX_YEN).contains(&min_yen)
289        && max_yen <= INFER_HOURLY_MAX_YEN
290    {
291        return Some(SalaryType::Hourly);
292    }
293    None
294}
295
296/// 金額を種別ごとの妥当範囲で検証する。
297fn validate(
298    salary_type: SalaryType,
299    min_yen: u64,
300    max_yen: Option<u64>,
301    bounds: &SalaryBounds,
302) -> Result<(), ParseError> {
303    if let Some(max) = max_yen
304        && max < min_yen
305    {
306        return Err(ParseError::InvertedRange { min: min_yen, max });
307    }
308    let range = bounds.range(salary_type);
309    if !range.contains(&min_yen) {
310        return Err(ParseError::OutOfRange {
311            salary_type,
312            amount: min_yen,
313        });
314    }
315    if let Some(max) = max_yen
316        && !range.contains(&max)
317    {
318        return Err(ParseError::OutOfRange {
319            salary_type,
320            amount: max,
321        });
322    }
323    Ok(())
324}
325
326/// テキスト中に金額表現(数字+円)が存在するか。エラー種別の判定に使う。
327fn has_amount(chars: &[char]) -> bool {
328    chars
329        .windows(2)
330        .any(|pair| pair[0].is_ascii_digit() && pair[1] == '円')
331}