Scala Language
Travailler avec Gradle

Configuration de base

1. Créez un fichier nommé SCALA_PROJECT/build.gradle avec ces contenus:

   group 'scala_gradle'
   version '1.0-SNAPSHOT'
   
   apply plugin: 'scala'
   
   repositories {
       jcenter()
       mavenCentral()
       maven {
           url "https://repo.typesafe.com/typesafe/maven-releases"
       }
   }
   
   dependencies {
       compile group: 'org.scala-lang', name: 'scala-library', version: '2.10.6'
   }
   
   
   task  "create-dirs" << {
       sourceSets*.scala.srcDirs*.each { it.mkdirs() }
       sourceSets*.resources.srcDirs*.each { it.mkdirs() }
   }
   
   

2. Exécuter des gradle tasks pour voir les tâches disponibles.

3. Exécutez gradle create-dirs pour créer un répertoire src/scala, src/resources .

4. Exécutez gradle build pour générer le projet et télécharger les dépendances.

Créez votre propre plugin Gradle Scala

Après avoir suivi l' exemple de configuration de base , vous pouvez vous retrouver à répéter la plupart de ces tâches dans chaque projet Scala Gradle. Ça sent le code passe-partout ...

Et si, au lieu d'appliquer le plug-in Scala proposé par Gradle, vous pouviez appliquer votre propre plug-in Scala, qui serait chargé de gérer toute votre logique de construction commune, tout en prolongeant le plug-in existant.

Cet exemple va transformer la logique de construction précédente en un plug-in Gradle réutilisable.

Heureusement, dans Gradle, vous pouvez facilement écrire des plug-ins personnalisés à l'aide de l'API Gradle, comme indiqué dans la documentation . En tant que langage d'implémentation, vous pouvez utiliser Scala lui-même ou même Java. Cependant, la plupart des exemples que vous pouvez trouver dans les documents sont écrits dans Groovy. Si vous avez besoin de plus d'échantillons de code ou si vous voulez comprendre ce qui se cache derrière le plugin Scala, par exemple, vous pouvez vérifier le repo github gradle.

Ecrire le plugin

Le plug-in personnalisé ajoutera les fonctionnalités suivantes lorsqu'il sera appliqué à un projet:

• un objet de propriété scalaVersion , qui aura deux propriétés par défaut remplaçables
  • major = "2.12"
  • minor = "0"
• une fonction withScalaVersion , qui s'applique à un nom de dépendance, ajoute la version principale de scala pour assurer la compatibilité binaire (l'opérateur sbt %% peut sonner, sinon, rendez-vous ici )
• une tâche createDirs pour créer l'arborescence de répertoires nécessaire, exactement comme dans l'exemple précédent

1. créer un nouveau projet de gradation et ajouter ce qui suit à build.gradle

apply plugin: 'scala'
apply plugin: 'maven'

repositories {
    mavenLocal()
    mavenCentral()
}

dependencies {
    compile gradleApi()
    compile "org.scala-lang:scala-library:2.12.0"
}

Notes :

• l'implémentation du plugin est écrite en Scala, nous avons donc besoin du plugin Gradle Scala
• pour utiliser le plugin d'autres projets, le plugin Gradle Maven est utilisé; Cela ajoute la tâche d' install utilisée pour enregistrer le fichier de projet dans le référentiel local Maven.
• compile gradleApi() ajoute le gradle-api-<gradle_version>.jar au classpath

2. créer une nouvelle classe Scala pour l'implémentation du plugin

package com.btesila.gradle.plugins 
 
import org.gradle.api.{Plugin, Project}  
 
class ScalaCustomPlugin extends Plugin[Project] {
    override def apply(project: Project): Unit = {
        project.getPlugins.apply("scala")
    }
}

Notes :

• pour implémenter un plugin, il suffit d'étendre le trait de type Plugin in de type Project et de remplacer la méthode d' apply
• dans la méthode apply, vous avez accès à l'instance de Project laquelle le plug-in est appliqué et vous pouvez l'utiliser pour y ajouter une logique de construction
• ce plugin ne fait qu'appliquer le plug-in Gradle Scala déjà existant

3. ajouter la propriété d'objet scalaVersion

Tout d'abord, nous créons une classe ScalaVersion , qui contiendra les deux propriétés de la version

class ScalaVersion {
  var major: String = "2.12"
  var minor: String = "0"
}

Une chose intéressante à propos des plug-ins Gradle est le fait que vous pouvez toujours ajouter ou remplacer des propriétés spécifiques. Un plug-in reçoit ce type d'entrée d'utilisateur via le ExtensionContainer attaché à une instance de Project gradle. Pour plus de détails, consultez ceci .
En ajoutant ce qui suit à la méthode apply , nous faisons essentiellement ceci:

• s'il n'y a pas de propriété scalaVersion définie dans le projet, on en ajoute une avec les valeurs par défaut
• sinon, nous obtenons l'existant comme instance de ScalaVersion , pour l'utiliser davantage

var scalaVersion = new ScalaVersion
if (!project.getExtensions.getExtraProperties.has("scalaVersion"))
   project.getExtensions.getExtraProperties.set("scalaVersion", scalaVersion)
else
   scalaVersion = project.getExtensions.getExtraProperties.get("scalaVersion").asInstanceOf[ScalaVersion]

Cela équivaut à écrire ce qui suit dans le fichier de génération du projet qui applique le plug-in:

ext {
    scalaVersion.major = "2.12"
    scalaVersion.minor = "0"

}

4. ajouter la bibliothèque scala-lang aux dépendances du projet, en utilisant la version scalaVersion

project.getDependencies.add("compile", s"org.scala-lang:scala-library:${scalaVersion.major}.${scalaVersion.minor}")

Cela équivaut à écrire ce qui suit dans le fichier de génération du projet qui applique le plug-in:

compile "org.scala-lang:scala-library:2.12.0"

5. ajouter la fonction withScalaVersion

val withScalaVersion = (lib: String) => {
    val libComp = lib.split(":")
    libComp.update(1, s"${libComp(1)}_${scalaVersion.major}")
    libComp.mkString(":")
}
project.getExtensions.getExtraProperties.set("withScalaVersion", withScalaVersion)

6. Enfin, créez la tâche createDirs et ajoutez-la au projet
   Implémentez une tâche Gradle en étendant DefaultTask :

class CreateDirs extends DefaultTask {
  @TaskAction
  def createDirs(): Unit = {
    val sourceSetContainer = this.getProject.getConvention.getPlugin(classOf[JavaPluginConvention]).getSourceSets

    sourceSetContainer forEach { sourceSet =>
      sourceSet.getAllSource.getSrcDirs.forEach(file => if (!file.getName.contains("java")) file.mkdirs())
    }
  }
}

Remarque : le SourceSetContainer contient des informations sur tous les répertoires sources présents dans le projet. Ce que fait le plug- in Gradle Scala, c'est d'ajouter les jeux de sources supplémentaires aux jeux Java, comme vous pouvez le voir dans les docs du plug - in .

Ajoutez la tâche createDir au projet en ajoutant ceci à la méthode apply :

project.getTasks.create("createDirs", classOf[CreateDirs])

Au final, votre classe ScalaCustomPlugin devrait ressembler à ceci:

class ScalaCustomPlugin extends Plugin[Project] {
  override def apply(project: Project): Unit = {
    project.getPlugins.apply("scala")

    var scalaVersion = new ScalaVersion
    if (!project.getExtensions.getExtraProperties.has("scalaVersion"))
      project.getExtensions.getExtraProperties.set("scalaVersion", scalaVersion)
    else
      scalaVersion = project.getExtensions.getExtraProperties.get("scalaVersion").asInstanceOf[ScalaVersion]

    project.getDependencies.add("compile", s"org.scala-lang:scala-library:${scalaVersion.major}.${scalaVersion.minor}")

    val withScalaVersion = (lib: String) => {
      val libComp = lib.split(":")
      libComp.update(1, s"${libComp(1)}_${scalaVersion.major}")
      libComp.mkString(":")
    }
    project.getExtensions.getExtraProperties.set("withScalaVersion", withScalaVersion)

    project.getTasks.create("createDirs", classOf[CreateDirs])
  }
}

Cela se fait très facilement en exécutant gradle install
Vous pouvez vérifier l'installation en allant dans le répertoire du référentiel local, généralement situé dans le ~/.m2/repository

Chaque plugin Gradle a un id qui est utilisé dans l'instruction apply . Par exemple, en écrivant ce qui suit dans le fichier de compilation, cela se traduit par un déclencheur pour trouver et appliquer le plug-in avec id scala .

apply plugin: 'scala'

De même, nous aimerions appliquer notre nouveau plugin de la manière suivante,

apply plugin: "com.btesila.scala.plugin"

ce qui signifie que notre plugin aura l'identifiant com.btesila.scala.plugin .

Pour définir cet identifiant, ajoutez le fichier suivant:
src / main / resources / META-INF / gradle-plugin / com.btesil.scala.plugin.properties

implementation-class=com.btesila.gradle.plugins.ScalaCustomPlugin

Ensuite, gradle install .

Utiliser le plugin

1. créer un nouveau projet Gradle vide et ajouter les éléments suivants au fichier de construction

buildscript {
    repositories {
        mavenLocal()
        mavenCentral()
    }

    dependencies {
        //modify this path to match the installed plugin project in your local repository
        classpath 'com.btesila:working-with-gradle:1.0-SNAPSHOT'
    }
}

repositories {
    mavenLocal()
    mavenCentral()
}


apply plugin: "com.btesila.scala.plugin"

2. run gradle createDirs - vous devriez maintenant avoir tous les répertoires source générés
3. remplacer la version de la scala en l'ajoutant au fichier de construction:

ext {
    scalaVersion.major = "2.11"
    scalaVersion.minor = "8"

}
println(project.ext.scalaVersion.major)
println(project.ext.scalaVersion.minor)

4. ajouter une bibliothèque de dépendances compatible binaire avec la version Scala

dependencies {
    compile withScalaVersion("com.typesafe.scala-logging:scala-logging:3.5.0")
}

C'est tout! Vous pouvez maintenant utiliser ce plug-in pour tous vos projets sans répéter le même ancien modèle.