Update Gradle Compatibility

build.gradle

@@ -64,12 +64,16 @@ javadoc {
 //}
 
 task javadocJar(type: Jar, dependsOn: javadoc) {
-    classifier = 'javadoc'
+// Do not work after Gradle 5.1.
+//    classifier = 'javadoc'
+    archiveClassifier = 'javadoc'
     from javadoc.destinationDir
 }
 
 task sourcesJar(type: Jar, dependsOn: classes) {
-    classifier = 'sources'
+// Do not work after Gradle 5.1.
+//    classifier = 'sources'
+    archiveClassifier = 'sources'
     from sourceSets.main.allSource
 }
 
@@ -165,4 +169,3 @@ signing {
         sign publishing.publications.platformPluginMarkerMaven
     }
 }
-

src/main/java/org/bytedeco/gradle/javacpp/BuildExtension.java

@@ -24,6 +24,7 @@
 import groovy.util.Node;
 import java.io.File;
 import java.io.IOException;
+import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.nio.file.Files;
 import java.nio.file.StandardCopyOption;
@@ -36,6 +37,8 @@
 import org.gradle.api.artifacts.ResolvedArtifact;
 import org.gradle.api.artifacts.ResolvedDependency;
 import org.gradle.api.internal.project.DefaultProject;
+import org.gradle.api.internal.tasks.DefaultTaskDependencyFactory;
+import org.gradle.api.internal.tasks.TaskDependencyFactory;
 import org.gradle.api.plugins.BasePluginConvention;
 import org.gradle.api.publish.maven.MavenArtifact;
 import org.gradle.api.publish.maven.MavenPom;
@@ -49,11 +52,35 @@
  * @author Samuel Audet
  */
 public class BuildExtension {
+    private static final Constructor<FileBasedMavenArtifact> compatibleArtifactConstructor;
+    private static final boolean isLegacy;
     private final Logger logger = LoggerFactory.getLogger(BuildExtension.class);
 
     BuildPlugin plugin;
     Project project;
 
+    static {
+        boolean legacyCheck;
+        Constructor<FileBasedMavenArtifact> compatibleConstructor;
+        try {
+            // If gradle version is lower than 6.2, use legacy constructor.
+            compatibleConstructor = FileBasedMavenArtifact.class.getConstructor(File.class);
+            legacyCheck = true;
+        } catch (NoSuchMethodException e) {
+            try {
+                // If gradle version is equals or higher than 6.2, use latest constructor.
+                compatibleConstructor = FileBasedMavenArtifact.class.getConstructor(File.class, TaskDependencyFactory.class);
+                legacyCheck = false;
+            } catch (NoSuchMethodException e2) {
+                // If no compatible constructor found, constructor signature modified on latest version and do not compatible with this code.
+                // Throw exception to prevent build.
+                throw new RuntimeException("Could not find constructor for FileBasedMavenArtifact (Incompatible with this gradle version)", e);
+            }
+        }
+        isLegacy = legacyCheck;
+        compatibleArtifactConstructor = compatibleConstructor;
+    }
+
     public BuildExtension(BuildPlugin plugin) {
         this.plugin = plugin;
         this.project = plugin.project;
@@ -88,7 +115,8 @@ public List<MavenArtifact> existingArtifacts(Configuration configuration) throws
                                 File in = ra.getFile();
                                 File out = new File(libsDir, in.getName());
                                 Files.copy(in.toPath(), out.toPath(), StandardCopyOption.REPLACE_EXISTING);
-                                MavenArtifact ma = new FileBasedMavenArtifact(out);
+                                MavenArtifact ma = isLegacy ? compatibleArtifactConstructor.newInstance(out) :
+                                        compatibleArtifactConstructor.newInstance(out, DefaultTaskDependencyFactory.withNoAssociatedProject());
                                 ma.setClassifier(ra.getClassifier());
                                 artifacts.add(ma);
                             } catch (RuntimeException e) {

src/main/java/org/bytedeco/gradle/javacpp/BuildPlugin.java

@@ -23,6 +23,9 @@
 
 import java.io.File;
 import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Arrays;
 import java.util.Properties;
 import java.util.Set;
 import org.bytedeco.javacpp.Loader;
@@ -33,6 +36,7 @@
 import org.gradle.api.file.FileTreeElement;
 import org.gradle.api.plugins.JavaPlugin;
 import org.gradle.api.plugins.JavaPluginConvention;
+import org.gradle.api.provider.Property;
 import org.gradle.api.specs.Spec;
 import org.gradle.api.tasks.SourceSet;
 import org.gradle.api.tasks.TaskProvider;
@@ -88,7 +92,61 @@ boolean isLibraryPath(String path) {
         String p = (String)project.findProperty("javacpp.platform.library.path");
         return p != null && p.length() > 0 ? path.startsWith(p) : path.contains("/" + getPlatform() + getPlatformExtension() + "/");
     }
+
+    private <T> void setProperty(String originalMethod, String propertyField, Object target, T value) {
+        Method method = findMethod(target.getClass(), originalMethod, value.getClass());
+        if (method != null) {
+            try {
+                invoke(method, target, value);
+            } catch (Exception e) {
+                throw new RuntimeException("Cannot set property " + method.getName() + " in " + target.getClass(), e);
+            }
+        } else {
+            Method propertyGetter = findMethod(target.getClass(), propertyField);
+            if (propertyGetter == null) {
+                throw new RuntimeException("Cannot find property getter method " + propertyField + " in " + target.getClass());
+            }
+            ((Property<T>) invoke(propertyGetter, target)).set(value);
+        }
+    }
 
+    private <T> T getProperty(String originalMethod, String propertyMethod, Object target) {
+        Method method = findMethod(target.getClass(), originalMethod);
+        if (method != null) {
+            return (T) invoke(method, target);
+        }
+        Method propertyGetter = findMethod(target.getClass(), propertyMethod);
+        if (propertyGetter == null) {
+            throw new RuntimeException("Cannot find property getter method " + propertyMethod + " in " + target.getClass());
+        }
+        return ((Property<T>) invoke(propertyGetter, target)).get();
+    }
+
+    private Method findMethod(Class<?> cls, String methodName) {
+        for (Method method : cls.getMethods()) {
+            if (method.getName().equals(methodName)) {
+                return method;
+            }
+        }
+        return null;
+    }
+
+    private Method findMethod(Class<?> cls, String methodName, Class<?>... parameterTypes) {
+        try {
+            return cls.getMethod(methodName, parameterTypes);
+        } catch (NoSuchMethodException e) {
+            return null;
+        }
+    }
+
+    private <T> T invoke(Method method, Object target, Object... parameter) {
+        try {
+            return (T) method.invoke(target, parameter);
+        } catch (IllegalAccessException | InvocationTargetException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
     @Override public void apply(final Project project) {
         this.project = project;
         if (!project.hasProperty("javacppPlatform")) {
@@ -131,7 +189,16 @@ boolean isLibraryPath(String path) {
                     JavaCompile.class, new Action<JavaCompile>() { public void execute(JavaCompile task) {
                 task.setSource(main.getJava());
                 task.setClasspath(main.getCompileClasspath());
-                task.setDestinationDir(main.getJava().getOutputDir());
+                setProperty(
+                    "setDestinationDir", // Deprecated in 7.1, will be removed in Gradle 9.0
+                    "getDestinationDirectory", // Since 6.1
+                    task,
+                    getProperty(
+                        "getOutputDir", // Deprecated in 7.1, removed in Gradle 8.0
+                        "getClassesDirectory", // Since 6.1
+                        main.getJava()
+                    )
+                );
                 task.dependsOn("javacppBuildCommand");
             }});
 
@@ -185,7 +252,11 @@ boolean isLibraryPath(String path) {
             TaskProvider<Jar> javacppJarTask = project.getTasks().register("javacppJar",
                     Jar.class, new Action<Jar>() { public void execute(Jar task) {
                 task.from(main.getOutput());
-                task.setClassifier(getPlatform() + getPlatformExtension());
+                setProperty(
+                    "setClassifier", // Deprecated in 7.0, removed in 8.0
+                    "getArchiveClassifier", // Since 5.1
+                    task,
+                    getPlatform() + getPlatformExtension());
                 task.include(new Spec<FileTreeElement>() { public boolean isSatisfiedBy(FileTreeElement file) {
                     return file.isDirectory() || isLibraryPath(file.getPath());
                 }});
@@ -196,21 +267,37 @@ boolean isLibraryPath(String path) {
 
             TaskProvider<Jar> javacppPlatformJarTask = project.getTasks().register("javacppPlatformJar",
                     Jar.class, new Action<Jar>() { public void execute(Jar task) {
-                task.setBaseName(project.getName() + "-platform");
+                setProperty(
+                    "setBaseName", // Deprecated in 7.0, removed in 8.0
+                    "getArchiveBaseName", // Since 5.1
+                    task, 
+                    project.getName() + "-platform");
                 task.dependsOn("javacppJar");
             }});
 
             TaskProvider<Jar> javacppPlatformJavadocJarTask = project.getTasks().register("javacppPlatformJavadocJar",
                     Jar.class, new Action<Jar>() { public void execute(Jar task) {
-                task.setBaseName(project.getName() + "-platform");
-                task.setClassifier("javadoc");
+                setProperty(
+                    "setBaseName", // Deprecated in 7.0, removed in 8.0
+                    "getArchiveBaseName", // Since 5.1
+                    task,
+                    project.getName() + "-platform");
+                setProperty(
+                    "setClassifier", // Deprecated in 7.0, removed in 8.0
+                    "getArchiveClassifier", // Since 5.1
+                    task,
+                    "javadoc");
                 task.dependsOn("javacppPlatformJar");
             }});
 
             TaskProvider<Jar> javacppPlatformSourcesTask = project.getTasks().register("javacppPlatformSourcesJar",
                     Jar.class, new Action<Jar>() { public void execute(Jar task) {
-                task.setBaseName(project.getName() + "-platform");
-                task.setClassifier("sources");
+                setProperty(
+                    "setBaseName", // Deprecated in 7.0, removed in 8.0
+                    "getArchiveBaseName", // Since 5.1
+                    task,
+                    project.getName() + "-platform");
+                setProperty("setClassifier", "getArchiveClassifier", task, "sources");
                 task.dependsOn("javacppPlatformJar");
             }});
 
@@ -220,4 +307,4 @@ boolean isLibraryPath(String path) {
             project.getArtifacts().add("javacppPlatform", javacppPlatformSourcesTask);
         }});
     }
-}
+}