@Override
  public JibContainerBuilder createJibContainerBuilder(
      JavaContainerBuilder javaContainerBuilder, ContainerizingMode containerizingMode) {
    try {
      FileCollection projectDependencies =
          project.files(
              project.getConfigurations().getByName(configurationName).getResolvedConfiguration()
                  .getResolvedArtifacts().stream()
                  .filter(
                      artifact ->
                          artifact.getId().getComponentIdentifier()
                              instanceof ProjectComponentIdentifier)
                  .map(ResolvedArtifact::getFile)
                  .collect(Collectors.toList()));

      if (isWarProject()) {
        String warFilePath = getWarFilePath();
        log(LogEvent.info("WAR project identified, creating WAR image from: " + warFilePath));
        Path explodedWarPath = tempDirectoryProvider.newDirectory();
        ZipUtil.unzip(Paths.get(warFilePath), explodedWarPath);
        return JavaContainerBuilderHelper.fromExplodedWar(
            javaContainerBuilder,
            explodedWarPath,
            projectDependencies.getFiles().stream().map(File::getName).collect(Collectors.toSet()));
      }

      SourceSet mainSourceSet = getMainSourceSet();
      FileCollection classesOutputDirectories =
          mainSourceSet.getOutput().getClassesDirs().filter(File::exists);
      Path resourcesOutputDirectory = mainSourceSet.getOutput().getResourcesDir().toPath();
      FileCollection allFiles =
          project.getConfigurations().getByName(configurationName).filter(File::exists);

      FileCollection nonProjectDependencies =
          allFiles
              .minus(classesOutputDirectories)
              .minus(projectDependencies)
              .filter(file -> !file.toPath().equals(resourcesOutputDirectory));

      FileCollection snapshotDependencies =
          nonProjectDependencies.filter(file -> file.getName().contains("SNAPSHOT"));
      FileCollection dependencies = nonProjectDependencies.minus(snapshotDependencies);

      // Adds dependency files
      javaContainerBuilder
          .addDependencies(
              dependencies.getFiles().stream().map(File::toPath).collect(Collectors.toList()))
          .addSnapshotDependencies(
              snapshotDependencies.getFiles().stream()
                  .map(File::toPath)
                  .collect(Collectors.toList()))
          .addProjectDependencies(
              projectDependencies.getFiles().stream()
                  .map(File::toPath)
                  .collect(Collectors.toList()));

      switch (containerizingMode) {
        case EXPLODED:
          // Adds resource files
          if (Files.exists(resourcesOutputDirectory)) {
            javaContainerBuilder.addResources(resourcesOutputDirectory);
          }

          // Adds class files
          for (File classesOutputDirectory : classesOutputDirectories) {
            javaContainerBuilder.addClasses(classesOutputDirectory.toPath());
          }
          if (classesOutputDirectories.isEmpty()) {
            log(LogEvent.warn("No classes files were found - did you compile your project?"));
          }
          break;

        case PACKAGED:
          // Add a JAR
          Jar jarTask = (Jar) project.getTasks().findByName("jar");
          Path jarPath = jarTask.getArchiveFile().get().getAsFile().toPath();
          log(LogEvent.debug("Using JAR: " + jarPath));
          javaContainerBuilder.addToClasspath(jarPath);
          break;

        default:
          throw new IllegalStateException("unknown containerizing mode: " + containerizingMode);
      }

      return javaContainerBuilder.toContainerBuilder();

    } catch (IOException ex) {
      throw new GradleException("Obtaining project build output files failed", ex);
    }
  }
@Test
  public void testCreateContainerBuilder_noErrorIfWebInfLibDoesNotExist()
      throws IOException, InvalidImageReferenceException {
    temporaryFolder.newFolder("WEB-INF", "classes");
    setUpWarProject(temporaryFolder.getRoot().toPath());

    assertThat(
            gradleProjectProperties.createJibContainerBuilder(
                JavaContainerBuilder.from("ignored"), ContainerizingMode.EXPLODED))
        .isNotNull();
  }