Scalaで何かをやりたいときに「どうなった？」の試行をまとめておくGist。

ScalaExecutableScraps.scala

import java.util.LinkedHashMap
import org.ho.yaml.exception.ObjectCreationException
import org.ho.yaml.Yaml
import org.scalatest.junit.JUnitSuite
import org.junit.Assert._
import org.junit.Test
import scala.collection.mutable.ListBuffer
import scala.collection.mutable.HashMap

/**
 * 何かをやりたいときに「どうなった？」の試行をまとめておくGist。
 * ScalaTest + JUnit4 方式で記述。
 */
class ScalaExecutableScraps extends JUnitSuite {

  @Test
  def JUnitスタイルアサーション例 {
    val sb = new StringBuilder("ScalaTest は")
    sb.append("かんたん！")
    assertEquals("ScalaTest はかんたん！", sb.toString)

    val lb = new ListBuffer[String]
    assertTrue(lb.isEmpty)
    lb += "sweet"
    try {
      "verbose".charAt(-1)
      fail()
    }
    catch {
      case e: StringIndexOutOfBoundsException => // こうなるはず
    }
  }

  @Test
  def ScalaTestアサーション例() {
    // ScalaTest アサーションを使用
    val sb = new StringBuilder("ScalaTest は")
    sb.append("たのしい！")
    assert(sb.toString === "ScalaTest はたのしい！")
    val lb = new ListBuffer[String]
    assert(lb.isEmpty)
    lb += "sweeter"
    intercept[StringIndexOutOfBoundsException] {
      "concise".charAt(-1)
    }
  }

  @Test
  def JYamlを使ったScalaタイプのMapやListのyaml文字列化例() {

    // 対象データはScala方式で作った「MapのMap」とする。
    val scalaMap = Map(
      "11" -> Map(
        "12" -> Map(
          "13" -> Map(
            "14" -> Map()
            , "other" -> Map()
          )
          , "16" -> Map(
            "17" -> Map()
          )
        )
        , "18" -> Map(
          "19" -> Map(
            "20" -> Map()
          )
        )
      )
    )

    // JYaml のクラスを使って文字列化しようとする…が、この記述は実行時例外となる。
    intercept[ObjectCreationException] {
      Yaml.dump(scalaMap) // どうやらSerializeと良く似てて「new等で復元可能」でないといけないようだ。
    }

    // Emutableがダメなのかと思い、MutableなScalaのMapへと返還してから、Yaml化してみる。
    def convertToMutableScalaMap(source: Map[String, Object]): HashMap[String, Object] = {
      val mMap = new HashMap[String, Object]()
      source.foreach {
        case (k, v: Map[String, Object]) =>
          mMap.put(k, convertToMutableScalaMap(v))
      }
      mMap
    }

    val mutableScalaMap = convertToMutableScalaMap(scalaMap)

    // JYamlを使用して、オブジェクトをYamlテキスト化。
    val yamlByMutableScalaMap = Yaml.dump(mutableScalaMap)

    // Yaml化自体は成功するのだが…なぜかデータが消失し、スカスカなテキストとなる。
    assert(yamlByMutableScalaMap ===
      """--- !scala.collection.mutable.HashMap {}
""")

    // そもそも、JYamlはJava用につくられたものである。Java謹製のMapなら行けるのではないか。
    // Java謹製のjava.util.Map系の実装クラスのオブジェクトで試行。

    def convertToMutableJavaMap(source: Map[String, Object]): LinkedHashMap[String, Object] = {
      val jMap = new LinkedHashMap[String, Object]()
      source.foreach {
        case (k, v: Map[String, Object]) =>
          jMap.put(k, convertToMutableJavaMap(v))
      }
      jMap
    }

    val mutableJavaMap = convertToMutableJavaMap(scalaMap)

    // JYamlを使用して、オブジェクトをYamlテキスト化。
    val yamlMutableJavaMap = Yaml.dump(mutableJavaMap)

    // Yaml化自体は成功する。データ消失もなし。
    assert(yamlMutableJavaMap ===
      """--- !java.util.LinkedHashMap
"11": !java.util.LinkedHashMap
  "12": !java.util.LinkedHashMap
    "13": !java.util.LinkedHashMap
      "14": !java.util.LinkedHashMap {}
      other: !java.util.LinkedHashMap {}
    "16": !java.util.LinkedHashMap
      "17": !java.util.LinkedHashMap {}
  "18": !java.util.LinkedHashMap
    "19": !java.util.LinkedHashMap
      "20": !java.util.LinkedHashMap {}
""")
    // だが…復元のため型が全ての行につくのは、データフォーマットとしては嫌だな。

  }

  @Test
  def Scalaにおける文字列表現の簡易化() {

    val depth = 3
    val value = "Three"

    // Java的に書くとこう
    val expected = "   " + depth + ":'" + value + "'\n"
    // Scala的に簡易化するとこう
    val actual = s"${(" " * depth)}$depth:'${value}'\n"

    assert(actual === expected)

  }

}