コード例 #1
0
  protected void checkForRedundantVersions(
      final MavenProject mavenProject,
      final ResultCollector resultCollector,
      final ObjectWithPath<?> object,
      final ObjectWithPath<?> inheritedObject,
      final String dependencyDescription,
      final String inheritedDescription) {

    Object modelObject = object.getObject();
    Object resolvedModelObject = tryResolveObject(object);

    if (isExcluded(resolvedModelObject)) {
      return;
    }

    String version = resolveVersion(modelObject, resolvedModelObject);
    String inheritedVersion = modelUtil.getVersion(tryResolveObject(inheritedObject));
    // both have a version, but if they're different, that might be ok.
    // But if they're the same, then one is redundant.
    if (version != null && inheritedVersion != null && inheritedVersion.equals(version)) {
      InputLocation location = modelUtil.getLocation(modelObject, "version");
      String message =
          dependencyDescription
              + " '"
              + modelUtil.getKey(modelObject)
              + "' has same version ("
              + version
              + ") as "
              + inheritedDescription;
      resultCollector.addViolation(mavenProject, this, message, location);
    }
  }
コード例 #2
0
 private Object tryResolveObject(final ObjectWithPath<?> objectWithPath) {
   try {
     return resolveObject(objectWithPath);
   } catch (final IllegalStateException e) {
     log.warn(e);
     return objectWithPath.getObject();
   }
 }
コード例 #3
0
  /**
   * This uses the path of an object that was found in the "original model", and tries to find the
   * same object in the "model". The "model" has had properties replaced with values, so this is how
   * we find the resolved version of the object.
   */
  private Object resolveObject(final ObjectWithPath<?> objectWithPath) {
    Object object = objectWithPath.getObject();
    StringBuilder path = new StringBuilder();
    path.append(objectWithPath.getPath());
    path.append("[");
    path.append("groupId='").append(modelUtil.getGroupId(object)).append("'");
    path.append(" and artifactId='").append(modelUtil.getArtifactId(object)).append("'");

    String type = modelUtil.tryGetType(object);
    if (type != null) {
      path.append(" and type='").append(type).append("'");
    } else {
      path.append(" and not(type)");
    }

    String classifier = modelUtil.tryGetClassifier(object);
    if (classifier != null) {
      path.append(" and classifier='").append(classifier).append("'");
    } else {
      path.append(" and not(classifier)");
    }
    path.append("]");

    // evaluate embedded properties
    if (path.toString().contains("${")) {
      try {
        Object evaluate = pluginParameterExpressionEvaluator.evaluate(path.toString());
        path = new StringBuilder(evaluate.toString());
      } catch (ExpressionEvaluationException e) {
        throw new IllegalStateException(e);
      }
    }

    Model model = objectWithPath.getProject().getModel();
    Collection<Object> objects = expressionEvaluator.getPath(model, path.toString());
    if (objects.isEmpty()) {
      throw new IllegalStateException("Could not resolve " + object + " using path " + path);
    } else if (objects.size() > 1) {
      throw new IllegalStateException("Found " + objects.size() + " objects using path " + path);
    } else {
      return objects.iterator().next();
    }
  }