さだまさし弱者すぎて困ったので Scala でコンパイルすることにした話

scalaVersion := "2.11.7"
libraryDependencies += "com.github.seratch" %% "sadamasashi-compiler" % "0.1"
initialCommands := "import sadamasashi._"

// build.sbt
lazy val root = (project in file(".")).settings(
    name = "sadamasashi-compiler",
    scalaVersion := "2.11.7",
    libraryDependencies ++= Seq(
      "org.scala-lang"       %  "scala-compiler"              % scalaVersion.value,
      "org.scala-lang"       %  "scala-reflect"               % scalaVersion.value
    )
  )

// src/main/scala/sadamasashi/app.scala
package sadamasashi

import scala.language.dynamics
import scala.language.experimental.macros
import scala.reflect.macros.blackbox.Context

object SadaMasashi extends Dynamic {
  val songTitles = Seq("案山子", "防人の詩", "関白宣言")

  // Ruby の method_missing のようなものだと思ってください
  def selectDynamic(title: String): Song = macro SongCompilerMacro.selectDynamic
}

case class Song(title: String)

object SongCompilerMacro {
  def selectDynamic(c: Context)(title: c.Expr[String]): c.Tree = {
    import c.universe._
    val Literal(Constant(t: String)) = title.tree
    if (!SadaMasashi.songTitles.contains(t)) {
      c.error(c.enclosingPosition, "これはさだまさしさんの曲名ではないようです。")
    }
    q"_root_.sadamasashi.Song(title = $title)"
  }
}

$ sbt console

[info] Starting scala interpreter...
[info]
Welcome to Scala version 2.11.7 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_45).
Type in expressions to have them evaluated.
Type :help for more information.

scala> import sadamasashi._
import sadamasashi._

scala> SadaMasashi.案山子
res0: sadamasashi.Song = Song(案山子)

scala> SadaMasashi.神田川
<console>:14: error: これはさだまさしさんの曲名ではないようです。
       SadaMasashi.神田川
       ^

package object sadamasashi {
  val 佐田雅志 = SadaMasashi
  val さだまさし = 佐田雅志
  val まっさん = さだまさし
}

scala> import sadamasashi._
import sadamasashi._

scala> さだまさし.関白宣言
res0: sadamasashi.Song = Song(関白宣言)

lazy val root = (project in file(".")).settings(
    name = "sadamasashi-compiler",
    scalaVersion := "2.11.7",
    libraryDependencies ++= Seq(
      "org.scala-lang"       %  "scala-compiler"              % scalaVersion.value,
      "org.scala-lang"       %  "scala-reflect"               % scalaVersion.value
    ),
    initialCommands := "import sadamasashi._"
  )

$ sbt console

[info] Starting scala interpreter...
[info]
import sadamasashi._
Welcome to Scala version 2.11.7 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_45).
Type in expressions to have them evaluated.
Type :help for more information.

scala> さだまさし.関白宣言
res0: sadamasashi.Song = Song(関白宣言)

lazy val songTitles: Seq[String] = {
  using(getClass.getClassLoader.getResourceAsStream("song_titles.txt")) { txt =>
    scala.io.Source.fromInputStream(txt).mkString.split(",")
  }
}

lazy val root = (project in file(".")).settings(
    name = "sadamasashi-compiler",
    scalaVersion := "2.11.7",
    libraryDependencies ++= Seq(
      "org.scala-lang"       %  "scala-compiler"              % scalaVersion.value,
      "org.scala-lang"       %  "scala-reflect"               % scalaVersion.value,
      "org.skinny-framework" %% "skinny-common"               % "2.0.2",
      "org.apache.lucene"    %  "lucene-analyzers-kuromoji"   % "5.3.1",
      "org.slf4j"            %  "slf4j-simple"                % "1.7.13"
    ),
    initialCommands := "import sadamasashi._"
  )

package sadamasashi

import scala.language.dynamics
import scala.language.experimental.macros
import scala.reflect.macros.blackbox.Context
import skinny.activeimplicits.StringImplicits
import skinny.logging.LoggerProvider

object SadaMasashi extends Dynamic with StringImplicits {

  lazy val songTitles: Seq[String] = {
    using(getClass.getClassLoader.getResourceAsStream("song_titles.txt")) { txt =>
      scala.io.Source.fromInputStream(txt).mkString.split(",")
    }
  }
  lazy val songTitleCandidates: Seq[String] = {
    songTitles ++
      songTitles.map(_.hiragana) ++
      songTitles.map(_.katakana) ++
      songTitles.map(_.romaji)
  }

  def findCorrectSongTitle(title: String): Option[String] = {
    songTitles.find(t => Set(t.hiragana, t.katakana, t.romaji).contains(title))
  }

  def selectDynamic(title: String): Song = macro SongCompilerMacro.selectDynamic
}

case class Song(title: String)

object SongCompilerMacro extends LoggerProvider {

  def selectDynamic(c: Context)(title: c.Expr[String]): c.Tree = {
    import c.universe._
    val Literal(Constant(t: String)) = title.tree
    if (SadaMasashi.songTitles.contains(t)) {
      // NOOP
    } else if (SadaMasashi.songTitleCandidates.contains(t)) {
      val correctTitle = SadaMasashi.findCorrectSongTitle(t).getOrElse(t)
      logger.warn(s"""気を利かせておきましたが、正しい曲名は "${correctTitle}" です。""")
      return q"_root_.sadamasashi.Song(title = ${correctTitle})"
    } else {
      c.error(c.enclosingPosition, "これはさだまさしさんの曲名ではないようです。")
    }
    q"_root_.sadamasashi.Song(title = $title)"
  }
}

scala> さだまさし.かんぱくしっきゃく
[run-main-0] WARN sadamasashi.SongCompilerMacro$ - 気を利かせておきましたが、正しい曲名は "関白失脚" です。
res0: sadamasashi.Song = Song(関白失脚)

scala> さだまさし.カンパクシッキャク
[run-main-0] WARN sadamasashi.SongCompilerMacro$ - 気を利かせておきましたが、正しい曲名は "関白失脚" です。
res1: sadamasashi.Song = Song(関白失脚)

scala> SadaMasashi.kampakushikkyaku
[run-main-0] WARN sadamasashi.SongCompilerMacro$ - 気を利かせておきましたが、正しい曲名は "関白失脚" です。
res2: sadamasashi.Song = Song(関白失脚)

scala> さだまさし.秋桜
res0: sadamasashi.Song = Song(秋桜)

scala> さだまさし.こすもす
<console>:17: error: これはさだまさしさんの曲名ではないようです。
       さだまさし.こすもす
       ^

scala> import skinny.activeimplicits.StringImplicits._
import skinny.activeimplicits.StringImplicits._

scala> "秋桜".hiragana
res0: String = あきざくら

scala> import skinny.activeimplicits.StringImplicits._
import skinny.activeimplicits.StringImplicits._

scala> SadaMasashi.songTitles.map(t => (t, t.hiragana)).foreach(println)
(愛,あい)
(愛について,あいについて)
(愛の音,あいのおと)
(青空背負って,あおぞらせおって)
(青の季節,あおのきせつ)
(赤い靴,あかいくつ)
(赤い月,あかいつき)
(秋麗,あきうらら)
(空缶と白鷺,そらかんとしらさぎ)
(秋の虹,あきのにじ)
(あこがれの雲南,あこがれのうんなん)
(明日咲く花,あしたさくはな)
(明日檜,あしたひのき)
(安曇野,あずみの)

（以下省略・・）

秋桜,秋桜,コスモス,カスタム名詞
秋麗,秋麗,シュウレイ,カスタム名詞
空缶,空缶,アキカン,カスタム名詞
明日檜,明日檜,アスナロ,カスタム名詞
三昧,三昧,ザンマイ,カスタム名詞
雨やどり,雨やどり,アマヤドリ,カスタム名詞
十六夜,十六夜,イザヨイ,カスタム名詞
一杯,一杯,イッパイ,カスタム名詞
いのちの理由,いのちの理由,イノチノリユウ,カスタム名詞
驛舎,驛舎,エキ,カスタム名詞
縁切寺,縁切寺,エンキリデラ,カスタム名詞
糸遊,糸遊,イトユウ,カスタム名詞
金糸雀,金糸雀,カナリア,カスタム名詞
勧酒,勧酒,カンシュ,カスタム名詞
玻璃草子,玻璃草子,ガラスゾウシ,カスタム名詞
木根川橋,木根川橋,キネガワバシ,カスタム名詞
最后,最后,サイゴ,カスタム名詞
防人の詩,防人の詩,サキモリノウタ,カスタム名詞
残春,残春,ザンシュン,カスタム名詞
逍遙,逍遙,ショウヨウ,カスタム名詞
精霊流し,精霊流し,ショウロウナガシ,カスタム名詞
天狼星,天狼星,テンロウセイ,カスタム名詞
静夜思,静夜思,セイヤシ,カスタム名詞
桃花鳥,桃花鳥,トキ,カスタム名詞
小魚,小魚,コザカナ,カスタム名詞
春告鳥,春告鳥,ハルツゲドリ,カスタム名詞
廣重寫眞館,廣重寫眞館,ヒロシゲシャシンカン,カスタム名詞
風炎,風炎,フウエン,カスタム名詞
冬物語,冬物語,フユモノガタリ,カスタム名詞
邪馬臺,邪馬臺,ヤマタイ,カスタム名詞
理・不・尽,理・不・尽,リフジン,カスタム名詞
凛憧－りんどう－,凛憧－りんどう－,リンドウ,カスタム名詞
檸檬,檸檬,レモン,カスタム名詞

// src/main/scala/sadamasashi/package.scala
import scala.language.reflectiveCalls

package object sadamasashi {

  val 佐田雅志 = SadaMasashi
  val さだまさし = 佐田雅志
  val まっさん = さだまさし

  type Closable = { def close() }
  def using[R <: Closable, A](resource: R)(f: R => A): A = {
    try f(resource) finally try resource.close() catch { case scala.util.control.NonFatal(_) => }
  }

  def readLines(filename: String): Seq[String] = {
    using(getClass.getClassLoader.getResourceAsStream(filename)) { f =>
      scala.io.Source.fromInputStream(f).getLines.toIndexedSeq
    }
  }
}

// src/main/scala/sadamasashi/app.scala
package sadamasashi

import scala.language.dynamics
import scala.language.experimental.macros
import scala.reflect.macros.blackbox.Context
import skinny.activeimplicits.StringImplicits
import skinny.nlp.SkinnyJapaneseAnalyzerFactory
import skinny.logging.LoggerProvider

object SadaMasashi extends Dynamic with StringImplicits {

  implicit lazy val japaneseAnalyzer = {
    val dictionary = readLines("dictionary.txt").mkString("\n")
    SkinnyJapaneseAnalyzerFactory.create(dictionary)
  }

  lazy val songTitles: Seq[String] = readLines("song_titles.txt").mkString.split(",")

  lazy val songTitleCandidates: Seq[String] = {
    songTitles ++
      songTitles.map(_.hiragana) ++
      songTitles.map(_.katakana) ++
      songTitles.map(_.romaji)
  }

  def findCorrectSongTitle(title: String): Option[String] = {
    songTitles.find(t => Set(t.hiragana, t.katakana, t.romaji).contains(title))
  }

  def selectDynamic(title: String): Song = macro SongCompilerMacro.selectDynamic
}

case class Song(title: String)

object SongCompilerMacro extends LoggerProvider {

  def selectDynamic(c: Context)(title: c.Expr[String]): c.Tree = {
    import c.universe._
    val Literal(Constant(t: String)) = title.tree
    if (SadaMasashi.songTitles.contains(t)) {
      // NOOP
    } else if (SadaMasashi.songTitleCandidates.contains(t)) {
      val correctTitle = SadaMasashi.findCorrectSongTitle(t).getOrElse(t)
      logger.warn(s"""気を利かせておきましたが、正しい曲名は "${correctTitle}" です。""")
      return q"_root_.sadamasashi.Song(title = ${correctTitle})"
    } else {
      c.error(c.enclosingPosition, "これはさだまさしさんの曲名ではないようです。")
    }
    q"_root_.sadamasashi.Song(title = $title)"
  }
}

scala> さだまさし.こすもす
[run-main-0] WARN sadamasashi.SongCompilerMacro$ - 気を利かせておきましたが、正しい曲名は "秋桜" です。
res0: sadamasashi.Song = Song(秋桜)

scala> さだまさし.れもん
[run-main-0] WARN sadamasashi.SongCompilerMacro$ - 気を利かせておきましたが、正しい曲名は "檸檬" です。
res1: sadamasashi.Song = Song(檸檬)

lazy val root = (project in file(".")).settings(
    name := "scadamasashi-compiler",
    scalaVersion := "2.11.7",
    libraryDependencies ++= Seq(
      "org.scala-lang"       %  "scala-compiler"              % scalaVersion.value,
      "org.scala-lang"       %  "scala-reflect"               % scalaVersion.value,
      "org.skinny-framework" %% "skinny-common"               % "2.0.2",
      "org.apache.lucene"    %  "lucene-analyzers-kuromoji"   % "5.3.1",
      "org.apache.lucene"    %  "lucene-suggest"              % "5.3.1",
      "org.slf4j"            %  "slf4j-simple"                % "1.7.13",
      "org.scalatest"        %% "scalatest"                   % "2.2.5" % Test
    ),
    initialCommands := "import sadamasashi._"
  )

package sadamasashi

import org.apache.lucene.search.spell.LevensteinDistance
import scala.language.dynamics
import scala.language.experimental.macros
import scala.reflect.macros.blackbox.Context
import skinny.activeimplicits.StringImplicits
import skinny.nlp.SkinnyJapaneseAnalyzerFactory
import skinny.logging.LoggerProvider

object SadaMasashi extends Dynamic with StringImplicits {

  implicit lazy val japaneseAnalyzer = {
    val dictionary = readLines("dictionary.txt").mkString("\n")
    SkinnyJapaneseAnalyzerFactory.create(dictionary)
  }

  lazy val songTitles: Seq[String] = readLines("song_titles.txt").mkString.split(",")
  lazy val hiraganaSongTitles: Seq[String] = songTitles.map(_.hiragana)
  lazy val katakanaSongTitles: Seq[String] = songTitles.map(_.katakana)
  lazy val romajiSongTitles: Seq[String] = songTitles.map(_.romaji)

  lazy val songTitleCandidates: Seq[String] = {
    songTitles ++
      hiraganaSongTitles ++
      katakanaSongTitles ++
      romajiSongTitles
  }

  def findCorrectSongTitle(title: String): Option[String] = {
    songTitles.find(t => Set(t.hiragana, t.katakana, t.romaji).contains(title))
  }

  private[this] lazy val distance = new LevensteinDistance

  def suggestSongTitles(title: String): Seq[String] = {
    val hiraganaTitle = title.hiragana
    (songTitles.map(t => (t, distance.getDistance(t, title))) ++
      hiraganaSongTitles.map(t => (t, distance.getDistance(t, hiraganaTitle))))
      .filter { case (_, similarity) => similarity >= 0.3 }
      .sortWith { case ((_, a), (_, b)) => a > b }
      .flatMap { case (e, _) => findCorrectSongTitle(e) }
      .distinct
      .take(10)
  }

  def selectDynamic(title: String): Song = macro SongCompilerMacro.selectDynamic
}

case class Song(title: String)

object SongCompilerMacro extends LoggerProvider {

  def selectDynamic(c: Context)(title: c.Expr[String]): c.Tree = {
    import c.universe._
    val Literal(Constant(t: String)) = title.tree
    if (SadaMasashi.songTitles.contains(t)) {
      // NOOP
    } else if (SadaMasashi.songTitleCandidates.contains(t)) {
      val correctTitle = SadaMasashi.findCorrectSongTitle(t).getOrElse(t)
      logger.warn(s"""気を利かせておきましたが、正しい曲名は "${correctTitle}" です。""")
      return q"_root_.sadamasashi.Song(title = ${correctTitle})"
    } else {
      val suggestions = {
        val s = SadaMasashi.suggestSongTitles(t).take(5).mkString(", ")
        if (s.isEmpty) "" else s"（もしかして: $s)"
      }
      c.error(c.enclosingPosition, s"これはさだまさしさんの曲名ではないようです。$suggestions")
    }
    q"_root_.sadamasashi.Song(title = $title)"
  }
}

scala> さだまさし.ライオン
<console>:14: error: これはさだまさしさんの曲名ではないようです。（もしかして: 風に立つライオン, 愛の音, 絵画館, 指定券, 地平線)
       さだまさし.ライオン
       ^

package sadamasashi

import java.awt.Desktop
import java.net.{ URLEncoder, URI }
import com.google.api.services.youtube.model.SearchResult
import org.apache.lucene.search.spell.LevensteinDistance
import scala.language.dynamics
import scala.language.experimental.macros
import scala.reflect.macros.blackbox.Context
import skinny.activeimplicits.StringImplicits
import skinny.nlp.SkinnyJapaneseAnalyzerFactory
import skinny.logging.LoggerProvider

object SadaMasashi extends Dynamic with StringImplicits {

  implicit lazy val japaneseAnalyzer = {
    val dictionary = readLines("dictionary.txt").mkString("\n")
    SkinnyJapaneseAnalyzerFactory.create(dictionary)
  }

  lazy val songTitles: Seq[String] = readLines("song_titles.txt").mkString.split(",")
  lazy val hiraganaSongTitles: Seq[String] = songTitles.map(_.hiragana)
  lazy val katakanaSongTitles: Seq[String] = songTitles.map(_.katakana)
  lazy val romajiSongTitles: Seq[String] = songTitles.map(_.romaji)

  lazy val songTitleCandidates: Seq[String] = {
    songTitles ++
      hiraganaSongTitles ++
      katakanaSongTitles ++
      romajiSongTitles
  }

  def findCorrectSongTitle(title: String): Option[String] = {
    songTitles.find(t => Set(t.hiragana, t.katakana, t.romaji).contains(title))
  }

  private[this] lazy val distance = new LevensteinDistance

  def suggestSongTitles(title: String): Seq[(String, Float)] = {
    val hiraganaTitle = title.hiragana
    (songTitles.map(t => (t, distance.getDistance(t, title))) ++
      hiraganaSongTitles.map(t => (t, distance.getDistance(t, hiraganaTitle))))
      .filter { case (_, similarity) => similarity >= 0.3F }
      .sortWith { case ((_, a), (_, b)) => a > b }
      .flatMap { case (t, s) => findCorrectSongTitle(t).map(t => (t, s)) }
      .take(5)
  }

  // 曲名を指定
  def selectDynamic(title: String): Song = macro SongCompilerMacro.selectDynamic
}

case class Song(title: String)

object SongCompilerMacro extends LoggerProvider {

  def selectDynamic(c: Context)(title: c.Expr[String]): c.Tree = {
    import c.universe._
    val Literal(Constant(t: String)) = title.tree
    if (SadaMasashi.songTitles.contains(t)) {
      // NOOP
    } else if (SadaMasashi.songTitleCandidates.contains(t)) {
      val correctTitle = SadaMasashi.findCorrectSongTitle(t).getOrElse(t)
      logger.warn(s"""気を利かせておきましたが、正しい曲名は "${correctTitle}" です。""")
      return q"_root_.sadamasashi.Song(title = ${correctTitle})"
    } else {
      val suggestions = {
        val ss = SadaMasashi.suggestSongTitles(t)
        ss.headOption.foreach {
          case (_, s) if s <= 0.5F =>
            val google = new URI(s"https://www.google.co.jp/search?q=${URLEncoder.encode(s"さだまさし ${t}", "UTF-8")}")
            Desktop.getDesktop.browse(google)
          case _ =>
        }
        val str = ss.map { case (t, s) => "%s (%1.2f)".format(t, s) }.mkString(", ")
        if (str.isEmpty) "" else s"もしかして: $str"
      }
      c.error(c.enclosingPosition, s"これはさだまさしさんの曲名ではないようです。$suggestions")
    }
    q"_root_.sadamasashi.Song(title = $title)"
  }
}

scala> さだまさし.天皇の料理番
<console>:14: error: これはさだまさしさんの曲名ではないようです。もしかして: いのちの理由 (0.36), 転校生(ちょっとピンボケ) (0.36), 検察側の証人 (0.33), 天空の村に月が降る (0.31)
       さだまさし.天皇の料理番
       ^

scala> さだまさし.夢見る人
res1: sadamasashi.Song = Song(夢見る人)

    libraryDependencies ++= Seq(
      "org.scala-lang"       %  "scala-compiler"              % scalaVersion.value,
      "org.scala-lang"       %  "scala-reflect"               % scalaVersion.value,
      "org.skinny-framework" %% "skinny-common"               % "2.0.2",
      "org.apache.lucene"    %  "lucene-analyzers-kuromoji"   % "5.3.1",
      "org.apache.lucene"    %  "lucene-suggest"              % "5.3.1",
      "org.slf4j"            %  "slf4j-simple"                % "1.7.13",
      "com.google.apis"      %  "google-api-services-youtube" % "v3-rev157-1.19.1"
    ),

package sadamasashi

import java.awt.Desktop
import java.net.{ URLEncoder, URI }
import com.google.api.services.youtube.model.SearchResult
import org.apache.lucene.search.spell.LevensteinDistance
import scala.language.dynamics
import scala.language.experimental.macros
import scala.reflect.macros.blackbox.Context
import skinny.activeimplicits.StringImplicits
import skinny.nlp.SkinnyJapaneseAnalyzerFactory
import skinny.logging.LoggerProvider

object SadaMasashi extends Dynamic with StringImplicits {

  implicit lazy val japaneseAnalyzer = {
    val dictionary = readLines("dictionary.txt").mkString("\n")
    SkinnyJapaneseAnalyzerFactory.create(dictionary)
  }

  lazy val songTitles: Seq[String] = readLines("song_titles.txt").mkString.split(",")
  lazy val hiraganaSongTitles: Seq[String] = songTitles.map(_.hiragana)
  lazy val katakanaSongTitles: Seq[String] = songTitles.map(_.katakana)
  lazy val romajiSongTitles: Seq[String] = songTitles.map(_.romaji)

  lazy val songTitleCandidates: Seq[String] = {
    songTitles ++
      hiraganaSongTitles ++
      katakanaSongTitles ++
      romajiSongTitles
  }

  def findCorrectSongTitle(title: String): Option[String] = {
    songTitles.find(t => Set(t.hiragana, t.katakana, t.romaji).contains(title))
  }

  private[this] lazy val distance = new LevensteinDistance

  def suggestSongTitles(title: String): Seq[(String, Float)] = {
    val hiraganaTitle = title.hiragana
    (songTitles.map(t => (t, distance.getDistance(t, title))) ++
      hiraganaSongTitles.map(t => (t, distance.getDistance(t, hiraganaTitle))))
      .filter { case (_, similarity) => similarity >= 0.3F }
      .sortWith { case ((_, a), (_, b)) => a > b }
      .flatMap { case (t, s) => findCorrectSongTitle(t).map(t => (t, s)) }
      .take(5)
  }

  private[this] val r = new scala.util.Random()
  def randomSongTitle: String = songTitles.apply(r.nextInt(songTitles.size))

  // 曲名を指定
  def selectDynamic(title: String): Song = macro SongCompilerMacro.selectDynamic

  // さださんの全てを知り尽くすまでコンパイルは失敗し続けます
  def learnMore: SadaMasashi.type = macro SongCompilerMacro.learnMore
  def もっと知りたい: SadaMasashi.type = macro SongCompilerMacro.learnMore
  def もっと学びたい: SadaMasashi.type = macro SongCompilerMacro.learnMore
}

case class SadaVideo(key: String) {
  import scala.collection.JavaConverters._
  import com.google.api.client.googleapis.auth.oauth2.GoogleCredential
  import com.google.api.client.http.apache.ApacheHttpTransport
  import com.google.api.client.json.jackson2.JacksonFactory
  import com.google.api.services.youtube.YouTube

  def find(title: String): Option[SearchResult] = {
    val youTube = new YouTube.Builder(new ApacheHttpTransport, new JacksonFactory, new GoogleCredential)
      .setApplicationName("sadamasashi-compiler").build()
    val youTubeSearch = youTube.search.list("id,snippet")
    youTubeSearch.setType("video")
    youTubeSearch.setFields("items(id/kind,id/videoId,snippet/title,snippet/thumbnails/default/url)")
    youTubeSearch.setMaxResults(50L)
    val query = s"さだまさし ${title}"
    youTubeSearch.setQ(query)
    youTubeSearch.setKey(key)
    val youTubeResponse = youTubeSearch.execute()
    youTubeResponse.getItems.asScala
      .filter(_.getSnippet.getTitle.contains("さだまさし"))
      .headOption
  }

}

case class Song(title: String)

object SongCompilerMacro extends LoggerProvider {

  def selectDynamic(c: Context)(title: c.Expr[String]): c.Tree = {
    import c.universe._
    val Literal(Constant(t: String)) = title.tree
    if (SadaMasashi.songTitles.contains(t)) {
      // NOOP
    } else if (SadaMasashi.songTitleCandidates.contains(t)) {
      val correctTitle = SadaMasashi.findCorrectSongTitle(t).getOrElse(t)
      logger.warn(s"""気を利かせておきましたが、正しい曲名は "${correctTitle}" です。""")
      return q"_root_.sadamasashi.Song(title = ${correctTitle})"
    } else {
      val suggestions = {
        val ss = SadaMasashi.suggestSongTitles(t)
        ss.headOption.foreach {
          case (_, s) if s <= 0.5F =>
            val google = new URI(s"https://www.google.co.jp/search?q=${URLEncoder.encode(s"さだまさし ${t}", "UTF-8")}")
            Desktop.getDesktop.browse(google)
          case _ =>
        }
        val str = ss.map { case (t, s) => "%s (%1.2f)".format(t, s) }.mkString(", ")
        if (str.isEmpty) "" else s"もしかして: $str"
      }
      c.error(c.enclosingPosition, s"これはさだまさしさんの曲名ではないようです。$suggestions")
    }
    q"_root_.sadamasashi.Song(title = $title)"
  }

  def learnMore(c: Context): c.Tree = {
    import c.universe._
    sys.env.get("GOOGLE_API_KEY") match {
      case Some(key) =>
        val title = SadaMasashi.randomSongTitle
        SadaVideo(key).find(title) match {
          case Some(video) =>
            val uri = new URI(s"https://www.youtube.com/watch?v=${video.getId.getVideoId}")
            Desktop.getDesktop.browse(uri)
            c.error(c.enclosingPosition,
              s"""|
              | "さだまさし ${title}" で YouTube 動画を検索しました。
              | 「${video.getSnippet.getTitle}」(${uri}) がオススメです。
              | しっかりと理解を深めましょう。
              |""".stripMargin)
          case _ => c.error(c.enclosingPosition,
            s"""|
            | "さだまさし ${title}" で YouTube 動画を検索しました。
            | オススメの動画が見つかりませんでした。
            | もう一度お試しください。
            |""".stripMargin)
        }
      case _ =>
        val googleUri = new URI("https://console.developers.google.com/apis/credentials")
        Desktop.getDesktop.browse(googleUri)
        c.error(c.enclosingPosition,
          s"""|
          | 環境変数 GOOGLE_API_KEY に Google の API キーを設定すると無限にさだまさしさんについて学ぶことができます。
          | $googleUri にアクセスして API キーを発行・確認して
          | export GOOGLE_API_KEY={API キーの値}
          | のように設定してください。
          |""".stripMargin)
    }
    q"_root_.sadamasashi.SadaMasashi"
  }

}

scala> さだまさし.もっと知りたい
<console>:14: error:
 環境変数 GOOGLE_API_KEY に YouTube の API キーを設定すると無限にさだまさしさんについて学ぶことができます。
 https://console.developers.google.com/apis/credentials にアクセスして API キーを発行・確認して
 export GOOGLE_API_KEY={API キーの値}
 のように設定してください。

       さだまさし.もっと知りたい
             ^

scala> さだまさし.もっと知りたい
<console>:14: error:
 "さだまさし SMILE AGAIN" で YouTube 動画を検索しました。
 「「SMILE AGAIN」　　夏 長崎から92 　さだまさし」(https://www.youtube.com/watch?v=TpGY3o9310M) がオススメです。
 しっかりと理解を深めましょう。

       さだまさし.もっと知りたい
             ^

case class Song(title: String) {

  def show(): Unit = {
    sys.env.get("GOOGLE_API_KEY") match {
      case Some(key) =>
        SadaVideo(key).find(title) match {
          case Some(video) =>
            val uri = new URI(s"https://www.youtube.com/watch?v=${video.getId.getVideoId}")
            Desktop.getDesktop.browse(uri)
          case _ =>
            sys.error("YouTube で動画が見つかりませんでした。")
        }
      case _ =>
        val googleUri = new URI("https://console.developers.google.com/apis/credentials")
        Desktop.getDesktop.browse(googleUri)
        sys.error("環境変数 GOOGLE_API_KEY を設定してください。")
    }
  }

  def を観る(): Unit = show()
}

さだまさし.夢見る人.を観る
さだまさし.精霊流し.を観る
さだまさし.道化師のソネット.を観る