def prepareResult()

in scala-interpreter/src/main/scala/org/apache/toree/kernel/interpreter/scala/ScalaInterpreter.scala [195:277]
60 lines of code
22 McCabe index (conditional complexity)

  def prepareResult(interpreterOutput: String,
                    showType: Boolean = KernelOptions.showTypes, // false
                    noTruncate: Boolean = KernelOptions.noTruncation, // false
                    showOutput: Boolean = KernelOptions.showOutput // true
                   ): (Option[Any], Option[String], Option[String]) = {
    if (interpreterOutput.isEmpty) {
      return (None, None, None)
    }

    var lastResult = Option.empty[Any]
    var lastResultAsString = ""
    val definitions = new StringBuilder
    val text = new StringBuilder

    interpreterOutput.split("\n").foreach {

      case HigherOrderFunction(name, func, funcType) =>

        definitions.append(s"$name: $func$funcType").append("\n")

      case NamedResult(name, vtype, value) if read(name).nonEmpty =>

        val result = read(name)

        lastResultAsString = result.map(String.valueOf(_)).getOrElse("")
        lastResult = result

        // magicOutput should be handled as result to properly
        // display based on MimeType.
        if(vtype != "org.apache.toree.magic.MagicOutput") {
          // default noTruncate = False
          // %truncation on ==>  noTruncate = false -> display Value
          // %truncation off ==>  noTruncate = true  -> display lastResultAsString
          val defLine = (showType, noTruncate) match {
            case (true, true) =>
              s"$name: $vtype = $lastResultAsString\n"
            case (true, false) =>
              lastResultAsString = value
              lastResult = Some(value)
              s"$name: $vtype = $value\n"
            case (false, true) =>
              s"$name = $lastResultAsString\n"
            case (false, false) =>
              lastResultAsString = value
              lastResult = Some(value)
              s"$name = $value\n"
          }

          // suppress interpreter-defined values
          if ( defLine.matches("res\\d+(.*)[\\S\\s]") == false ) {
            definitions.append(defLine)
          }

          if(showType) {
            if(defLine.startsWith("res")) {
              val v = defLine.split("^res\\d+(:|=)\\s+")(1)
              lastResultAsString = v
              lastResult = Some(v)
            } else {
              lastResultAsString = defLine
              lastResult = Some(defLine)
            }
          }
        }

      case Definition(defType, name) =>
        lastResultAsString = ""
        definitions.append(s"defined $defType $name\n")

      case Import(name) =>
        // do nothing with the line

      case line if lastResultAsString.contains(line) =>
        // do nothing with the line

      case line =>
        text.append(line).append("\n")
    }

    (lastResult,
     if (definitions.nonEmpty && showOutput) Some(definitions.toString) else None,
     if (text.nonEmpty && showOutput) Some(text.toString) else None)
  }