def genType()

in scrooge-generator/src/main/scala/com/twitter/scrooge/backend/Generator.scala [567:680]
95 lines of code
11 McCabe index (conditional complexity)

  def genType(t: FunctionType, immutable: Boolean = false): CodeFragment

  def genPrimitiveType(t: FunctionType): CodeFragment

  def genFieldType(f: Field): CodeFragment

  def genFieldParams(fields: Seq[Field], asVal: Boolean = false): CodeFragment

  def genBaseFinagleService: CodeFragment

  def finagleClientFile(
    packageDir: File,
    service: Service,
    options: Set[ServiceOption]
  ): Option[File] =
    None

  def finagleServiceFile(
    packageDir: File,
    service: Service,
    options: Set[ServiceOption]
  ): Option[File] =
    None

  def templates: HandlebarLoader
  def fileExtension: String

  def apply(
    serviceOptions: Set[ServiceOption],
    outputPath: File,
    dryRun: Boolean = false,
    genAdapt: Boolean = false
  ): Iterable[File] = {
    val generatedFiles = new mutable.ListBuffer[File]
    val doc = normalizeCase(resolvedDoc.document)
    val header = templates.header(resolvedDoc.filePath)
    val namespace = getNamespace(resolvedDoc.document)
    val packageDir = namespacedFolder(outputPath, namespace.fullName, dryRun)
    val includes = doc.headers.collect {
      case x @ Include(_, _) => x
    }
    val validator = getValidator(resolvedDoc.document)
    // validate default annotations applied to structs during generation
    validateStructAnnotations(doc.structs)

    if (doc.consts.nonEmpty) {
      val file = new File(packageDir, "Constants" + fileExtension)
      if (!dryRun) {
        val dict = constDict(namespace, doc.consts)
        writeFile(file, header, templates("consts").generate(dict))
      }
      generatedFiles += file
    }

    doc.enums.foreach { enum =>
      val file = new File(packageDir, enum.sid.toTitleCase.name + fileExtension)
      if (!dryRun) {
        val dict = enumDict(namespace, enum)
        writeFile(file, header, templates("enum").generate(dict))
      }
      generatedFiles += file
    }

    doc.structs.foreach { struct =>
      val file = new File(packageDir, struct.sid.toTitleCase.name + fileExtension)

      if (!dryRun) {
        val templateName =
          struct match {
            case _: Union => "union"
            case _ => "struct"
          }

        val dict =
          structDict(
            struct,
            Some(namespace),
            includes,
            serviceOptions,
            genAdapt,
            toplevel = true,
            validator)
        writeFile(file, header, templates(templateName).generate(dict))
      }
      generatedFiles += file
    }

    doc.services.foreach { service =>
      val allOptions = serviceOptions ++ service.options
      val interfaceFile = new File(packageDir, service.sid.toTitleCase.name + fileExtension)
      val finagleClientFileOpt = finagleClientFile(packageDir, service, allOptions)
      val finagleServiceFileOpt = finagleServiceFile(packageDir, service, allOptions)

      if (!dryRun) {
        val dict = serviceDict(service, namespace, includes, allOptions, genAdapt)
        writeFile(interfaceFile, header, templates("service").generate(dict))

        finagleClientFileOpt foreach { file =>
          val dict = finagleClient(service, namespace, allOptions.contains(WithAsClosable))
          writeFile(file, header, templates("finagleClient").generate(dict))
        }

        finagleServiceFileOpt foreach { file =>
          val dict = finagleService(service, namespace)
          writeFile(file, header, templates("finagleService").generate(dict))
        }
      }
      generatedFiles += interfaceFile
      generatedFiles ++= finagleServiceFileOpt
      generatedFiles ++= finagleClientFileOpt
    }

    generatedFiles
  }