How to use

createDependency

method

in

org.jboss.shrinkwrap.resolver.api.maven.coordinate.MavenDependencies

public static JavaArchive[] getEngineSpring() {
 if(CACHED_SPRING_ASSETS != null) {
  return CACHED_SPRING_ASSETS;
 } else {
  JavaArchive[] resolvedArchives = Maven.configureResolver()
    .workOffline()
    .loadPomFromFile("pom.xml")
    .addDependencies(
      MavenDependencies.createDependency("org.camunda.bpm:camunda-engine-spring", ScopeType.COMPILE, false,
        MavenDependencies.createExclusion("org.camunda.bpm:camunda-engine")),
        MavenDependencies.createDependency("org.springframework:spring-web", ScopeType.COMPILE, false))
    .resolve()
    .withTransitivity()
    .as(JavaArchive.class);
  if(resolvedArchives.length == 0) {
   throw new RuntimeException("could not resolve org.camunda.bpm:camunda-engine-spring");
  } else {
   CACHED_SPRING_ASSETS = resolvedArchives;
   return CACHED_SPRING_ASSETS;
  }
 }
}

protected MavenDependency getComponentRuntimeBeamDependency() {
  return createDependency("org.talend.sdk.component:component-runtime-beam:jar:" + kitVersion, RUNTIME, false);
}

public static MavenDependency[] toMavenDependencies(String[] dependencies, String[] exclusions) {
  MavenDependencyExclusion[] mavenExclusions = toMavenExclusions(exclusions);
  MavenDependency[] mavenDependencies = new MavenDependency[dependencies.length];
  for (int i = 0; i < dependencies.length; i++) {
    mavenDependencies[i] = MavenDependencies.createDependency(
      dependencies[i],
      ScopeType.COMPILE,
      false,
      mavenExclusions);
  }
  return mavenDependencies;
}

public static MavenDependency[] toMavenDependencies(String[] dependencies, String[] exclusions) {
  MavenDependencyExclusion[] mavenExclusions = toMavenExclusions(exclusions);
  MavenDependency[] mavenDependencies = new MavenDependency[dependencies.length];
  for (int i = 0; i < dependencies.length; i++) {
    mavenDependencies[i] = MavenDependencies.createDependency(
      dependencies[i],
      ScopeType.COMPILE,
      false,
      mavenExclusions);
  }
  return mavenDependencies;
}

protected MavenDependency getRunnerDependency() {
  return createDependency(rootDependencyBase() + ":jar:" + beamVersion, RUNTIME, false);
}

public RejectDependenciesFilter(final boolean rejectTransitives, final String... coordinates)
    throws IllegalArgumentException,
    CoordinateParseException {
  if (coordinates == null || coordinates.length == 0) {
    throw new IllegalArgumentException("There must be at least one coordinate specified to be rejected.");
  }
  final Set<MavenDependency> bannedDependencies = new HashSet<MavenDependency>(coordinates.length);
  for (final String coords : coordinates) {
    final MavenCoordinate coordinate = MavenCoordinates.createCoordinate(coords);
    final MavenDependency dependency = MavenDependencies.createDependency(coordinate, ScopeType.COMPILE, false);
    bannedDependencies.add(dependency);
  }
  this.bannedDependencies = Collections.unmodifiableSet(bannedDependencies);
  this.rejectTransitives = rejectTransitives;
}

private MavenDependency resolveDependency(final String coordinate) {
  assert coordinate != null && coordinate.length() > 0 : "Coordinate is required";
  final MavenCoordinate newCoordinate = MavenCoordinates.createCoordinate(coordinate);
  final MavenDependency declared = MavenDependencies.createDependency(newCoordinate, null, false);
  final MavenDependency resolved = this.resolveDependency(declared);
  return resolved;
}

private MavenDependency resolveDependency(final String coordinate) {
  assert coordinate != null && coordinate.length() > 0 : "Coordinate is required";
  final MavenCoordinate newCoordinate = MavenCoordinates.createCoordinate(coordinate);
  final MavenDependency declared = MavenDependencies.createDependency(newCoordinate, null, false);
  final MavenDependency resolved = this.resolveDependency(declared);
  return resolved;
}

/**
 * Run post-resolution filtering to weed out POMs.
 *
 * @param artifactResults The original list of resolved artifacts
 * @return List of modified artifactResults
 */
static Collection<MavenResolvedArtifact> postFilter(final Collection<MavenResolvedArtifact> artifactResults) {
  final MavenResolutionFilter postResolutionFilter = RestrictPomArtifactFilter.INSTANCE;
  final Collection<MavenResolvedArtifact> filteredArtifacts = new ArrayList<MavenResolvedArtifact>();
  final List<MavenDependency> emptyList = Collections.emptyList();
  for (final MavenResolvedArtifact artifact : artifactResults) {
    final MavenDependency dependency = MavenDependencies.createDependency(artifact.getCoordinate(),
        ScopeType.COMPILE, false);
    // Empty lists OK here because we know the RestrictPOM Filter doesn't consult them
    if (postResolutionFilter.accepts(dependency, emptyList, emptyList)) {
      filteredArtifacts.add(artifact);
    }
  }
  return Collections.unmodifiableCollection(filteredArtifacts);
}

/**
 * Creates a new {@link MavenDependency} instance from the specified, required canonical form in format
 * {@code <groupId>:<artifactId>[:<packagingType>[:<classifier>]][:<version>]}, with the additional, optional
 * properties. If no {@link ScopeType} is specified, default will be {@link ScopeType#COMPILE}.
 *
 * @param canonicalForm A canonical form in format {@code <groupId>:<artifactId>[:<packagingType>[:<classifier>]][:<version>]}
 *                      of the new {@link MavenDependency} instance.
 * @param scope A scope of the new {@link MavenDependency} instance. Default will be {@link ScopeType#COMPILE}.
 * @param optional Whether or not this {@link MavenDependency} has been marked as optional; defaults to <code>false</code>.
 * @param exclusions Exclusions of the new {@link MavenDependency} instance.
 * @return The new {@link MavenDependency} instance.
 * @throws IllegalArgumentException
 *             If the canonical form is not supplied
 * @throws CoordinateParseException
 *             If the specified canonical form is not valid
 */
public static MavenDependency createDependency(final String canonicalForm, final ScopeType scope,
  final boolean optional, final MavenDependencyExclusion... exclusions) throws IllegalArgumentException,
  CoordinateParseException {
  if (canonicalForm == null || canonicalForm.length() == 0) {
    throw new IllegalArgumentException("canonical form is required");
  }
  final MavenCoordinate delegate = MavenCoordinates.createCoordinate(canonicalForm);
  return createDependency(delegate, scope, optional, exclusions);
}

/**
 * Run post-resolution filtering to weed out POMs.
 *
 * @param artifactResults The original list of resolved artifacts
 * @return List of modified artifactResults
 */
static Collection<MavenResolvedArtifact> postFilter(final Collection<MavenResolvedArtifact> artifactResults) {
  final MavenResolutionFilter postResolutionFilter = RestrictPomArtifactFilter.INSTANCE;
  final Collection<MavenResolvedArtifact> filteredArtifacts = new ArrayList<MavenResolvedArtifact>();
  final List<MavenDependency> emptyList = Collections.emptyList();
  for (final MavenResolvedArtifact artifact : artifactResults) {
    final MavenDependency dependency = MavenDependencies.createDependency(artifact.getCoordinate(),
        ScopeType.COMPILE, false);
    // Empty lists OK here because we know the RestrictPOM Filter doesn't consult them
    if (postResolutionFilter.accepts(dependency, emptyList, emptyList)) {
      filteredArtifacts.add(artifact);
    }
  }
  return Collections.unmodifiableCollection(filteredArtifacts);
}

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

private MavenDependency resolveDependency(final MavenDependency declared) {
  final String resolvedVersion = this.resolveVersion(declared);
  final MavenCoordinate newCoordinate = MavenCoordinates.createCoordinate(declared.getGroupId(),
    declared.getArtifactId(), resolvedVersion, declared.getPackaging(), declared.getClassifier());
  final MavenDependency dependency = MavenDependencies.createDependency(newCoordinate, declared.getScope(),
    declared.isOptional(), declared.getExclusions().toArray(TYPESAFE_EXCLUSIONS_ARRAY));
  return dependency;
}

private MavenDependency resolveDependency(final MavenDependency declared) {
  final String resolvedVersion = this.resolveVersion(declared);
  final MavenCoordinate newCoordinate = MavenCoordinates.createCoordinate(declared.getGroupId(),
    declared.getArtifactId(), resolvedVersion, declared.getPackaging(), declared.getClassifier());
  final MavenDependency dependency = MavenDependencies.createDependency(newCoordinate, declared.getScope(),
    declared.isOptional(), declared.getExclusions().toArray(TYPESAFE_EXCLUSIONS_ARRAY));
  return dependency;
}

public MavenDependency createMavenDependency(final ArtifactSpec spec) {
  final MavenCoordinate newCoordinate = MavenCoordinates.createCoordinate(
      spec.groupId(),
      spec.artifactId(),
      spec.version(),
      PackagingType.of(spec.type()),
      spec.classifier());
  return MavenDependencies.createDependency(newCoordinate, ScopeType.fromScopeType(spec.scope), false);
}

public static MavenDependency fromDependency(final Dependency dependency) {
  final Artifact artifact = dependency.getArtifact();
  final PackagingType packaging = PackagingType
      .of(artifact.getProperty(ArtifactProperties.TYPE, artifact.getExtension()));
  final String classifier = artifact.getClassifier().length() == 0 ? packaging.getClassifier() : artifact.getClassifier();
  final MavenCoordinate coordinate = MavenCoordinates.createCoordinate(artifact.getGroupId(),
      artifact.getArtifactId(), artifact.getVersion(), packaging, classifier);
  // SHRINKRES-143 lets ignore invalid scope
  ScopeType scope = ScopeType.RUNTIME;
  try {
    scope = ScopeType.fromScopeType(dependency.getScope());
  } catch (IllegalArgumentException e) {
    // let scope be RUNTIME
    log.log(Level.WARNING, "Invalid scope {0} of dependency {1} will be replaced by <scope>runtime</scope>",
        new Object[] { dependency.getScope(), coordinate.toCanonicalForm() });
  }
  final MavenDependency result = MavenDependencies.createDependency(coordinate, scope, dependency.isOptional(),
      fromExclusions(dependency.getExclusions()).toArray(TYPESAFE_EXCLUSIONS_ARRAY));
  return result;
}

public static MavenDependency fromDependency(final Dependency dependency) {
  final Artifact artifact = dependency.getArtifact();
  final PackagingType packaging = PackagingType
      .of(artifact.getProperty(ArtifactProperties.TYPE, artifact.getExtension()));
  final String classifier = artifact.getClassifier().length() == 0 ? packaging.getClassifier() : artifact.getClassifier();
  final MavenCoordinate coordinate = MavenCoordinates.createCoordinate(artifact.getGroupId(),
      artifact.getArtifactId(), artifact.getVersion(), packaging, classifier);
  // SHRINKRES-143 lets ignore invalid scope
  ScopeType scope = ScopeType.RUNTIME;
  try {
    scope = ScopeType.fromScopeType(dependency.getScope());
  } catch (IllegalArgumentException e) {
    // let scope be RUNTIME
    log.log(Level.WARNING, "Invalid scope {0} of dependency {1} will be replaced by <scope>runtime</scope>",
        new Object[] { dependency.getScope(), coordinate.toCanonicalForm() });
  }
  final MavenDependency result = MavenDependencies.createDependency(coordinate, scope, dependency.isOptional(),
      fromExclusions(dependency.getExclusions()).toArray(TYPESAFE_EXCLUSIONS_ARRAY));
  return result;
}