Potential fixes for 3 code quality findings

src/main/java/com/solubris/enforcer/VersionPropertyRule.java

@@ -46,8 +46,8 @@
     @SuppressWarnings("unused")
     @Inject
     public VersionPropertyRule(MavenSession session) {
         this(modelFrom(session), session.getCurrentProject().getModel());
     }
 
     protected VersionPropertyRule(Model originalModel, Model effectiveModel) {
         this.originalModel = originalModel;
@@ -56,8 +56,8 @@
 
     @Override
     public void execute() throws EnforcerRuleException {
         throwViolations(scan(), "Found {0} version violation(s):");
     }
 
     @SuppressWarnings("PMD.CollapsibleIfStatements")
     protected Stream<String> scan() {
@@ -65,8 +65,8 @@
                 .collect(groupingBy(Artifact::fullKey, toList()));
         Map<String, List<Artifact>> usages = scanModel(originalModel)
                 .map(a -> a.withEffectiveVersion(fetchVersion(a, byKey)))
                 .filter(a -> a.getEffectiveVersion() != null)
                 .filter(artifact -> !isExcluded(artifact.getVersion()))
                 .collect(groupingBy(Artifact::getEffectiveVersion, toList()));
 
         // byVersion maps from property to list of artifacts
@@ -76,14 +76,14 @@
                 .map(e -> {
                     String effectiveVersion = e.getKey();
                     List<Artifact> artifacts = e.getValue();
-                    long propertyCount = artifacts.stream()
+                    long implicitVersionCount = artifacts.stream()
                             .filter(Artifact::hasImplicitVersion)
                             .count();
                     if (artifacts.size() > 1) {
-                        if (propertyCount == 0) return missingProperty(effectiveVersion, artifacts);
-                        if (propertyCount < artifacts.size()) return unusedProperty(effectiveVersion, artifacts);
+                        if (implicitVersionCount == 0) return missingProperty(effectiveVersion, artifacts);
+                        if (implicitVersionCount < artifacts.size()) return unusedProperty(effectiveVersion, artifacts);
                     } else if (artifacts.size() == 1) {
-                        if (propertyCount == 1) return redundantProperty(artifacts.get(0));
+                        if (implicitVersionCount == 1) return redundantProperty(artifacts.get(0));
                     }
                     return null;
                 }).filter(Objects::nonNull);
@@ -91,9 +91,9 @@
 
     private String fetchVersion(Artifact a, Map<String, List<Artifact>> byKey) {
         List<Artifact> artifacts = byKey.getOrDefault(a.fullKey(), List.of());
         if (!artifacts.isEmpty()) return artifacts.get(0).getVersion();
         getLog().warn("Could not find artifact in effectiveModel for " + a.fullKey());
         return null;
     }
 
     private String redundantProperty(Artifact artifact) {
@@ -114,31 +114,31 @@
      * That's possible due to coincidental properties - another edge case to consider.
      */
     private static String unusedProperty(String effectiveVersion, List<Artifact> artifacts) {
-        String unused = artifacts.stream()
+        String explicitVersionLocations = artifacts.stream()
                 .filter(Artifact::hasExplicitVersion)
                 .map(Artifact::key)
                 .collect(joining(", "));
         String propertyName = artifacts.stream()
                 .filter(Artifact::hasImplicitVersion)
                 .map(Artifact::getVersion)
                 .map(PropertyUtil::fromPlaceHolder)
                 .findAny().orElse("unknown");
         return String.format(
                 "Version property %s=%s exists but is not used everywhere. Unused locations: %s",
-                propertyName, effectiveVersion, unused);
+                propertyName, effectiveVersion, explicitVersionLocations);
     }
 
     private String missingProperty(String version, List<Artifact> artifacts) {
         if (!requirePropertiesForDuplicates) return null;
 
-        String unused = artifacts.stream()
+        String locationsWithoutProperty = artifacts.stream()
                 .filter(a -> Objects.equals(a.getVersion(), a.getEffectiveVersion()))
                 .map(Artifact::key)
                 .collect(joining(", "));
         return String.format(
                 "Version '%s' exists in multiple locations, please extract a version property. " +
                         "Unused locations: %s",
-                version, unused);
+                version, locationsWithoutProperty);
     }
 
     /**
@@ -149,11 +149,11 @@
      */
     @SuppressWarnings("checkstyle:InvertedControlFlow")
     private boolean isExcluded(String version) {
         if (version == null) return true;
         if (excludeVersions.contains(version)) return true;
 
         if (ignoreParentVersion && Objects.equals(version, "${project.parent.version}")) {
             return true;
         }
 
         // Match version ranges like [1.0,2.0) or (1.0,2.0]