Scala Language
Werken met Gradle

Basic Setup

1. Maak een bestand met de naam SCALA_PROJECT/build.gradle met deze inhoud:

   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. Voer gradle tasks om beschikbare taken te zien.

3. Voer gradle create-dirs uit om een map src/scala, src/resources .

4. Voer gradle build uit om het project te bouwen en afhankelijkheden te downloaden.

Maak uw eigen Gradle Scala-plug-in

Na het Basic Setup- voorbeeld te hebben doorlopen, kan het zijn dat je het grootste deel ervan in elk Scala Gradle-project herhaalt. Ruikt naar boilerplate code ...

Wat als u, in plaats van de Scala-plug-in die door Gradle wordt aangeboden, uw eigen Scala-plug-in zou kunnen toepassen, die verantwoordelijk zou zijn voor de afhandeling van al uw gemeenschappelijke buildlogica, en tegelijkertijd de reeds bestaande plug-in uitbreidt.

Dit voorbeeld gaat de vorige buildlogica omzetten in een herbruikbare Gradle-plug-in.

Gelukkig kun je in Gradle eenvoudig aangepaste plug-ins schrijven met behulp van de Gradle-API, zoals beschreven in de documentatie . Als implementatietaal kunt u Scala zelf of zelfs Java gebruiken. De meeste voorbeelden die u in de documenten kunt vinden, zijn echter in Groovy geschreven. Als je meer codevoorbeelden nodig hebt of als je wilt begrijpen wat er achter de Scala-plug-in schuilt, kun je de gradle github repo bekijken .

De plug-in schrijven

De aangepaste plug-in voegt de volgende functionaliteit toe wanneer toegepast op een project:

• een scalaVersion eigenschapobject, dat twee overschrijfbare standaardeigenschappen zal hebben
  • major = "2.12"
  • minor = "0"
• een withScalaVersion functie, die van toepassing was op een afhankelijkheidsnaam, zal de scala major-versie toevoegen om binaire compatibiliteit te garanderen (sbt %% -operator kan een belletje rinkelen, anders gaat u hierheen voordat u verder gaat)
• een createDirs taak om de benodigde directorystructuur te maken, precies zoals in het vorige voorbeeld

1. maak een nieuw gradle-project en voeg het volgende toe aan build.gradle

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

repositories {
    mavenLocal()
    mavenCentral()
}

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

Opmerkingen :

• de implementatie van de plug-in is geschreven in Scala, dus we hebben de Gradle Scala-plug-in nodig
• om de plug-in van andere projecten te gebruiken, wordt de Gradle Maven-plug-in gebruikt; dit voegt de install die wordt gebruikt voor het opslaan van de projectpot toe aan de Maven Local Repository
• compile gradleApi() voegt de gradle-api-<gradle_version>.jar aan het classpath

2. maak een nieuwe Scala-klasse voor de implementatie van de plug-in

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")
    }
}

Opmerkingen :

• om een plug-in te implementeren, breidt u gewoon de eigenschap Plugin van het type Project en overschrijft u de methode van apply
• binnen de methode Toepassen heeft u toegang tot de Project instantie waarop de plug-in wordt toegepast en kunt u deze gebruiken om buildlogica eraan toe te voegen
• deze plug-in doet niets anders dan de reeds bestaande Gradle Scala-plug-in toepassen

3. voeg de scalaVersion eigenschap scalaVersion

Ten eerste maken we een ScalaVersion klasse, die de twee versie-eigenschappen bevat

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

Een cool ding van Gradle-plug-ins is het feit dat je altijd specifieke eigenschappen kunt toevoegen of negeren. Een plug-in ontvangt dit soort gebruikersinvoer via de ExtensionContainer gekoppeld aan een gradle Project instantie. Voor meer informatie, check deze uit.
Door het volgende toe te voegen aan de methode apply , doen we dit in principe:

• als er geen eigenschap scalaVersion in het project is gedefinieerd, voegen we er een toe met de standaardwaarden
• anders krijgen we de bestaande als exemplaar van ScalaVersion , om het verder te gebruiken

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]

Dit komt overeen met het schrijven van het volgende naar het buildbestand van het project dat de plug-in toepast:

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

}

4. voeg de scala-lang bibliotheek toe aan de projectafhankelijkheden, met behulp van de scalaVersion

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

Dit komt overeen met het schrijven van het volgende naar het buildbestand van het project dat de plug-in toepast:

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

5. voeg de withScalaVersion functie toe

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. Maak ten slotte de taak createDirs en voeg deze toe aan het project
   Implementeer een Gradle-taak door DefaultTask breiden:

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())
    }
  }
}

Opmerking : de SourceSetContainer heeft informatie over alle SourceSetContainer aanwezig zijn in het project. Wat de Gradle Scala-plug-in doet, is de extra bronsets toevoegen aan de Java-sets, zoals u kunt zien in de documenten van de plug-in .

Voeg de createDir taak toe aan het project door deze toe te voegen aan de methode apply :

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

Uiteindelijk zou je ScalaCustomPlugin klasse er zo uit moeten zien:

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])
  }
}

Dit wordt heel eenvoudig gedaan door gradle install
U kunt de installatie controleren door naar de lokale repository-map te gaan, meestal te vinden op ~/.m2/repository

Elke Gradle-plug-in heeft een id die wordt gebruikt in de instructie apply . Door bijvoorbeeld het volgende naar het buildbestand te schrijven, vertaalt dit zich in een trigger naar Gradle om de plug-in met id scala te vinden en toe te passen.

apply plugin: 'scala'

Op dezelfde manier willen we onze nieuwe plug-in op de volgende manier toepassen,

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

wat betekent dat onze plug-in het ID com.btesila.scala.plugin .

Voeg het volgende bestand toe om deze id in te stellen:
src / main / resources / META-INF / gradle-plug / com.btesil.scala.plugin.properties

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

Voer daarna de gradle install opnieuw gradle install .

De plug-in gebruiken

1. maak een nieuw leeg Gradle-project en voeg het volgende toe aan het buildbestand

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. voer gradle createDirs - u zou nu alle gegenereerde gradle createDirs moeten hebben
3. overschrijf de scala-versie door dit toe te voegen aan het buildbestand:

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

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

4. voeg een afhankelijkheidsbibliotheek toe die binair compatibel is met de Scala-versie

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

Dat is het! U kunt deze plug-in nu in al uw projecten gebruiken zonder dezelfde oude boilerplate te herhalen.