HHH-14513 : Move publishing release and snapshot artifacts to Sonatype OSSRH

README.adoc

@@ -0,0 +1,144 @@
+Hibernate ORM is a library providing Object/Relational Mapping (ORM) support
+to applications, libraries, and frameworks.
+
+It also provides an implementation of the JPA specification, which is the standard Java specification for ORM.
+
+This is the repository of its source code; see http://hibernate.org/orm/[Hibernate.org] for additional information.
+
+image:http://ci.hibernate.org/job/hibernate-orm-main-h2-main/badge/icon[Build Status,link=http://ci.hibernate.org/job/hibernate-orm-main-h2-main/]
+image:https://img.shields.io/lgtm/grade/java/g/hibernate/hibernate-orm.svg?logo=lgtm&logoWidth=18[Language grade: Java,link=https://lgtm.com/projects/g/hibernate/hibernate-orm/context:java]
+
+== Continuous Integration
+
+Hibernate uses both http://jenkins-ci.org[Jenkins] and https://github.com/features/actions[GitHub Actions]
+for its CI needs. See
+
+* http://ci.hibernate.org/view/ORM/[Jenkins Jobs]
+* https://github.com/hibernate/hibernate-orm/actions[GitHub Actions Jobs]
+
+== Building from sources
+
+The build requires at least Java 8 JDK.
+
+Hibernate uses https://gradle.org[Gradle] as its build tool. See the _Gradle Primer_ section below if you are new to
+Gradle.
+
+Contributors should read the link:CONTRIBUTING.md[Contributing Guide].
+
+See the guides for setting up http://hibernate.org/community/contribute/intellij-idea/[IntelliJ] or
+https://hibernate.org/community/contribute/eclipse-ide/[Eclipse] as your development environment.
+
+== Gradle Primer
+
+The Gradle build tool has amazing documentation.  2 in particular that are indispensable:
+
+* https://docs.gradle.org/current/userguide/userguide_single.html[Gradle User Guide] is a typical user guide in that
+it follows a topical approach to describing all of the capabilities of Gradle.
+* https://docs.gradle.org/current/dsl/index.html[Gradle DSL Guide] is unique and excellent in quickly
+getting up to speed on certain aspects of Gradle.
+
+We will cover the basics developers and contributors new to Gradle need to know to get productive quickly.
+
+NOTE: The project defines a https://docs.gradle.org/current/userguide/gradle_wrapper.html[Gradle Wrapper].
+The rest of the section will assume execution through the wrapper.
+
+=== Executing Tasks
+
+Gradle uses the concept of build tasks (equivalent to Ant targets or Maven phases/goals). You can get a list of
+available tasks via 
+
+----
+gradle tasks
+----
+
+To execute a task across all modules, simply perform that task from the root directory. Gradle will visit each
+sub-project and execute that task if the sub-project defines it. To execute a task in a specific module you can
+either:
+
+. `cd` into that module directory and execute the task
+. name the "task path". For example, to run the tests for the _hibernate-core_ module from the root directory
+you could say `gradle hibernate-core:test`
+
+=== Common tasks
+
+The common tasks you might use in building Hibernate include:
+
+* _build_ - Assembles (jars) and tests this project
+* _compile_ - Performs all compilation tasks including staging resources from both main and test
+* _jar_ - Generates a jar archive with all the compiled classes
+* _test_ - Runs the tests
+* _publishToMavenLocal_ - Installs the project jar to your local maven cache (aka ~/.m2/repository). Note that Gradle
+never uses this, but it can be useful for testing your build with other local Maven-based builds.
+* _clean_ - Cleans the build directory
+
+== Testing and databases
+
+Testing against a specific database can be achieved in 2 different ways:
+
+=== Using the "Matrix Testing Plugin" for Gradle.
+
+Coming later…
+
+=== Using "profiles"
+
+The Hibernate build defines several database testing "profiles" in `databases.gradle`. These
+profiles can be activated by name using the `db` build property which can be passed either as
+a JVM system prop (`-D`) or as a Gradle project property (`-P`). Examples below use the Gradle
+project property approach.
+
+----
+gradle clean build -Pdb=pgsql
+----
+
+To run a test from your IDE, you need to ensure the property expansions happen.
+Use the following command:
+
+----
+gradle clean compile -Pdb=pgsql
+----
+
+__NOTE: If you are running tests against a JDBC driver that is not available via Maven central be sure to
+add these drivers to your local Maven repo cache (~/.m2/repository) or (better) add it to a personal Maven repo server__
+
+=== Running database-specific tests from the IDE using "profiles"
+
+You can run any test on any particular database that is configured in a `databases.gradle` profile.
+
+All you have to do is run the following command:
+
+----
+gradlew setDataBase -Pdb=pgsql
+----
+
+or you can use the shortcut version: 
+
+----
+gradlew sDB -Pdb=pgsql
+----
+
+You can do this from the module which you are interested in testing or from the `hibernate-orm` root folder.
+
+Afterward, just pick any test from the IDE and run it as usual. Hibernate will pick the database configuration from the `hibernate.properties`
+file that was set up by the `setDataBase` Gradle task.
+
+=== Starting test databases locally as docker containers
+
+You don't have to install all databases locally to be able to test against them in case you have docker available.
+The script `docker_db.sh` allows you to start a pre-configured database which can be used for testing.
+
+All you have to do is run the following command:
+
+----
+./docker_db.sh postgresql_9_5
+----
+
+omitting the argument will print a list of possible options.
+
+When the database is properly started, you can run tests with special profiles that are suffixed with `_ci`
+e.g. `pgsql_ci` for PostgreSQL. By using the system property `dbHost` you can configure the IP address of your docker host.
+
+The command for running tests could look like the following:
+
+----
+gradlew test -Pdb=pgsql_ci "-DdbHost=192.168.99.100"
+----

README.md

@@ -1,169 +0,0 @@
-<img src="http://static.jboss.org/hibernate/images/hibernate_logo_whitebkg_200px.png" />
-
-
-Hibernate ORM is a library providing Object/Relational Mapping (ORM) support
-to applications, libraries, and frameworks.
-
-It also provides an implementation of the JPA specification, which is the standard Java specification for ORM.
-
-This is the repository of its source code: see [Hibernate.org](http://hibernate.org/orm/) for additional information.
-
-[![Build Status](http://ci.hibernate.org/job/hibernate-orm-main-h2-main/badge/icon)](http://ci.hibernate.org/job/hibernate-orm-main-h2-main/)
-[![Language grade: Java](https://img.shields.io/lgtm/grade/java/g/hibernate/hibernate-orm.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/hibernate/hibernate-orm/context:java)
-
-
-Continuous Integration
-======================
-
-Hibernate uses both [Jenkins](http://jenkins-ci.org) and [TravisCI](https://travis-ci.org/) for its CI needs.  See
-
-* [Jenkins Jobs](http://ci.hibernate.org/view/ORM/)
-* [TravisCI Jobs](https://travis-ci.org/hibernate/hibernate-orm)
-
-
-Building from sources
-=====================
-
-The build requires a Java 8 JDK as JAVA_HOME.
-
-You will need [Git](https://git-scm.com/) to obtain the [source](https://github.com/hibernate/hibernate-orm/).
-
-Hibernate uses [Gradle](https://gradle.org) as its build tool.  See the _Gradle Primer_ section below if you are new to
-Gradle.
-
-Contributors should read the [Contributing Guide](CONTRIBUTING.md).
-
-See the guides for setting up [IntelliJ](http://hibernate.org/community/contribute/intellij-idea/) or
-[Eclipse](https://hibernate.org/community/contribute/eclipse-ide/) as your development environment.
-
-Check out the _Getting Started_ section in CONTRIBUTING.md for getting started working on Hibernate source.
-
-
-Gradle Primer
-============
-
-This section describes some of the basics developers and contributors new to Gradle might 
-need to know to get productive quickly.  The Gradle documentation is very well done; 2 in 
-particular that are indispensable:
-
-* [Gradle User Guide](https://docs.gradle.org/current/userguide/userguide_single.html) is a typical user guide in that
-it follows a topical approach to describing all of the capabilities of Gradle.
-* [Gradle DSL Guide](https://docs.gradle.org/current/dsl/index.html) is unique and excellent in quickly
-getting up to speed on certain aspects of Gradle.
-
-
-Using the Gradle Wrapper
-------------------------
-
-For contributors who do not otherwise use Gradle and do not want to install it, Gradle offers a very cool
-feature called the wrapper.  It lets you run Gradle builds without a previously installed Gradle distro in 
-a zero-conf manner.  Hibernate configures the Gradle wrapper for you.  If you would rather use the wrapper and 
-not install Gradle (or to make sure you use the version of Gradle intended for older builds) you would just use
-the command `gradlew` (or `gradlew.bat`) rather than `gradle` (or `gradle.bat`) in the following discussions.
-Note that `gradlew` is only available in the project's root dir, so depending on your working directory you may
-need to adjust the path to `gradlew` as well.
-
-Examples use the `gradle` syntax, but just swap `gradlew` (properly relative) for `gradle` if you wish to use 
-the wrapper.
-
-Another reason to use `gradlew` is that it uses the exact version of Gradle that the build is defined to work with.
-
-
-Executing Tasks
-------------------------
-
-Gradle uses the concept of build tasks (equivalent to Ant targets or Maven phases/goals). You can get a list of
-available tasks via 
-
-    gradle tasks
-
-To execute a task across all modules, simply perform that task from the root directory.  Gradle will visit each
-sub-project and execute that task if the sub-project defines it.  To execute a task in a specific module you can 
-either:
-
-1. `cd` into that module directory and execute the task
-2. name the "task path".  For example, to run the tests for the _hibernate-core_ module from the root directory you could say `gradle hibernate-core:test`
-
-Common Java related tasks
-------------------------
-
-* _build_ - Assembles (jars) and tests this project
-* _buildDependents_ - Assembles and tests this project and all projects that depend on it.  So think of running this in hibernate-core, Gradle would assemble and test hibernate-core as well as hibernate-envers (because envers depends on core)
-* _classes_ - Compiles the main classes
-* _testClasses_ - Compiles the test classes
-* _compile_ (Hibernate addition) - Performs all compilation tasks including staging resources from both main and test
-* _jar_ - Generates a jar archive with all the compiled classes
-* _test_ - Runs the tests
-* _publish_ - Think Maven deploy
-* _publishToMavenLocal_ - Installs the project jar to your local maven cache (aka ~/.m2/repository).  Note that Gradle 
-never uses this, but it can be useful for testing your build with other local Maven-based builds.
-* _eclipse_ - Generates an Eclipse project
-* _idea_ - Generates an IntelliJ/IDEA project (although the preferred approach is to use IntelliJ's Gradle import).
-* _clean_ - Cleans the build directory
-
-
-Testing and databases
-=====================
-
-Testing against a specific database can be achieved in 2 different ways:
-
-
-Using the "Matrix Testing Plugin" for Gradle.
----------------------------------------------
-
-Coming soon...
-
-
-Using "profiles"
-------------------------
-
-The Hibernate build defines several database testing "profiles" in `databases.gradle`.  These
-profiles can be activated by name using the `db` build property which can be passed either as
-a JVM system prop (`-D`) or as a Gradle project property (`-P`).  Examples below use the Gradle
-project property approach.
-
-    gradle clean build -Pdb=pgsql
-
-To run a test from your IDE, you need to ensure the property expansions happen.
-Use the following command:
-
-    gradle clean compile -Pdb=pgsql
-
-_*NOTE: If you are running tests against a JDBC driver that is not available via Maven central be sure to add these drivers to your local Maven repo cache (~/.m2/repository) or (better) add it to a personal Maven repo server*_
-
-Running database-specific tests from the IDE using "profiles"
--------------------------------------------------------------
-
-You can run any test on any particular database that is configured in a `databases.gradle` profile.
-
-All you have to do is run the following command:
-
-    gradlew setDataBase -Pdb=pgsql
-    
-or you can use the shortcut version:    
-
-    gradlew sDB -Pdb=pgsql
-    
-You can do this from the module which you are interested in testing or from the `hibernate-orm` root folder.
-
-Afterward, just pick any test from the IDE and run it as usual. Hibernate will pick the database configuration from the `hibernate.properties`
-file that was set up by the `setDataBase` Gradle task.
-
-Starting test databases locally as docker containers
--------------------------------------------------------------
-
-You don't have to install all databases locally to be able to test against them in case you have docker available.
-The script `docker_db.sh` allows you to start a pre-configured database which can be used for testing.
-
-All you have to do is run the following command:
-
-    ./docker_db.sh postgresql_9_5
-
-omitting the argument will print a list of possible options.
-
-When the database is properly started, you can run tests with special profiles that are suffixed with `_ci`
-e.g. `pgsql_ci` for PostgreSQL. By using the system property `dbHost` you can configure the IP address of your docker host.
-
-The command for running tests could look like the following:
-
-    gradlew test -Pdb=pgsql_ci "-DdbHost=192.168.99.100"

build.gradle

@@ -22,11 +22,17 @@ buildscript {
 	}
 }
 
+
 plugins {
+	id 'io.github.gradle-nexus.publish-plugin' version '1.1.0'
+	id 'nu.studer.credentials' version '2.1'
+
+	id 'idea'
+	id 'org.jetbrains.gradle.plugin.idea-ext' version '0.5'
+	id 'eclipse'
+
 	id 'me.champeau.buildscan-recipes' version '0.2.3'
 	id 'org.hibernate.build.xjc' version '2.0.1' apply false
-	id 'org.hibernate.build.maven-repo-auth' version '3.0.3' apply false
-	id 'org.jetbrains.gradle.plugin.idea-ext' version '0.5'
 	id 'biz.aQute.bnd' version '5.1.1' apply false
 }
 
@@ -40,21 +46,15 @@ allprojects {
 				dirs "${System.env.ADDITIONAL_REPO}"
 			}
 		}
-		// Needed atm for asciidoclet PR-91, which does not seem to work anyway :(
-		// todo (6.0) : remove once/if PR-91 ever works and becomes part of asciidoclet proper
-		maven {
-			name 'jboss-snapshots-repository'
-			url 'https://repository.jboss.org/nexus/content/repositories/snapshots'
-		}
 	}
+
+	apply from: rootProject.file( 'gradle/base-information.gradle' )
+
 	apply plugin: 'idea'
 	apply plugin: 'eclipse'
 
 	// minimize changes, at least for now (gradle uses 'build' by default)..
 	buildDir = "target"
-
-	apply from: rootProject.file( 'gradle/base-information.gradle' )
-
 }
 
 
@@ -84,6 +84,59 @@ task publish {
 			"themselves if they have any release-related activities to perform"
 }
 
+ext {
+	// look for command-line overrides of the username/password pairs for publishing
+	if ( project.hasProperty( 'hibernatePublishUsername' ) ) {
+		credentials.hibernatePublishUsername = project.property( 'hibernatePublishUsername' )
+	}
+	if ( project.hasProperty( 'hibernatePublishPassword' ) ) {
+		credentials.hibernatePublishPassword = project.property( 'hibernatePublishPassword' )
+	}
+
+	if ( project.hasProperty( 'hibernateSnapshotsUsername' ) ) {
+		credentials.hibernateSnapshotsUsername = project.property( 'hibernateSnapshotsUsername' )
+	}
+	if ( project.hasProperty( 'hibernateSnapshotsPassword' ) ) {
+		credentials.hibernateSnapshotsPassword = project.property( 'hibernateSnapshotsPassword' )
+	}
+}
+
+gradle.taskGraph.addTaskExecutionGraphListener(
+		new TaskExecutionGraphListener() {
+			@Override
+			void graphPopulated(TaskExecutionGraph graph) {
+				// make sure the needed username/password pair is available based on whether
+				// we are trying to perform a release or snapshot publishing (if either)
+				if ( graph.hasTask( 'publishMavenJavaPublicationToSnapshotRepository' ) ) {
+					if ( ! project.hcannVersion.isSnapshot ) {
+						throw new GradleException("Cannot publish non-snapshot version to snapshot repository");
+					}
+					if ( project.credentials.hibernateSnapshotsUsername == null ) {
+						throw new GradleException("Snapshot publishing credentials not specified");
+					}
+				}
+
+				if (graph.hasTask('publishMavenJavaPublicationToOssrhRepository')) {
+					if ( project.hcannVersion.isSnapshot ) {
+						throw new GradleException("Cannot publish snapshot version to non-snapshot repository");
+					}
+					if (project.credentials.hibernatePublishUsername == null) {
+						throw new GradleException("Publishing credentials not specified");
+					}
+				}
+			}
+		}
+)
+
+nexusPublishing {
+	repositories {
+		sonatype {
+			username = project.credentials.hibernatePublishUsername
+			password = project.credentials.hibernatePublishPassword
+		}
+	}
+}
+
 
 
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -97,6 +150,10 @@ task ciBuild {
 }
 
 
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Misc...
+
 wrapper {
 	// To upgrade the version of gradle used in the wrapper, run:
 	//     ./gradlew wrapper --gradle-version NEW_VERSION

documentation/documentation.gradle

@@ -40,37 +40,34 @@ defaultTasks 'buildDocs'
 dependencies {
 	ext.pressgangVersion = '3.0.0'
 
-	compile( libraries.jpa )
+	implementation project( ':hibernate-core' )
-	compile( project( ':hibernate-core' ) )
-	annotationProcessor( project( ':hibernate-jpamodelgen' ) )
 
-	testCompile( 'org.apache.commons:commons-lang3:3.4' )
+	annotationProcessor project( ':hibernate-jpamodelgen' )
 
-	testCompile( project(':hibernate-envers') )
+	testImplementation project(':hibernate-testing')
+	testImplementation project(':hibernate-envers')
 	// todo (6.0) - add back hibernate-spatial dependency
-//	testCompile( project(':hibernate-spatial') )
+	//testImplementation project(':hibernate-spatial')
-	testCompile( project(path: ':hibernate-core', configuration: 'tests') )
+	testImplementation project( ':hibernate-jcache' )
+	testImplementation libraries.jcache
+	testImplementation project( path: ':hibernate-core', configuration: 'tests' )
 
-	testCompile( project(':hibernate-testing') )
+	testImplementation 'org.apache.commons:commons-lang3:3.4'
+	testImplementation 'org.osgi:org.osgi.core:4.3.1'
 
-	testCompile "org.osgi:org.osgi.core:4.3.1"
+	testImplementation libraries.mockito
+	testImplementation libraries.mockito_inline
 
-	testCompile( libraries.mockito )
+	testRuntimeOnly libraries.wildfly_transaction_client
-	testCompile( libraries.mockito_inline )
+	testRuntimeOnly libraries.h2
-
+	testRuntimeOnly libraries.hsqldb
-	testRuntime( libraries.wildfly_transaction_client )
+	testRuntimeOnly libraries.postgresql
-	testRuntime( libraries.h2 )
+	testRuntimeOnly libraries.mysql
-	testRuntime( libraries.hsqldb )
+	testRuntimeOnly libraries.mariadb
-	testRuntime( libraries.postgresql )
+	testRuntimeOnly libraries.mssql
-	testRuntime( libraries.mysql )
+	testRuntimeOnly libraries.hana
-	testRuntime( libraries.mariadb )
+	testRuntimeOnly libraries.cockroachdb
-	testRuntime( libraries.mssql )
+	testRuntimeOnly libraries.ehcache3
-	testRuntime( libraries.hana )
-	testRuntime( libraries.cockroachdb )
-	testRuntime( libraries.firebird )
-
-	testCompile( project( ':hibernate-jcache' ) )
-	testRuntime( libraries.ehcache3 )
 }
 
 

gradle/base-information.gradle

@@ -7,11 +7,9 @@
 
 apply plugin: 'base'
 
-File versionFile = file( "${rootProject.projectDir}/gradle/version.properties" )
-
 ext {
-	ormVersionFile = versionFile
+	ormVersionFile = file( "${rootProject.projectDir}/gradle/version.properties" )
-	ormVersion = HibernateVersion.fromFile( versionFile, project )
+	ormVersion = HibernateVersion.fromFile( ormVersionFile, project )
 	// Override during releases
 	if ( project.hasProperty( 'releaseVersion' ) ) {
 		ormVersion = new HibernateVersion( project.releaseVersion, project )

gradle/java-module.gradle

@@ -9,8 +9,6 @@
  * Support for modules that contain Java code
  */
 
-
-
 buildscript {
 	repositories {
 		mavenCentral()
@@ -23,21 +21,27 @@ buildscript {
 import de.thetaphi.forbiddenapis.gradle.CheckForbiddenApis
 import org.apache.tools.ant.filters.ReplaceTokens
 
-/**
- * Support for modules that contain Java code
- */
-
-apply from: rootProject.file( 'gradle/base-information.gradle' )
 apply from: rootProject.file( 'gradle/libraries.gradle' )
 apply from: rootProject.file( 'gradle/databases.gradle' )
 
 apply plugin: 'java'
+apply plugin: 'java-library'
 apply plugin: 'biz.aQute.bnd.builder'
 
 apply plugin: 'checkstyle'
 apply plugin: 'build-dashboard'
 apply plugin: 'project-report'
 
+ext {
+	forbiddenAPITargetJDKCompatibility = '11'
+}
+
+if ( !project.description ) {
+	project.description = "The Hibernate ORM $project.name module"
+}
+
+
+
 // Attempt to leverage JetBrain's Gradle extension to automatically define
 // `copyResourcesToIntelliJOutFolder` as a "build trigger" on import.
 //
@@ -72,64 +76,60 @@ configurations.all*.exclude group: 'xml-apis', module: 'xml-apis'
 
 
 dependencies {
-	compile libraries.logging
+	implementation libraries.logging
-
-	provided libraries.logging_annotations
-
-	annotationProcessor( libraries.logging_processor )
-	annotationProcessor( libraries.logging )
-	annotationProcessor( libraries.logging_annotations )
-
 
+	compileOnly libraries.logging_annotations
 
 	// JUnit dependencies made up of:
 	// 		* JUnit 5
 	// 		* the Jupiter engine which runs JUnit 5 based tests
 	//		* the "vintage" engine - which runs JUnit 3 and 4 based tests
-	testCompile( libraries.junit5_api )
+	testImplementation libraries.junit5_api
-	testRuntime( libraries.junit5_jupiter )
+	testImplementation libraries.junit5_jupiter
-	testCompile( libraries.junit5_params )
+	testImplementation libraries.junit5_params
-	testCompile( libraries.junit )
+	testImplementation libraries.junit
-	testRuntime( libraries.junit5_vintage )
+	testImplementation libraries.junit5_vintage
 
-	testCompile( libraries.byteman )
+	testImplementation libraries.byteman
-	testCompile( libraries.byteman_install )
+	testImplementation libraries.byteman_install
-	testCompile( libraries.byteman_bmunit )
+	testImplementation libraries.byteman_bmunit
 
-	testRuntime( libraries.log4j )
+	testRuntimeOnly libraries.log4j
-	testRuntime( libraries.javassist )
+	testRuntimeOnly libraries.javassist
-	testRuntime( libraries.byteBuddy )
+	testRuntimeOnly libraries.byteBuddy
 
 	//Databases
-	testRuntime( libraries.h2 )
+	testRuntimeOnly libraries.h2
-	testRuntime( libraries.derby )
+	testRuntimeOnly libraries.derby
-	testRuntime( libraries.hsqldb )
+	testRuntimeOnly libraries.hsqldb
-	testRuntime( libraries.postgresql )
+	testRuntimeOnly libraries.postgresql
-	testRuntime( libraries.mysql )
+	testRuntimeOnly libraries.mysql
-	testRuntime( libraries.mariadb )
+	testRuntimeOnly libraries.mariadb
-	testRuntime( libraries.mssql )
+	testRuntimeOnly libraries.mssql
-	testRuntime( libraries.informix )
+	testRuntimeOnly libraries.informix
-	testRuntime( libraries.hana )
+	testRuntimeOnly libraries.hana
-	testRuntime( libraries.cockroachdb )
+	testRuntimeOnly libraries.cockroachdb
-	testRuntime( libraries.firebird )
+	testRuntimeOnly libraries.oracle
-
-	testRuntime( libraries.oracle )
 
 	// Since both the DB2 driver and HANA have a package "net.jpountz" we have to add dependencies conditionally
 	// This is due to the "no split-packages" requirement of Java 9+
 
 	if ( db.startsWith( 'db2' ) ) {
-		testRuntime( libraries.db2 )
+		testRuntimeOnly libraries.db2
 	}
 	else if ( db.startsWith( 'hana' ) ) {
-		testRuntime( libraries.hana )
+		testRuntimeOnly libraries.hana
 	}
 
 	// Mac-specific
 	project.ext.toolsJar = file("${System.getProperty('java.home')}/../lib/tools.jar")
 	if ( project.toolsJar.exists() ) {
-		testCompile files( project.toolsJar )
+		testCompileOnly files( project.toolsJar )
 	}
+
+	annotationProcessor libraries.logging_processor
+	annotationProcessor libraries.logging
+	annotationProcessor libraries.logging_annotations
 }
 
 

gradle/published-java-module.gradle

@@ -6,28 +6,16 @@
  */
 
 apply from: rootProject.file( 'gradle/java-module.gradle' )
-
-apply from: rootProject.file( 'gradle/publishing-repos.gradle' )
 apply from: rootProject.file( 'gradle/publishing-pom.gradle' )
 
 
-
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// Configurations and Dependencies
+// Published artifacts (main, sources, javadoc)
 
-configurations {
+ext {
-	asciidoclet {
+	java9ModuleNameBase = project.name.startsWith( 'hibernate-' ) ? name.drop( 'hibernate-'.length() ): name
-		description = 'Dependencies for Asciidoctor Javadoc taglet'
+	java9ModuleName = "org.hibernate.orm.$project.java9ModuleNameBase"
 }
-}
-
-dependencies {
-	asciidoclet( libraries.asciidoclet )
-}
-
-
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// Jar
 
 jar {
 	manifest {
@@ -113,7 +101,6 @@ task javadocJar(type: Jar) {
 	archiveClassifier.set( 'javadoc' )
 }
 
-
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 // Javadoc
 
@@ -131,20 +118,16 @@ javadoc {
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 // Publishing
 
+java {
+	withJavadocJar()
+	withSourcesJar()
+}
+
+
 publishing {
 	publications {
 		publishedArtifacts {
 			from components.java
-
-			artifact( sourcesJar ) {
-				// todo : do these really need to be specified twice?
-				classifier 'sources'
-			}
-
-			artifact( javadocJar ) {
-				// todo : do these really need to be specified twice?
-				classifier "javadoc"
-			}
 		}
 	}
 }
@@ -211,14 +194,12 @@ publishing {
 	}
 }
 
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Release / publishing tasks
+
 task ciBuild( dependsOn: [test, publish] )
 
-task release( dependsOn: [test, bintrayUpload] )
+task release(dependsOn: [test, publishToSonatype])
-bintrayUpload.mustRunAfter test
+publishToSonatype.mustRunAfter test
 
-afterEvaluate { Project project ->
-	project.rootProject.subprojects { Project subproject ->
-		// NOTE : we want this even when `project == subproject`
-		project.tasks.bintrayUpload.dependsOn( subproject.tasks.build )
-	}
-}

gradle/publishing-pom.gradle

@@ -14,9 +14,8 @@ tasks.withType(GenerateModuleMetadata) {
 }
 
 publishing {
-
 	publications {
-		publishedArtifacts {
+		publishedArtifacts( MavenPublication ) {
 			pom {
 				name = 'Hibernate ORM - ' + project.name
 				description = project.description

gradle/publishing-repos.gradle

@@ -1,77 +0,0 @@
-/*
- * Hibernate, Relational Persistence for Idiomatic Java
- *
- * License: GNU Lesser General Public License (LGPL), version 2.1 or later
- * See the lgpl.txt file in the root directory or http://www.gnu.org/licenses/lgpl-2.1.html
- */
-
-apply from: rootProject.file( 'gradle/base-information.gradle' )
-
-
-apply plugin: 'maven-publish'
-apply plugin: 'org.hibernate.build.maven-repo-auth'
-apply plugin: 'com.jfrog.bintray'
-
-
-ext {
-	bintrayUser = project.findProperty( 'PERSONAL_BINTRAY_USER' )
-	bintrayKey = project.findProperty( 'PERSONAL_BINTRAY_API_KEY' )
-	sonatypeOssrhUser = project.findProperty( 'SONATYPE_OSSRH_USER' )
-	sonatypeOssrhPassword = project.findProperty( 'SONATYPE_OSSRH_PASSWORD' )
-}
-
-
-publishing {
-	publications {
-		publishedArtifacts( MavenPublication )
-	}
-
-	repositories {
-		maven {
-			name 'jboss-snapshots-repository'
-			url 'https://repository.jboss.org/nexus/content/repositories/snapshots'
-		}
-	}
-}
-
-bintray {
-	user = project.bintrayUser
-	key = project.bintrayKey
-
-	publications = ['publishedArtifacts','relocationArtifacts']
-
-	pkg {
-		userOrg = 'hibernate'
-		repo = 'artifacts'
-		name = 'hibernate-orm'
-
-		publish = true
-
-		version {
-			name = project.version
-			description ="Hibernate ORM ${project.version} release.  See http://hibernate.org/orm/releases/${project.ormVersion.family}"
-			released  = new Date()
-			vcsTag = project.version
-			gpg {
-				sign = true
-			}
-			attributes = [
-					'jpa': project.jpaVersion.name,
-					'family': project.ormVersion.family
-			]
-			mavenCentralSync {
-				sync = true
-				user = project.sonatypeOssrhUser
-				password = project.sonatypeOssrhPassword
-			}
-		}
-	}
-}
-
-model {
-	tasks.generatePomFileForPublishedArtifactsPublication {
-		destination = file( "${buildDir}/generated-pom.xml" )
-	}
-}
-
-task generatePomFile( dependsOn: 'generatePomFileForPublishedArtifactsPublication' )

hibernate-agroal/hibernate-agroal.gradle

@@ -10,12 +10,12 @@ description = 'Integration for Agroal as a ConnectionProvider for Hibernate ORM'
 apply from: rootProject.file( 'gradle/published-java-module.gradle' )
 
 dependencies {
-    compile project( ':hibernate-core' )
+    implementation project( ':hibernate-core' )
-    compile( libraries.agroal_api )
+    implementation libraries.agroal_api
 
-    runtime( libraries.agroal_pool )
+    runtimeOnly libraries.agroal_pool
 
-    testCompile project( ':hibernate-testing' )
+    testImplementation project( ':hibernate-testing' )
-    testCompile( libraries.mockito )
+    testImplementation libraries.mockito
-    testCompile( libraries.mockito_inline )
+    testImplementation libraries.mockito_inline
 }

hibernate-c3p0/hibernate-c3p0.gradle

@@ -10,22 +10,22 @@ description = 'Integration for c3p0 Connection pooling into Hibernate ORM'
 apply from: rootProject.file( 'gradle/published-java-module.gradle' )
 
 dependencies {
-    compile project( ':hibernate-core' )
+    implementation project( ':hibernate-core' )
-    compile( libraries.c3p0 )
+    implementation libraries.c3p0
 
-    testCompile project( ':hibernate-testing' )
+    testImplementation project( ':hibernate-testing' )
-    testCompile( libraries.mockito )
+    testImplementation libraries.mockito
-    testCompile( libraries.mockito_inline )
+    testImplementation libraries.mockito_inline
 
-    testCompile( libraries.validator ) {
+    testImplementation( libraries.validator ) {
         // for test runtime
         transitive = true
     }
     // EL libraries are provided scope in Validator
-    testRuntime( libraries.expression_language )
+    testRuntimeOnly( libraries.expression_language )
 
     if ( db.equalsIgnoreCase( 'oracle' ) ) {
-        testRuntime( libraries.oracle )
+        testRuntimeOnly( libraries.oracle )
     }
 }
 

hibernate-core/hibernate-core.gradle

@@ -20,11 +20,22 @@ ext {
     jaxbTargetDir = file( "${buildDir}/generated-src/jaxb/main" )
 }
 
-sourceSets.main {
+configurations {
-    java.srcDir project.jaxbTargetDir
+    tests {
+        description = 'Configuration for the produced test jar'
+    }
+
+    javassist {
+        description "Dependencies for compiling and running the Javassist tests in the `javassist` source-set"
+    }
 }
 
 sourceSets {
+    main {
+        // add the XJC generated JAXB classes to the main source-set
+        java.srcDir project.jaxbTargetDir
+    }
+
     // resources inherently exclude sources
     test {
         resources {
@@ -32,84 +43,75 @@ sourceSets {
         }
     }
 
+    testJavassist {
+        // define the testJavassist source-set
+        java {
+            compileClasspath += main.output + test.output + configurations.javassist
+            runtimeClasspath += main.output + test.output + configurations.javassist
         }
-
-configurations {
-    tests {
-        description = 'Configuration for the produced test jar'
     }
-
 }
 
 dependencies {
-    compile( libraries.jpa )
+    api libraries.jpa
-    compile( libraries.byteBuddy )
+    api libraries.jta
-    compile( libraries.antlr )
+    api libraries.jandex
-    compile( libraries.jta )
+    api libraries.classmate
-    compile( libraries.jandex )
+    api libraries.commons_annotations
-    compile( libraries.classmate )
+    api libraries.jaxb_api
-    compile( libraries.activation )
 
-    compile( libraries.commons_annotations )
+    implementation libraries.byteBuddy
+    implementation libraries.activation
+    implementation libraries.jaxb_runtime
+    implementation libraries.antlr
 
-    // JAXB
+    compileOnly libraries.jacc
-    compile( libraries.jaxb_api )
+    compileOnly libraries.validation
-    compile( libraries.jaxb_runtime )
+    compileOnly libraries.ant
+    compileOnly libraries.cdi
+    compileOnly configurations.javassist
 
-	// Antlr
+    testImplementation project(':hibernate-testing')
-	antlr( libraries.antlr )
+    testImplementation libraries.shrinkwrap_api
-
+    testImplementation libraries.shrinkwrap
-	// xjc plugin
+    testImplementation libraries.shrinkwrap_descriptors_api_javaee
-    xjc( libraries.jaxb_runtime )
+    testImplementation libraries.shrinkwrap_descriptors_impl_javaee
-    xjc( libraries.jaxb_xjc )
+    testImplementation libraries.jacc
-    xjc( libraries.jaxb2_basics )
+    testImplementation libraries.validation
-    xjc( libraries.jaxb2_basics_ant )
+    testImplementation( libraries.validator ) {
-    xjc( libraries.activation )
-
-    provided( libraries.jacc )
-    provided( libraries.validation )
-    provided( libraries.ant )
-	provided( libraries.cdi )
-
-    testCompile( project(':hibernate-testing') )
-    testCompile( libraries.shrinkwrap_api )
-    testCompile( libraries.shrinkwrap )
-    testCompile( libraries.jacc )
-    testCompile( libraries.validation )
-    testCompile( libraries.jandex )
-    testCompile( libraries.classmate )
-    testCompile( libraries.mockito )
-    testCompile( libraries.mockito_inline )
-    testCompile( libraries.jodaTime )
-    testCompile( libraries.assertj )
-
-    testCompile( libraries.cdi )
-
-    testCompile( libraries.validator ) {
         // for test runtime
         transitive = true
     }
+    testImplementation libraries.jandex
+    testImplementation libraries.classmate
+    testImplementation libraries.mockito
+    testImplementation libraries.mockito_inline
+    testImplementation libraries.jodaTime
+    testImplementation libraries.assertj
+    testImplementation libraries.log4j
+    testImplementation libraries.cdi
+    testImplementation libraries.jboss_ejb_spec_jar
+    testImplementation libraries.jboss_annotation_spec_jar
 
-    // for testing stored procedure support
+    testRuntimeOnly "org.jboss.spec.javax.ejb:jboss-ejb-api_3.2_spec:1.0.0.Final"
-    testCompile( libraries.derby )
+    testRuntimeOnly libraries.expression_language
+    testRuntimeOnly 'jaxen:jaxen:1.1'
+//    testRuntimeOnly libraries.javassist
+    testRuntimeOnly libraries.byteBuddy
+    testRuntimeOnly libraries.weld
+    testRuntimeOnly libraries.atomikos
+    testRuntimeOnly libraries.atomikos_jta
+    testRuntimeOnly libraries.wildfly_transaction_client
 
-    testRuntime( "org.jboss.spec.javax.ejb:jboss-ejb-api_3.2_spec:1.0.0.Final" )
+    testAnnotationProcessor project( ':hibernate-jpamodelgen' )
-    testRuntime( libraries.expression_language )
-    testRuntime( 'jaxen:jaxen:1.1' )
-    testRuntime( libraries.byteBuddy )
-    testRuntime( libraries.weld )
-    testRuntime( libraries.atomikos )
-    testRuntime( libraries.atomikos_jta )
-    testRuntime(libraries.wildfly_transaction_client)
 
-    testAnnotationProcessor( project( ':hibernate-jpamodelgen' ) )
+    antlr libraries.antlr
-
-    testCompile libraries.shrinkwrap_descriptors_api_javaee
-    testCompile libraries.shrinkwrap_descriptors_impl_javaee
-
-    testCompile libraries.jboss_ejb_spec_jar
-    testCompile libraries.jboss_annotation_spec_jar
 
+    xjc libraries.jaxb_runtime
+    xjc libraries.jaxb_xjc
+    xjc libraries.jaxb2_basics
+    xjc libraries.jaxb2_basics_ant
+    xjc libraries.activation
 }
 
 jar {

hibernate-envers/hibernate-envers.gradle

@@ -11,19 +11,23 @@ apply from: rootProject.file( 'gradle/published-java-module.gradle' )
 apply plugin: 'hibernate-matrix-testing'
 
 dependencies {
-    compile( project( ':hibernate-core' ) ) {
+    api( project( ':hibernate-core' ) ) {
         // Exclude access to this to avoid future use.
+        // todo (6.0) : this should no longer be transitive from core.  Come back and verify this
         exclude group: "org.javassist", module: "javassist"
     }
 
+    implementation libraries.commons_annotations
+
     // TODO HHH-13703: get rid of this dependency
-    compile( libraries.dom4j )
+    implementation libraries.dom4j
 
-    provided( libraries.ant )
+    compileOnly libraries.ant
-    annotationProcessor( project( ':hibernate-jpamodelgen' ) )
 
-    testCompile( project( ':hibernate-testing' ) )
+    annotationProcessor project( ':hibernate-jpamodelgen' )
-    testCompile( project( path: ':hibernate-core', configuration: 'tests' ) )
+
+    testImplementation project( ':hibernate-testing' )
+    testImplementation project( path: ':hibernate-core', configuration: 'tests' )
 }
 
 sourceSets {

hibernate-graalvm/hibernate-graalvm.gradle

@@ -12,6 +12,7 @@ apply from: rootProject.file( 'gradle/published-java-module.gradle' )
 dependencies {
     //No need for transitive dependencies: this is all just metadata to be used as companion jar.
     compileOnly project( ':hibernate-core' )
-    compileOnly( libraries.graalvm_nativeimage )
+    compileOnly libraries.graalvm_nativeimage
-    testCompile( project( ':hibernate-core' ) )
+
+    testImplementation project( ':hibernate-core' )
 }

hibernate-hikaricp/hibernate-hikaricp.gradle

@@ -10,8 +10,9 @@ description = 'Integration for HikariCP into Hibernate O/RM'
 apply from: rootProject.file( 'gradle/published-java-module.gradle' )
 
 dependencies {
-    compile project( ':hibernate-core' )
+    implementation project( ':hibernate-core' )
-    compile( libraries.hikaricp )
+    implementation libraries.hikaricp
-    testCompile project( ':hibernate-testing' )
+
-    testCompile(libraries.mockito)
+    testImplementation project( ':hibernate-testing' )
+    testImplementation libraries.mockito
 }

hibernate-integrationtest-java-modules/hibernate-integrationtest-java-modules.gradle

@@ -7,22 +7,9 @@
 
 description = 'Integration tests for running Hibernate ORM in the Java module path'
 
-buildscript {
-	repositories {
-		maven {
-			url "https://plugins.gradle.org/m2/"
-		}
-	}
-	dependencies {
-		classpath "org.javamodularity:moduleplugin:1.5.0"
-	}
-}
-
 apply from: rootProject.file( 'gradle/java-module.gradle' )
 
-// No first-class, built-in support for Java modules in Gradle yet,
+java.modularity.inferModulePath = true
-// so we have to use https://github.com/java9-modularity/gradle-modules-plugin
-apply plugin: "org.javamodularity.moduleplugin"
 
 // In this module, the "main" code is actually just test code that happens
 // to be built independently so as to generate a Java module.
@@ -55,9 +42,9 @@ tasks.compileJava {
 checkstyleMain.exclude '**/module-info.java'
 
 dependencies {
-	compile( project( ':hibernate-core' ) )
+	api project( ':hibernate-core' )
-	compile( project( ':hibernate-envers' ) )
+	api project( ':hibernate-envers' )
-	compile( libraries.jpa )
+	implementation libraries.jpa
 }
 
 test {

hibernate-jcache/hibernate-jcache.gradle

@@ -4,11 +4,12 @@ apply from: rootProject.file( 'gradle/published-java-module.gradle' )
 
 
 dependencies {
-    compile project( ':hibernate-core' )
+    implementation project( ':hibernate-core' )
-    compile( libraries.jcache )
+    implementation libraries.jcache
 
-    testCompile project( ':hibernate-testing' )
+    testImplementation project( ':hibernate-testing' )
-    testCompile( libraries.mockito )
+    testImplementation libraries.mockito
-    testCompile( libraries.mockito_inline )
+    testImplementation libraries.mockito_inline
-    testRuntime( libraries.ehcache3 )
+
+    testRuntimeOnly libraries.ehcache3
 }

hibernate-micrometer/hibernate-micrometer.gradle

@@ -4,14 +4,15 @@ apply from: rootProject.file( 'gradle/published-java-module.gradle' )
 
 
 dependencies {
-    compile project( ':hibernate-core' )
+    implementation project( ':hibernate-core' )
-    compile( libraries.jpa )
+    implementation libraries.jpa
-    compile( libraries.micrometer )
+    implementation libraries.micrometer
 
-    testCompile project( ':hibernate-testing' )
+    testImplementation project( ':hibernate-testing' )
-    testCompile( libraries.mockito )
+    testImplementation libraries.mockito
-    testCompile( libraries.mockito_inline )
+    testImplementation libraries.mockito_inline
-    testAnnotationProcessor( project( ':hibernate-jpamodelgen' ) )
+
+    testAnnotationProcessor project( ':hibernate-jpamodelgen' )
 }
 
 sourceSets {

hibernate-proxool/hibernate-proxool.gradle

@@ -11,9 +11,10 @@ apply from: rootProject.file( 'gradle/published-java-module.gradle' )
 
 
 dependencies {
-    compile project( ':hibernate-core' )
+    implementation project( ':hibernate-core' )
-    compile( libraries.proxool )
+    implementation libraries.proxool
-    testCompile project( ':hibernate-testing' )
+
+    testImplementation project( ':hibernate-testing' )
 }
 
 test {

hibernate-testing/hibernate-testing.gradle

@@ -11,34 +11,30 @@ apply from: rootProject.file( 'gradle/published-java-module.gradle' )
 
 
 dependencies {
-    compile project( ':hibernate-core' )
+    api project( ':hibernate-core' )
 
-    compile( libraries.junit )
+    api libraries.junit
-    compile( libraries.junit5_api )
+    api libraries.junit5_api
-    compile( libraries.junit5_params )
+    api libraries.junit5_params
-    compile( 'org.hamcrest:hamcrest-all:1.3' )
+    api 'org.hamcrest:hamcrest-all:1.3'
+    api libraries.byteman
+    api libraries.byteman_install
+    api libraries.byteman_bmunit
 
-    compile( libraries.byteman )
+    api libraries.xapool
-    compile( libraries.byteman_install )
+//    api( libraries.jboss_tx_spi ) {
-    compile( libraries.byteman_bmunit )
+//        transitive=false;
-    compile( libraries.xapool )
+//    }
-    compile( libraries.log4j )
+    api( libraries.jboss_jta ) {
-    compile( libraries.jboss_jta ) {
         transitive=false;
     }
-    compile( 'javax.money:money-api:1.0.1' )
-    compile( 'org.javamoney:moneta:1.1' )
 
-    annotationProcessor( project( ':hibernate-jpamodelgen' ) )
+    api 'javax.money:money-api:1.0.1'
+    api 'org.javamoney:moneta:1.1'
 
-    testRuntime( libraries.h2 )
+    compileOnly libraries.log4j
-    testRuntime( libraries.log4j )
 }
 
 tasks.test.include '**/*'
 
-// todo : Fold into hibernate-core and publish in separate publications
-// 		once http://issues.gradle.org/browse/GRADLE-2966 is resolved;
-//		that will allow us to keep the same artifactId and publish the pom
-//		with proper dependencies
 

hibernate-vibur/hibernate-vibur.gradle

@@ -11,12 +11,12 @@ apply from: rootProject.file( 'gradle/published-java-module.gradle' )
 
 
 dependencies {
-    compile project( ':hibernate-core' )
+    implementation project( ':hibernate-core' )
-    compile( libraries.vibur )
+    implementation libraries.vibur
 
-    testCompile( libraries.vibur + ':tests' )
+    testImplementation project( ':hibernate-testing' )
-    testCompile( 'com.googlecode.concurrentlinkedhashmap:concurrentlinkedhashmap-lru:1.4.2' )
+    testImplementation libraries.vibur + ':tests'
-    testCompile project( ':hibernate-testing' )
+    testImplementation 'com.googlecode.concurrentlinkedhashmap:concurrentlinkedhashmap-lru:1.4.2'
-    testCompile( libraries.mockito )
+    testImplementation libraries.mockito
 }
 

release/README.adoc

@@ -0,0 +1,22 @@
+This project coordinates the tasks that need to be performed as part of creating a release for Hibernate.
+
+== Artifacts
+
+Both snapshot and release artifacts are published to Sonatype https://oss.sonatype.org/[OSSRH].
+
+The "official" detials about OSSRH + Gradle can be found at https://central.sonatype.org/publish/publish-gradle/.
+However, its content is way out of date as of the time of this writing.
+https://dev.to/kengotoda/deploying-to-ossrh-with-gradle-in-2020-1lhi presents a much better guide.  Regardless,
+This is all just for background; all of this information is "backed into" the build scripts.
+
+After release, be sure to manage the staging repository created for it on https://oss.sonatype.org/[OSSRH].
+
+
+== Documentation
+
+JBoss doc server...
+
+
+== SourceForge
+
+Release bundles (as ZIP and TGZ) are uploaded to https://sourceforge.net/projects/hibernate/files/hibernate-orm/[SourceForge]

tooling/hibernate-enhance-maven-plugin/hibernate-enhance-maven-plugin.gradle

@@ -21,26 +21,19 @@ processResources {
 }
 
 dependencies {
-    compile( libraries.maven_core ) { transitive = false }
+    implementation( project(':hibernate-core') ) { transitive = false }
-    compile( libraries.maven_artifact ) { transitive = false }
+    implementation( libraries.jpa ) { transitive = false }
-    compile( libraries.maven_plugin ) { transitive = false }
+    implementation( libraries.maven_core ) { transitive = false }
-    compile( libraries.maven_plugin_tools ) { transitive = false }
+    implementation( libraries.maven_artifact ) { transitive = false }
-    compile( project(':hibernate-core') ) { transitive = false }
+    implementation( libraries.maven_plugin ) { transitive = false }
-    compile( libraries.jpa ) { transitive = false }
+    implementation( libraries.maven_plugin_tools ) { transitive = false }
-    compile( libraries.javassist ) { transitive = false }
+    implementation 'org.codehaus.plexus:plexus-utils:3.0.24'
-    compile( libraries.byteBuddy ) { transitive = false }
+    implementation 'org.sonatype.plexus:plexus-build-api:0.0.7'
-    compile 'org.codehaus.plexus:plexus-utils:3.0.24'
+
-    compile 'org.sonatype.plexus:plexus-build-api:0.0.7'
+    runtimeOnly libraries.maven_core
-    runtime( libraries.maven_core )
+    runtimeOnly libraries.maven_artifact
-    runtime( libraries.maven_artifact )
+    runtimeOnly libraries.maven_plugin
-    runtime( libraries.maven_plugin )
+    runtimeOnly libraries.maven_plugin_tools
-    runtime( libraries.maven_plugin_tools )
-    runtime( project(':hibernate-core') )
-    runtime( libraries.jpa )
-    runtime( libraries.jta )
-    runtime( libraries.javassist )
-    runtime( libraries.byteBuddy )
-    runtime 'org.codehaus.plexus:plexus-utils:3.0.24'
 }
 
 // Inject dependencies into plugin.xml

tooling/hibernate-gradle-plugin/hibernate-gradle-plugin.gradle

@@ -13,11 +13,9 @@ plugins {
 
 	// for portal publishing
 	id "com.gradle.plugin-publish" version "0.12.0"
-	id "nu.studer.credentials" version "2.1"
 
 	// for publishing snapshots
 	id 'maven-publish'
-	id 'org.hibernate.build.maven-repo-auth'
 
 	id 'idea'
 	id 'eclipse'
@@ -45,11 +43,10 @@ ext {
 }
 
 dependencies {
-	compile project( ':hibernate-core' )
+	implementation project( ':hibernate-core' )
-	compile project( ':hibernate-testing' )
+
-	implementation( libraries.jpa )
+	implementation gradleApi()
-	implementation( libraries.javassist )
+	implementation localGroovy()
-	implementation( libraries.byteBuddy )
 }
 
 gradlePlugin {
@@ -110,13 +107,6 @@ publishing {
 			from components.java
 		}
 	}
-
-	repositories {
-		maven {
-			name 'jboss-snapshots-repository'
-			url 'https://repository.jboss.org/nexus/content/repositories/snapshots'
-		}
-	}
 }
 
 tasks.withType( GroovyCompile ) {

tooling/metamodel-generator/hibernate-jpamodelgen.gradle

@@ -18,19 +18,17 @@ ext {
 }
 
 dependencies {
+    implementation libraries.jaxb_api
+    implementation libraries.jaxb_runtime
 
-    // JAXB
+    xjc libraries.jaxb_runtime
-    compile( libraries.jaxb_api )
+    xjc libraries.jaxb_xjc
-    compile( libraries.jaxb_runtime )
+    xjc libraries.jaxb2_basics
-    xjc( libraries.jaxb_runtime )
+    xjc libraries.jaxb2_basics_ant
-    xjc( libraries.jaxb_xjc )
+    xjc libraries.activation
-    xjc( libraries.jaxb2_basics )
-    xjc( libraries.jaxb2_basics_ant )
-    xjc( libraries.activation )
 
-    testCompile libraries.junit
+    testImplementation project( ':hibernate-core' )
-    testCompile libraries.jpa
+    testImplementation libraries.junit
-    testCompile project( ':hibernate-core' )
 }
 
 sourceSets.main {