ika_bot/lib/verb.rb

U_VOWEL_CHANGES = {
  "る" => { "a" => "ら", "i" => "り", "u" => "る", "e" => "れ", "o" => "ろ" },
  "う" => { "a" => "あ", "i" => "い", "u" => "う", "e" => "え", "o" => "お" },
  "つ" => { "a" => "た", "i" => "ち", "u" => "つ", "e" => "て", "o" => "と" },
  "す" => { "a" => "さ", "i" => "し", "u" => "す", "e" => "せ", "o" => "そ" },
  "く" => { "a" => "か", "i" => "き", "u" => "く", "e" => "け", "o" => "こ" },
  "ぐ" => { "a" => "が", "i" => "ぎ", "u" => "ぐ", "e" => "げ", "o" => "ご" },
  "ぶ" => { "a" => "ば", "i" => "び", "u" => "ぶ", "e" => "べ", "o" => "ぼ" },
  "む" => { "a" => "ま", "i" => "み", "u" => "む", "e" => "め", "o" => "も" },
  "ぬ" => { "a" => "な", "i" => "に", "u" => "ぬ", "e" => "ね", "o" => "の" },
}

TE_TA_DE_DA = {
  "て" => "た", "で" => "だ"
}

class KanaKanji
  attr_reader :kana, :kanji
  def initialize(kana, kanji=nil)
    @kana = kana
    @kanji = kanji || kana
  end

  def [](index)
    self.class.new kana[index], kanji[index]
  end

  def +(other)
    case other
    when String
      self.class.new kana + other, kanji + other
    when KanaKanji
      self.class.new kana + other.kana, kanji + other.kanji
    end
  end

  def last_character(new_form=nil)
    return kana[-1] unless new_form
    U_VOWEL_CHANGES[kana[-1]][new_form]
  end

  def all_but_last_character
    self.class.new kana[0...-1], kanji[0...-1]
  end
end

class Verb
  attr_reader :dict_kanji, :dict_kana, :definition, :dict

  def initialize(dict_kanji, dict_kana, definition)
    @dict_kanji = dict_kanji || dict_kana
    @dict_kana = dict_kana
    @dict = KanaKanji.new dict_kana, dict_kanji
    @definition = definition
  end

  def last_character(new_form=nil)
    dict.last_character(new_form)
  end

  def all_but_last_character
    dict.all_but_last_character
  end

  def dictionary
    dict
  end

  def long_form_present_positive
    stem + "ます"
  end

  def long_form_present_negative
    stem + "ません"
  end

  def long_form_past_positive
    stem + "ました"
  end

  def long_form_past_negative
    long_form_present_negative + "でした"
  end

  def short_form_present_positive
    dictionary
  end

  def short_form_present_negative
    negative_stem + "ない"
  end

  def short_form_past_positive
    te.all_but_last_character + TE_TA_DE_DA[te.last_character]
  end

  def short_form_past_negative
    short_form_present_negative.all_but_last_character + "かった"
  end

  def desire
    stem + "たい"
  end

  def potential
    IchidanVerb.new(potential_starter.kanji, potential_starter.kana, "to be able #{definition}")
  end
end

class IchidanVerb < Verb
  def stem
    all_but_last_character
  end

  def negative_stem
    stem
  end

  def te
    all_but_last_character + "て"
  end

  def potential_starter
    stem + "られる"
  end
end

class GodanVerb < Verb
  def iku?
    dict.kanji == "行く"
  end

  def aru?
    dict.kanji == "ある"
  end

  def stem
    all_but_last_character + last_character("i")
  end

  def short_form_present_negative
    return KanaKanji.new("ない") if aru?

    super
  end

  def negative_stem
    all_but_last_character + last_character("a")
  end

  def potential_starter
    all_but_last_character + last_character("e") + "る"
  end

  def te
    all_but_last_character + case last_character
                             when "う"
                               "って"
                             when "る"
                               "って"
                             when "つ"
                               "って"
                             when "す"
                               "して"
                             when "く"
                               iku? ? "って" : "いて"
                             when "ぐ"
                               "いで"
                             when "ぶ"
                               "んで"
                             when "む"
                               "んで"
                             when "ぬ"
                               "んで"
                             end
  end
end

class SuruVerb < Verb
  def prefix
    dict[..-3]
  end

  def stem
    prefix + "し"
  end

  def negative_stem
    prefix + "し"
  end

  def te
    prefix + "して"
  end

  def potential_starter
    prefix + "できる"
  end
end

class KuruVerb < Verb
  def prefix
    dict[..-3]
  end

  def te
    stem + "て"
  end

  def stem
    prefix + KanaKanji.new("き", "来")
  end

  def negative_stem
    prefix + KanaKanji.new("こ", "来")
  end

  def potential_starter
    negative_stem + "られる"
  end
end