private def cacheControlLookup()

in magenta-lib/src/main/scala/magenta/tasks/gcp/GCSTasks.scala [183:305]
109 lines of code
14 McCabe index (conditional complexity)

  private def cacheControlLookup(fileName: String) = cacheControlPatterns
    .find(_.regex.findFirstMatchIn(fileName).isDefined)
    .map(_.value)

  private def getCurrentObjectsForDeletion(
      storage: Storage
  ): List[StorageObject] = {

    val objectsInThisDeploy = transfers.map(_.target).toList

    def getAllObjectsForDirectory(
        query: Storage#Objects#List,
        foundSoFar: List[StorageObject] = List.empty
    ): List[StorageObject] = {

      val listResults = query.execute
      val currentPageItems = Option(listResults.getItems)
        .map(resultsSet => resultsSet.asScala)
        .getOrElse(List.empty)
      val allItemsFoundSoFar = foundSoFar ++ currentPageItems

      Option(listResults.getNextPageToken) match {
        case Some(token) =>
          getAllObjectsForDirectory(
            query.setPageToken(token),
            allItemsFoundSoFar
          )
        case None => allItemsFoundSoFar
      }
    }

    def allObjectsInMatchingDirectories(
        directoriesToPurge: List[String],
        itemsSoFar: List[StorageObject] = List.empty
    ): List[StorageObject] =
      directoriesToPurge match {
        case Nil => itemsSoFar
        case head :: tail =>
          val gcsQuery = storage
            .objects()
            .list(gcsTargetBucket.name)
            .setPrefix(head)
          val allItemsForThisDirectory =
            getAllObjectsForDirectory(gcsQuery, itemsSoFar)
          allObjectsInMatchingDirectories(
            tail,
            itemsSoFar ::: allItemsForThisDirectory
          )
      }

    def tidyFileType(configuredFileType: String): String = {
      if (configuredFileType.startsWith("."))
        configuredFileType
      else
        s".${configuredFileType}"
    }

    def filterListByFileTypes(
        allDeployedObjects: List[StorageObject],
        filetypesToPurge: List[String],
        matchingObjects: List[StorageObject] = List.empty
    ): List[StorageObject] = {
      filetypesToPurge match {
        case Nil => matchingObjects
        case head :: tail =>
          val safeFileExtension = tidyFileType(head)
          val objectsMatchingThisFiletype = allDeployedObjects.filter(ob =>
            ob.getName.endsWith(safeFileExtension)
          )
          filterListByFileTypes(
            allDeployedObjects,
            tail,
            matchingObjects ::: objectsMatchingThisFiletype
          )
      }
    }

    def findCurrentObjectsNotInThisTransfer(
        objectsToCheckInCurrentDeploy: List[StorageObject],
        objectsPreviouslyDeployed: List[StorageObject],
        objectsToDelete: List[StorageObject] = List.empty
    ): List[StorageObject] = {
      objectsToCheckInCurrentDeploy match {
        case Nil => objectsToDelete
        case head :: tail =>
          objectsPreviouslyDeployed.find(so =>
            so.getName == head.getName
          ) match {
            case Some(_) =>
              // Was previously deployed and is being re-deployed, keep it
              findCurrentObjectsNotInThisTransfer(
                tail,
                objectsPreviouslyDeployed,
                objectsToDelete
              )
            case None =>
              // Was previously deployed but not in this deploy. Delete it
              findCurrentObjectsNotInThisTransfer(
                tail,
                objectsPreviouslyDeployed,
                head :: objectsToDelete
              )
          }
      }
    }

    val allItemsForConfiguredDirectories =
      gcsTargetBucket.directoriesToPurge match {
        // Nothing to delete = This isn't datatech's composer usecase, but hey ..
        case Nil => List.empty
        case directoriesToPurge =>
          allObjectsInMatchingDirectories(directoriesToPurge)
      }

    val allItemsFilteredByType = filterListByFileTypes(
      allItemsForConfiguredDirectories,
      gcsTargetBucket.fileTypesToPurge
    )
    findCurrentObjectsNotInThisTransfer(
      allItemsFilteredByType,
      objectsInThisDeploy
    )
  }