How to use

Maven

in

org.jboss.shrinkwrap.resolver.api.maven

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

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 static File[] resolveDependencies(final String coords)
  {
   return Maven.resolver().loadPomFromFile("pom.xml")
        .resolve(coords)
        .withTransitivity().asFile();
  }
}

  /**
   * Resolves the given artifact by it's name with help of maven build system.
   *
   * @param artifact the fully qualified artifact name
   *
   * @return the resolved files
   */
  private File[] resolveArtifact(String artifact) {

    return Maven.resolver()
        .resolve(artifact)
        .withTransitivity()
        .asFile();
  }
}

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())

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();

@Override
public Archive<?> createAuxiliaryArchive() {
  final JavaArchive arquillianPactConsumer = ShrinkWrap.create(JavaArchive.class, "arquillian-pact-consumer.jar")
      // Add Core classes required in container part
      .addClasses(AbstractConsumerPactTest.class,
          RemoteConsumerPactTest.class, PactConsumerConfiguration.class,
          MockProviderConfigCreator.class, PactConsumerConfigurator.class,
          PactConsumerRemoteExtension.class, PactFilesCommand.class, ConsumerProviderPair.class,
          ResolveClassAnnotation.class)
      .addPackages(true, Pact.class.getPackage())
      .addAsServiceProvider(RemoteLoadableExtension.class, PactConsumerRemoteExtension.class);
  final Properties properties = pactConsumerConfigurationInstance.get().asProperties();
  String configuration = toString(properties);
  arquillianPactConsumer.add(new StringAsset(configuration), "/pact-consumer-configuration.properties");
  final JavaArchive[] pactConsumerDeps = Maven.resolver()
      .resolve("au.com.dius:pact-jvm-consumer_2.11:" + getVersion())
      .withTransitivity().as(JavaArchive.class);
  final JavaArchive merge = merge(arquillianPactConsumer, pactConsumerDeps);
  return merge;
}

public static File[] resolve(File cacheFolder, MavenDependency[] dependencies) {
  String hash = hash(dependencies);
  File[] files;
  File cacheFile = getCacheFile(cacheFolder, hash);
  if (cacheFile.exists()) {
    files = readCache(cacheFile);
  } else {
    files = Maven.configureResolver()
      .addDependencies(dependencies)
      .resolve()
      .withTransitivity()
      .asFile();
    writeCache(getCacheFile(cacheFolder, hash), files);
  }
  return files;
}

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();
  }
}

public MavenResolvedArtifact[] resolveArtifacts(String artifact) {
  try {
    /* do offline check first */
    return Maven.configureResolver().workOffline().resolve(artifact).withTransitivity().asResolvedArtifact();
  } catch (NoResolvedResultException nre) {
    return Maven
        .configureResolver()
        .withRemoteRepo("Sonatype Nexus Snapshots",
            "https://oss.sonatype.org/content/repositories/snapshots/", "default")
        .resolve(artifact).withTransitivity().asResolvedArtifact();
  }
}

  @Override
  public File call() throws Exception {
    return Maven.resolver().resolve(distributableCoordinate.toCanonicalForm())
      .withoutTransitivity()
      .asSingle(GenericArchive.class)
      .as(ExplodedExporter.class)
      .exportExploded(targetDirectory, ".");
  }
});

/**
 * 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;
}

public void unpackContainerConfigurationFiles(@Observes ConfigureContainer event) {
  Validate.notNull(configuration, "fundamental test configuration is not setup");
  String configurationFiles = configuration.getContainerConfiguration();
  if (configurationFiles == null || configurationFiles.isEmpty()) {
    return;
  }
  Validate.notNull(configuration.getContainerHome(), "container home must be set");
  File containerHome = new File(configuration.getContainerHome());
  InputStream artifactStream = Maven.resolver().resolve(configurationFiles).withClassPathResolution(false).withoutTransitivity().asSingleInputStream();
  unzip(artifactStream, containerHome, true);
  log.info(String.format("The container configuration '%s' was unpacked into '%s'", configurationFiles,
      containerHome.getAbsolutePath()));
}

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());
        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);
 }
}

/**
 * Returns the set of dependencies defined as org.hibernate:hibernate-search-orm at
 * the version being built. We use transitive dependencies to include the version
 * of hibernate-search-engine and Apache Lucene at the currently built version, but
 * then need to exclude the packages already provided by the application server such
 * as Hibernate ORM.
 *
 * @return the set of dependencies a user would need to bundle in a web app
 */
public static JavaArchive[] hibernateSearchLibraries() {
  return Maven.resolver()
      .resolve( "org.hibernate:hibernate-search-orm:" + getCurrentVersion() )
      // we need some dependencies at the right version: Lucene, search-engine, etc..
      .using( new RejectDependenciesStrategy( false, exclusions ) )
      .as( JavaArchive.class );
}

/**
 * Obtains JavaArchive with phantomjs binary
 */
protected File getJavaArchive(String version) {
  String v = version;
  if (v == null) {
    v = ResolverConfiguration.get().version();
  }
  final String gav = getArtifactCanonicalForm(v);
  return Maven.resolver().resolve(gav).withoutTransitivity().asSingleFile();
}