def apply()

in app/prism/RecipeUsage.scala [78:122]
41 lines of code
4 McCabe index (conditional complexity)

  def apply(
      bakes: Iterable[Bake]
  )(implicit prismAgents: PrismData): RecipeUsage = {
    val bakedAmiLookupMap = bakes.flatMap(b => b.amiId.map(_ -> b)).toMap
    val bakedAmiIds = bakedAmiLookupMap.keys.toList
    val copiedAmis = prismAgents.copiedImages(bakedAmiIds.toSet).values.flatten
    val copiedAmiIds = copiedAmis.map(_.imageId)

    val amiIds = bakedAmiIds ++ copiedAmiIds
    val instances = prismAgents.allInstances.filter(instance =>
      amiIds.contains(instance.imageId)
    )
    val launchConfigurations = prismAgents.allLaunchConfigurations.filter(lc =>
      amiIds.contains(lc.imageId)
    )
    val launchTemplates =
      prismAgents.allLaunchTemplates.filter(lt => amiIds.contains(lt.imageId))
    val amis =
      (instances.map(_.imageId) ++ launchConfigurations.map(
        _.imageId
      ) ++ launchTemplates.map(_.imageId)).distinct

    val copiedAmiLookupMap = copiedAmis.map { image =>
      image.imageId -> image
    }.toMap

    val bakeUsage = amis.map { ami =>
      val maybeDirectBake = bakedAmiLookupMap.get(ami)
      val maybeCopy = copiedAmiLookupMap.get(ami)
      val bake = (maybeDirectBake, maybeCopy) match {
        case (Some(directBake), None) => directBake
        case (None, Some(copy))       => bakedAmiLookupMap(copy.copiedFromAMI)
        case _ =>
          throw new IllegalArgumentException(
            "AMI ID provided neither direct nor copied"
          )
      }
      val amiInstances = instances.filter(_.imageId == ami)
      val amiLc = launchConfigurations.filter(_.imageId == ami)
      val amiLt = launchTemplates.filter(_.imageId == ami)
      BakeUsage(ami, bake, maybeCopy, amiInstances, amiLc, amiLt)
    }

    RecipeUsage(instances, launchConfigurations, launchTemplates, bakeUsage)
  }