sabi-maker 0.1.0

A tiny dependency-free CLI that generates catchy Japanese chorus hooks
Documentation
//! Japanese chorus-hook generator used by the `sabi` command.

/// Options for chorus generation.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Options {
    pub theme: String,
    pub mood: Mood,
    pub lines: usize,
    pub seed: u64,
}

impl Default for Options {
    fn default() -> Self {
        Self {
            theme: "君".into(),
            mood: Mood::Bright,
            lines: 4,
            seed: 1,
        }
    }
}

/// Emotional tone of the generated hook.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Mood {
    Bright,
    Emotional,
    Cool,
}

impl Mood {
    pub fn parse(value: &str) -> Option<Self> {
        match value {
            "bright" | "明るい" => Some(Self::Bright),
            "emotional" | "エモい" => Some(Self::Emotional),
            "cool" | "クール" => Some(Self::Cool),
            _ => None,
        }
    }
}

/// Generate a chorus. The same options always produce the same result.
pub fn generate(options: &Options) -> String {
    let lines = options.lines.clamp(2, 12);
    let mut rng = Rng(options.seed ^ hash(&options.theme));
    let (starts, verbs, endings): (&[&str], &[&str], &[&str]) = match options.mood {
        Mood::Bright => (
            &["もっと", "きっと", "さあ", "何度でも", "まっすぐ"],
            &[
                "歌おう",
                "駆け出そう",
                "抱きしめよう",
                "信じよう",
                "飛び越えよう",
            ],
            &["光のほうへ", "明日を迎えに", "笑顔のままで", "空の向こうへ"],
        ),
        Mood::Emotional => (
            &["今も", "ずっと", "もしも", "もう一度", "声が枯れても"],
            &[
                "忘れない",
                "探してる",
                "そばにいたい",
                "届けたい",
                "呼び続ける",
            ],
            &[
                "夜が明けるまで",
                "涙の向こうで",
                "記憶の中へ",
                "この胸のまま",
            ],
        ),
        Mood::Cool => (
            &["静かに", "鋭く", "真夜中", "迷わず", "限界まで"],
            &[
                "塗り替える",
                "突き抜ける",
                "踊り続ける",
                "解き放つ",
                "加速する",
            ],
            &[
                "ノイズを裂いて",
                "影をまとって",
                "時代の先へ",
                "誰も知らない場所へ",
            ],
        ),
    };

    let mut output = Vec::with_capacity(lines);
    for index in 0..lines {
        let line = if index == lines - 1 {
            format!("{0}、{0}、{1}!", options.theme, pick(verbs, &mut rng))
        } else if index % 2 == 0 {
            format!(
                "{} {}を{}",
                pick(starts, &mut rng),
                options.theme,
                pick(verbs, &mut rng)
            )
        } else {
            format!("{} {}", pick(starts, &mut rng), pick(endings, &mut rng))
        };
        output.push(line);
    }
    output.join("\n")
}

fn pick<'a>(values: &'a [&str], rng: &mut Rng) -> &'a str {
    values[rng.next() as usize % values.len()]
}

fn hash(value: &str) -> u64 {
    value.bytes().fold(0xcbf29ce484222325, |acc, byte| {
        (acc ^ u64::from(byte)).wrapping_mul(0x100000001b3)
    })
}

struct Rng(u64);

impl Rng {
    fn next(&mut self) -> u64 {
        self.0 ^= self.0 << 13;
        self.0 ^= self.0 >> 7;
        self.0 ^= self.0 << 17;
        self.0
    }
}

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

    #[test]
    fn output_has_requested_number_of_lines() {
        let options = Options {
            lines: 6,
            ..Options::default()
        };
        assert_eq!(generate(&options).lines().count(), 6);
    }

    #[test]
    fn generation_is_deterministic() {
        let options = Options::default();
        assert_eq!(generate(&options), generate(&options));
    }

    #[test]
    fn theme_is_included() {
        let options = Options {
            theme: "東京".into(),
            ..Options::default()
        };
        assert!(generate(&options).contains("東京"));
    }
}