text.rs

//! 文字の扱い
//!
//! 和文か欧文かの見分け、行頭と行末に置けない文字、続いた記号の直し、
//! それに PDF へ書き出すときの数と文字列の形を持つ。

use std::time::{SystemTime, UNIX_EPOCH};


/// 行頭に置けない文字
const NOT_AT_START: &str = "、。，．・：；？！ゝゞヽヾ々ー〜）］｝」』】〉》〕”’%,.:;?!)]}";


/// 行末に置けない文字
const NOT_AT_END: &str = "（［｛「『【〈《〔“‘([{";


/// 小書きの仮名。行頭に置けない
const SMALL_KANA: &str = "ぁぃぅぇぉっゃゅょゎァィゥェォッャュョヮヵヶ";


/// 和文と欧文のあいだに入れる空き（em）
pub const MIXED_GAP: f64 = 0.25;


/// 全角の文字かどうか
pub fn is_wide(character: char) -> bool {
    let code = character as u32;

    matches!(
        code,
        0x1100..=0x115f
            | 0x2e80..=0x303e
            | 0x3041..=0x33ff
            | 0x3400..=0x4dbf
            | 0x4e00..=0x9fff
            | 0xa000..=0xa4cf
            | 0xac00..=0xd7a3
            | 0xf900..=0xfaff
            | 0xfe30..=0xfe6f
            | 0xff00..=0xff60
            | 0xffe0..=0xffe6
            | 0x20000..=0x3fffd
    )
}


/// 行頭に置けない文字かどうか
pub fn forbidden_at_start(character: char) -> bool {
    NOT_AT_START.contains(character) || SMALL_KANA.contains(character)
}


/// 行末に置けない文字かどうか
pub fn forbidden_at_end(character: char) -> bool {
    NOT_AT_END.contains(character)
}


/// 2 つの文字のあいだに和欧間の空きを入れるかどうか
///
/// 入れるのは和文と欧文の英数字のあいだだけである。`{` や `(` のような記号の隣、
/// 「、」や「）」のような約物の隣には入れない。もともと余白を持っている
pub fn needs_gap(left: char, right: char) -> bool {
    let (wide, narrow) = if is_wide(left) {
        if is_wide(right) {
            return false;
        }

        (left, right)
    } else {
        if !is_wide(right) {
            return false;
        }

        (right, left)
    };

    narrow.is_alphanumeric() && !forbidden_at_start(wide) && !forbidden_at_end(wide)
}


/// 続けて書いた記号を、組むときの文字に直す
///
/// `---` は全角ダッシュ、`--` は半角ダッシュ、`` `` `` と `''` は引用符になる
pub fn ligature(text: &str) -> String {
    let source: Vec<char> = text.chars().collect();
    let mut out = String::with_capacity(text.len());
    let mut at = 0;

    while at < source.len() {
        let rest = source.len() - at;

        if source[at] == '-' && rest >= 3 && source[at + 1] == '-' && source[at + 2] == '-' {
            out.push('\u{2014}');
            at += 3;

        } else if source[at] == '-' && rest >= 2 && source[at + 1] == '-' {
            out.push('\u{2013}');
            at += 2;

        } else if source[at] == '`' && rest >= 2 && source[at + 1] == '`' {
            out.push('\u{201c}');
            at += 2;

        } else if source[at] == '\'' && rest >= 2 && source[at + 1] == '\'' {
            out.push('\u{201d}');
            at += 2;

        } else if source[at] == '`' {
            out.push('\u{2018}');
            at += 1;

        } else if source[at] == '\'' {
            out.push('\u{2019}');
            at += 1;

        } else {
            out.push(source[at]);
            at += 1;
        }
    }

    out
}


/// 今日の日付。時差は見ないので、日付の変わり目では前日になることがある
pub fn today() -> String {
    let seconds = match SystemTime::now().duration_since(UNIX_EPOCH) {
        Ok(elapsed) => elapsed.as_secs() as i64,
        Err(_) => 0,
    };
    let (year, month, day) = civil(seconds.div_euclid(86_400));

    format!("{year}年{month}月{day}日")
}


/// 1970 年 1 月 1 日からの日数を、年月日に直す
fn civil(days: i64) -> (i64, i64, i64) {
    let shifted = days + 719_468;
    let era = shifted.div_euclid(146_097);
    let day_of_era = shifted.rem_euclid(146_097);
    let year_of_era =
        (day_of_era - day_of_era / 1_460 + day_of_era / 36_524 - day_of_era / 146_096) / 365;
    let year = year_of_era + era * 400;
    let day_of_year = day_of_era - (365 * year_of_era + year_of_era / 4 - year_of_era / 100);
    let shifted_month = (5 * day_of_year + 2) / 153;
    let day = day_of_year - (153 * shifted_month + 2) / 5 + 1;
    let month = if shifted_month < 10 {shifted_month + 3} else {shifted_month - 9};

    (if month <= 2 {year + 1} else {year}, month, day)
}


/// いまの時刻を PDF の日付の形で返す。時差は見ないので UTC で書く
pub fn stamp() -> String {
    let seconds = match SystemTime::now().duration_since(UNIX_EPOCH) {
        Ok(elapsed) => elapsed.as_secs() as i64,
        Err(_) => 0,
    };
    let (year, month, day) = civil(seconds.div_euclid(86_400));
    let rest = seconds.rem_euclid(86_400);
    let hour = rest / 3_600;
    let minute = (rest % 3_600) / 60;
    let second = rest % 60;

    format!("D:{year:04}{month:02}{day:02}{hour:02}{minute:02}{second:02}Z")
}


/// 数を PDF に書ける形にする。指数は使わず、末尾の 0 は落とす
pub fn number(value: f64) -> String {
    if !value.is_finite() {
        return "0".to_string();
    }

    let rounded = (value * 1000.0).round() / 1000.0;

    if rounded == rounded.trunc() {
        return format!("{}", rounded as i64);
    }

    let mut text = format!("{rounded:.3}");

    while text.ends_with('0') {
        text.pop();
    }

    if text.ends_with('.') {
        text.pop();
    }

    text
}


/// PDF の丸括弧で囲む文字列に入れられる形にする
pub fn escape_string(text: &str) -> String {
    let mut out = String::with_capacity(text.len());

    for character in text.chars() {
        match character {
            '\\' => out.push_str("\\\\"),
            '(' => out.push_str("\\("),
            ')' => out.push_str("\\)"),
            '\r' => out.push_str("\\r"),
            '\n' => out.push_str("\\n"),
            _ => out.push(character),
        }
    }

    out
}


/// 文字列を UTF-16BE の 16 進で書く。PDF の題名などに使う
pub fn hex_string(text: &str) -> String {
    let mut out = String::from("FEFF");

    for unit in text.encode_utf16() {
        out.push_str(&format!("{unit:04X}"));
    }

    out
}


/// 数を 16 進 4 桁で書く
pub fn hex_number(value: u16) -> String {
    format!("{value:04X}")
}


/// 番号をローマ数字にする。目次より前のページ番号に使う
pub fn roman(mut value: usize) -> String {
    const TABLE: &[(usize, &str)] = &[
        (1000, "m"),
        (900, "cm"),
        (500, "d"),
        (400, "cd"),
        (100, "c"),
        (90, "xc"),
        (50, "l"),
        (40, "xl"),
        (10, "x"),
        (9, "ix"),
        (5, "v"),
        (4, "iv"),
        (1, "i"),
    ];
    let mut out = String::new();

    for (size, mark) in TABLE {
        while value >= *size {
            out.push_str(mark);
            value -= size;
        }
    }

    out
}


/// 番号を A, B, C にする。付録の見出しに使う
pub fn alphabet(value: usize) -> String {
    if value == 0 {
        return String::new();
    }

    let mut out = String::new();
    let mut left = value;

    while left > 0 {
        let index = (left - 1) % 26;
        out.insert(0, (b'A' + index as u8) as char);
        left = (left - 1) / 26;
    }

    out
}


#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn wide_letters_are_told_apart() {
        assert!(is_wide('あ'));
        assert!(is_wide('漢'));
        assert!(is_wide('。'));
        assert!(!is_wide('a'));
        assert!(!is_wide('1'));
    }

    #[test]
    fn a_gap_goes_between_the_two_kinds() {
        assert!(needs_gap('あ', 'a'));
        assert!(needs_gap('a', 'あ'));
        assert!(needs_gap('あ', '1'));
        assert!(!needs_gap('あ', 'い'));
        assert!(!needs_gap('a', 'b'));
        assert!(!needs_gap('。', 'a'));
        assert!(!needs_gap('あ', '）'));
    }

    #[test]
    fn no_gap_goes_next_to_a_mark() {
        assert!(!needs_gap('{', '見'));
        assert!(!needs_gap('見', '}'));
        assert!(!needs_gap('(', '注'));
        assert!(!needs_gap('あ', '\u{2014}'));
    }

    #[test]
    fn marks_join_into_one_letter() {
        assert_eq!(ligature("a---b"), "a\u{2014}b");
        assert_eq!(ligature("a--b"), "a\u{2013}b");
        assert_eq!(ligature("``x''"), "\u{201c}x\u{201d}");
    }

    #[test]
    fn numbers_lose_their_trailing_zeros() {
        assert_eq!(number(1.0), "1");
        assert_eq!(number(1.5), "1.5");
        assert_eq!(number(1.2345), "1.235");
        assert_eq!(number(-0.0), "0");
    }

    #[test]
    fn a_known_day_comes_back_right() {
        assert_eq!(civil(0), (1970, 1, 1));
        assert_eq!(civil(19_000), (2022, 1, 8));
    }

    #[test]
    fn counters_have_other_shapes() {
        assert_eq!(roman(4), "iv");
        assert_eq!(roman(2026), "mmxxvi");
        assert_eq!(alphabet(1), "A");
        assert_eq!(alphabet(27), "AA");
    }
}