1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use regex::Captures;
use regex::Regex;

/// Structure of novel sentence.
///
/// Sentences are defined below:
/// * Starts from previous sentence or breakline
/// * End with sentence-terminators ('.', '。', '」'))
///     * '. '
///     * '。'
///     * '」'
///     * '！'
///     * '？'
///     * '!?'
///
pub struct Sentence {
    elements: String,
}

/// Implementation for novel sentence structure
impl Sentence {
    /// Constructor
    ///
    /// # Example
    ///
    /// ```
    /// use naromat::entities::sentence::Sentence;
    ///
    /// Sentence::new("我が輩は猫である。");
    /// ```
    pub fn new(sentence: &str) -> Self {
        Self {
            elements: sentence.trim_end().to_string(),
        }
    }

    /// Print formatted sentence
    ///
    /// # Example
    ///
    /// ```
    /// use naromat::entities::sentence::Sentence;
    ///
    /// let sentence = Sentence::new("我が輩は猫である。");
    /// sentence.print()
    /// ```
    pub fn print(self) {
        println!("{}", self.format().elements)
    }

    /// Get string of formatted sentence
    ///
    /// # Example
    ///
    /// ```
    /// use naromat::entities::sentence::Sentence;
    /// let sentence = Sentence::new("我が[輩:.]は[猫:ねこ]である");
    /// assert_eq!(sentence.get(), "我が｜輩《・》は｜猫《ねこ》である");
    /// ```
    ///
    pub fn get(self) -> String {
        self.format().elements
    }

    /// Format sentence
    fn format(&self) -> Self {
        self.add_space_after_exclamation().convert_kenten().convert_ruby()
    }

    /// Insert 2 byte whitespace to after of exclamation.
    fn add_space_after_exclamation(&self) -> Self {
        let exclamations = Regex::new(r"(!\?|\?!|[！？])").unwrap();
        let sentence = exclamations.replace_all(&self.elements, "$1　").to_string();
        let error_tails = Regex::new(r"　([」)）])").unwrap();
        let sentence = error_tails.replace_all(&sentence, "$1").to_string();
        Self::new(&sentence)
    }

    /// Convert kenten(圏点) format to Narou format.
    fn convert_kenten(&self) -> Self {
        let kenten = Regex::new(r"\[([^]]*?):\.\]").unwrap();
        let sentence = kenten
            .replace_all(&self.elements, |caps: &Captures| {
                format!("｜{}《{}》", &caps[1], "・".to_string().repeat(caps[1].chars().count()))
            })
            .to_string();
        Self::new(&sentence)
    }

    /// Convert ruby(ルビ) format to Narou format
    fn convert_ruby(&self) -> Self {
        let ruby = Regex::new(r"\[(.*?):(.*?)]").unwrap();
        let sentence = ruby.replace_all(&self.elements, "｜$1《$2》").to_string();
        Self::new(&sentence)
    }
}

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

    #[test]
    fn get() {
        let source = "私の[名前:なまえ]は！[田中:.]？太郎!?です";
        let expected = "私の｜名前《なまえ》は！　｜田中《・・》？　太郎!?　です";
        let sentence = Sentence::new(&source);
        assert_eq!(sentence.get(), expected);
    }
    #[test]
    fn format() {
        let source = "私の[名前:なまえ]は！[田中:.]？太郎!?です";
        let expected = "私の｜名前《なまえ》は！　｜田中《・・》？　太郎!?　です";
        let sentence = Sentence::new(&source).format();
        assert_eq!(sentence.elements, expected);
    }

    #[test]
    fn format_min() {
        let source = "私";
        let expected = "私";
        let sentence = Sentence::new(&source).format();
        assert_eq!(sentence.elements, expected);
    }

    #[test]
    fn add_space_after_exclamation() {
        let source = "私の名前は！田中？太郎!?です";
        let expected = "私の名前は！　田中？　太郎!?　です";
        let sentence = Sentence::new(&source).add_space_after_exclamation();
        assert_eq!(sentence.elements, expected);
    }

    #[test]
    fn convert_ruby_should_convert_ruby() {
        let sut = Sentence::new("私の[名前:なまえ]は[太郎:たろう]です");
        let expected = "私の｜名前《なまえ》は｜太郎《たろう》です";
        assert_eq!(sut.convert_ruby().elements, expected);
    }

    #[test]
    fn convert_kenten_should_convert_kenten() {
        let sut = Sentence::new("私の[名前:.]は[たろう:.]です");
        let expected = "私の｜名前《・・》は｜たろう《・・・》です";
        assert_eq!(sut.convert_kenten().elements, expected);
    }
}