How to use

PomEquippedResolveStage

in

org.jboss.shrinkwrap.resolver.api.maven

public static JavaArchive getEngineCdi() {
 if(CACHED_ENGINE_CDI_ASSET != null) {
  return CACHED_ENGINE_CDI_ASSET;
 } else {
  JavaArchive[] resolvedArchives = Maven.configureResolver()
    .workOffline()
    .loadPomFromFile("pom.xml")
    .resolve(CAMUNDA_ENGINE_CDI)
    .withTransitivity()
    .as(JavaArchive.class);
  if(resolvedArchives.length != 1) {
   throw new RuntimeException("could not resolve "+CAMUNDA_ENGINE_CDI);
  } else {
   CACHED_ENGINE_CDI_ASSET = resolvedArchives[0];
   return CACHED_ENGINE_CDI_ASSET;
  }
 }
}

public Builder withPomDependencies() {
 dependencies = Maven.resolver().loadPomFromFile("pom.xml").importRuntimeDependencies().resolve().withTransitivity().asFile();
 return this;
}

public static File[] single(PomStrategy pomStrategy, String groupId, String artifactId) {
  return Maven.resolver().loadPomFromFile(pomStrategy.toPom(), pomStrategy.profiles()).resolve(groupId + ":" + artifactId).withoutTransitivity().asFile();
}

PomEquippedResolveStage resolver = Maven.configureResolver()
 .useLegacyLocalRepo(true).workOffline().loadPomFromFile("pom.xml");
  .addAsLibraries(resolver.resolve("org.codehaus.jackson:jackson-jaxrs:1.6.5").withTransitivity().asFile())
  .addAsLibraries(resolver.addDependencies(
    MavenDependencies.createDependency("org.mockito:mockito-core", ScopeType.TEST, false,
    MavenDependencies.createExclusion("org.hamcrest:hamcrest-core"))).resolve()
     .withTransitivity().asFile())

public static JavaArchive[] awaitability() {
  return Maven.resolver()
      .loadPomFromFile("pom.xml")
      .resolve("org.assertj:assertj-core", "com.jayway.awaitility:awaitility")
      .withTransitivity()
      .as(JavaArchive.class);
}

MavenResolverSystem maven = Maven.resolver();
PomEquippedResolveStage resolveStage = maven.loadPomFromFile("pom.xml");
MavenResolvedArtifact[] provided = resolveStage.importRuntimeDependencies().importDependencies(ScopeType.PROVIDED).resolve().using(new AcceptScopesStrategy(ScopeType.PROVIDED)).asResolvedArtifact();
for (MavenResolvedArtifact mra : provided) {
MavenResolvedArtifact[] deps = resolveStage.importRuntimeAndTestDependencies().resolve().withTransitivity().asResolvedArtifact();

public static WebArchive createKieServerControllerWar() {
  try {
    final File kieServerControllerFile = Maven.configureResolver().workOffline().loadPomFromFile("pom.xml")
        .resolve("org.kie.server:kie-server-controller-standalone:war:ee7:?").withoutTransitivity().asSingleFile();
    return ShrinkWrap.create(ZipImporter.class,
                 "kie-server-controller.war").importFrom(kieServerControllerFile)
        .as(WebArchive.class);
  } catch (Exception ex) {
    ex.printStackTrace();
    throw new RuntimeException(ex);
  }
}

@Deployment
public static WebArchive processArchive() {
 return initWebArchiveDeployment("test.war", "singleEngineWithProcessEnginePlugin.xml")
   .addClass(GroovyProcessEnginePlugin.class)
   .addAsResource("org/camunda/bpm/integrationtest/deployment/war/groovy.bpmn20.xml")
   .addAsResource("org/camunda/bpm/integrationtest/deployment/war/groovyAsync.bpmn20.xml")
   .addAsLibraries(Maven.resolver()
     .offline()
     .loadPomFromFile("pom.xml")
     .resolve("org.codehaus.groovy:groovy-all")
     .withoutTransitivity()
     .as(JavaArchive.class));
}

  public static File[] resolveDependencies() {
    return Maven.resolver()
      .offline()
      .loadPomFromFile("pom.xml")
      .resolve(
        "org.infinispan:infinispan-core")
      .withTransitivity()
      .asFile();
  }
}

/**
 * Resolves Maven dependency and writes it to the cache, so it can be reused next run
 */
private void resolveMavenDependency(String missingDependency, File dir) {
  MavenResolverSystem resolver = getMavenResolver();
  JavaArchive[] dependencies;
  if (missingDependency.matches("^[^:]+:[^:]+:[^:]+")) {
    // resolution of the artifact without a version specified
    dependencies = resolver.resolve(missingDependency).withClassPathResolution(false).withTransitivity()
      .as(JavaArchive.class);
  } else {
    // resolution of the artifact without a version specified
    dependencies = resolver.loadPomFromFile("pom.xml").resolve(missingDependency)
      .withClassPathResolution(false).withTransitivity().as(JavaArchive.class);
  }
  for (JavaArchive archive : dependencies) {
    dir.mkdirs();
    if (mavenDependencyExcluded(archive.getName())) {
      continue;
    }
    final File outputFile = new File(dir, archive.getName());
    archive.as(ZipExporter.class).exportTo(outputFile, true);
  }
}

/**
 * Adds the dependencies defined in the project's POM to the deployment. <b>Only call this method if you have
 * dependencies defined in the project's POM.</b>
 *
 * @return Return this instance for method chaining.
 */
public LimbusStaging fromProjectDependencies() {
 //@formatter:off
 this.stage.setDependencies(Maven.configureResolver()
                 .withClassPathResolution(true)
                 .loadPomFromFile("pom.xml")
                 .importCompileAndRuntimeDependencies()
                 .resolve()
                 .withTransitivity()
                 .asList(JavaArchive.class));
 //@formatter:on
 return this;
}

    .importRuntimeAndTestDependencies()
    .resolve()
    .withoutTransitivity()
    .asResolvedArtifact()
);
                   r.addDependency(resolvingHelper.createMavenDependency(parent));
                   return pom
                       .resolve()
                       .withTransitivity()
                       .asResolvedArtifact();

final ConfigurableMavenResolverSystem resolver = Maven.configureResolver()
    .withMavenCentralRepo(true)
    .withRemoteRepo(jbossPublic);
  final List<String> topLevelDeps =
      ((ResolveStageBaseImpl) resolver.loadPomFromFile("pom.xml")
          .importRuntimeAndTestDependencies())
          .getMavenWorkingSession()
          .getDependenciesForResolution()
          .importRuntimeAndTestDependencies()
          .resolve()
          .withTransitivity()
          .asResolvedArtifact());
    final MavenResolvedArtifact[] deps =
        resolvingHelper.withResolver(r -> r.loadPomFromFile("pom.xml")
            .resolve(requestedDep)
            .withTransitivity()
            .asResolvedArtifact());

public static JavaArchive[] getSpinJacksonJsonDataFormatForServer(String server) {
 if (server.equals("tomcat") ||
   server.equals("websphere9") ||
   server.equals("weblogic") ||
   server.equals("glassfish")) {
  return Maven.configureResolver()
    .workOffline()
    .loadPomFromFile("pom.xml")
    .resolve("org.camunda.spin:camunda-spin-dataformat-json-jackson")
    .using(new RejectDependenciesStrategy(false,
      "org.camunda.spin:camunda-spin-core",
      "org.camunda.commons:camunda-commons-logging",
      "org.camunda.commons:camunda-commons-utils"))
    .as(JavaArchive.class);
 } else if (server.equals("websphere")) {
  return Maven.configureResolver()
   .workOffline()
   .loadPomFromFile("pom.xml", "was85")
   .resolve("org.camunda.spin:camunda-spin-dataformat-json-jackson")
   .using(new RejectDependenciesStrategy(false,
    "org.camunda.spin:camunda-spin-core",
    "org.camunda.commons:camunda-commons-logging",
    "org.camunda.commons:camunda-commons-utils"))
   .as(JavaArchive.class);
 } else {
  throw new RuntimeException("Unable to determine dependencies for spinJacksonJsonDataFormat: " + server);
 }
}

  artifacts = new MavenResolvedArtifact[0];
} else {
  artifacts = Maven.configureResolverViaPlugin(cls)
    .importDependencies(scopes)
    .resolve()
    .withTransitivity()
    .asResolvedArtifact();

  protected static File[] resolve(PomEquippedResolveStage resolver, String... coordinates) {
    final File[] files = resolver.resolve(coordinates).withoutTransitivity().as(File.class);
    if (files == null || files.length == 0)
      throw new IllegalArgumentException("Null or empty files (" + Arrays.toString(files) + "): " + Arrays.toString(coordinates));
    return files;
  }
}

  private static Archive<?>[] resolveEjbs(PomEquippedResolveStage dependencies) {
    List<Archive<?>> archives = new ArrayList<Archive<?>>();

    MavenResolvedArtifact[] artifacts = dependencies.resolve().withTransitivity().asResolvedArtifact();

    for (MavenResolvedArtifact artifact : artifacts) {
      if (PackagingType.EJB.equals(artifact.getCoordinate().getType())) {
        String originalName = artifact.asFile().getName();
        String name = originalName.replace(".ejb", ".jar");
        JavaArchive ejbArchive = ShrinkWrap.createFromZipFile(JavaArchive.class, artifact.asFile());
        archives.add(ShrinkWrap.create(JavaArchive.class, name).merge(ejbArchive));
      } else {
        archives.add(ShrinkWrap.createFromZipFile(JavaArchive.class, artifact.asFile()));
      }
    }
    
    return archives.toArray(new Archive<?>[archives.size()]);
  }
}

  private File getDependency(final String coordinates) {
    return getResolver().resolve(coordinates).withoutTransitivity().asSingle(File.class);
  }
}

  configureResolver().fromClassloaderResource(getSettings());
PomEquippedResolveStage mavenResolver=
  resolver.loadPomFromClassLoaderResource(getPom());
    addAsLibraries(
      mavenResolver.
        importRuntimeDependencies().asFile()).
    addAsLibraries(archives).
    addAsWebResource(

 @Deployment
public static WebArchive createDeployment() {
  //Load dependencies from POM
  final PomEquippedResolveStage pom = Maven
    .resolver()
    .loadPomFromFile("pom.xml");
  final PomEquippedResolveStage dependencies = pom
    .importCompileAndRuntimeDependencies();
  final File[] libs =         
   dependencies.resolve().withTransitivity().asFile();

  return ShrinkWrap
   .create(WebArchive.class,
       "ExampleArchive.war")
   .addPackage(org.example.Example.class.getPackage())
   .addAsLibraries(files)
   .addAsResource("test-persistence.xml",
          "META-INF/persistence.xml")
   .addAsWebInfResource(EmptyAsset.INSTANCE, "WEB-INF/beans.xml"); 

}