Scala Language
Lavorare con Gradle

Impostazione di base

1. Crea un file chiamato SCALA_PROJECT/build.gradle con questi contenuti:

   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. Esegui gradle tasks per vedere le attività disponibili.

3. Esegui gradle create-dirs per creare una gradle create-dirs src/scala, src/resources .

4. Esegui gradle build per creare il progetto e scaricare le dipendenze.

Crea il tuo plugin Gradle Scala

Dopo aver esaminato l'esempio di installazione di base , potresti trovarti a ripetere la maggior parte di esso in ogni singolo progetto Scala Gradle. Odora come codice boilerplate ...

Cosa succede se, invece di applicare il plugin Scala offerto da Gradle, è possibile applicare il proprio plugin Scala, che sarebbe responsabile della gestione di tutte le logiche di build comuni, estendendo, allo stesso tempo, il plug-in già esistente.

Questo esempio trasformerà la precedente build logic in un plugin Gradle riutilizzabile.

Fortunatamente, in Gradle, puoi facilmente scrivere plug-in personalizzati con l'aiuto dell'API Gradle, come indicato nella documentazione . Come linguaggio di implementazione, puoi usare lo stesso Scala o anche Java. Tuttavia, la maggior parte degli esempi che puoi trovare in tutti i documenti sono scritti in Groovy. Se hai bisogno di più esempi di codice o vuoi capire cosa si nasconde dietro il plugin Scala, ad esempio, puoi controllare il repository gradle github .

Scrivere il plugin

Il plug-in personalizzato aggiungerà le seguenti funzionalità quando applicato a un progetto:

• un oggetto di proprietà scalaVersion , che avrà due proprietà predefinite di override
  • major = "2.12"
  • minor = "0"
• una funzione withScalaVersion , che si applica a un nome di dipendenza, aggiungerà la versione scala maggiore per garantire la compatibilità binaria (l'operatore sbt %% potrebbe suonare un campanello, altrimenti vai qui prima di procedere)
• un'attività createDirs per creare l'albero delle directory necessario, esattamente come nell'esempio precedente

1. crea un nuovo progetto gradle e aggiungi quanto segue a build.gradle

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

repositories {
    mavenLocal()
    mavenCentral()
}

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

Note :

• l'implementazione del plugin è scritta in Scala, quindi abbiamo bisogno del plugin Gradle Scala
• per utilizzare il plugin da altri progetti, viene utilizzato il plugin Gradle Maven; questo aggiunge l'attività di install utilizzata per salvare il jar del progetto nell'archivio locale Maven
• compile gradleApi() aggiunge il gradle-api-<gradle_version>.jar al classpath

2. crea una nuova classe di Scala per l'implementazione del 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")
    }
}

Note :

• per implementare un plugin, estendere semplicemente il tratto del Plugin di tipo Project e sovrascrivere il metodo apply
• all'interno del metodo apply, si ha accesso all'istanza di Project cui è applicato il plugin e si può usarlo per aggiungere la build logic ad esso
• questo plugin non fa altro che applicare il plugin Gradle Scala già esistente

3. aggiungi la proprietà dell'oggetto scalaVersion

In primo luogo, creiamo una classe ScalaVersion , che conterrà le due proprietà della versione

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

Una cosa interessante dei plugin Gradle è il fatto che puoi sempre aggiungere o sovrascrivere proprietà specifiche. Un plugin riceve questo tipo di input utente tramite ExtensionContainer collegato a un'istanza di Project gradle. Per maggiori dettagli, controlla questo .
Aggiungendo il seguente al metodo apply , stiamo praticamente facendo questo:

• se non esiste una proprietà scalaVersion definita nel progetto, ne aggiungiamo una con i valori predefiniti
• altrimenti, otteniamo quello esistente come istanza di ScalaVersion , per usarlo ulteriormente

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]

Ciò equivale a scrivere quanto segue nel file di build del progetto che applica il plugin:

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

}

4. aggiungi la libreria scala-lang alle dipendenze del progetto, usando lo scalaVersion

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

Ciò equivale a scrivere quanto segue nel file di build del progetto che applica il plugin:

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

5. aggiungere la funzione 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. infine, creare l'attività createDirs e aggiungerla al progetto
   Implementare un'attività Gradle estendendo 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())
    }
  }
}

Nota : SourceSetContainer contiene informazioni su tutte le directory di origine presenti nel progetto. Quello che fa il plugin Gradle Scala è aggiungere i set sorgente extra a quelli Java, come puoi vedere nei documenti del plugin .

Aggiungere l'attività createDir al progetto aggiungendo questo al metodo apply :

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

Alla fine, la tua classe ScalaCustomPlugin dovrebbe apparire così:

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

Questo è veramente facile eseguendo gradle install
È possibile verificare l'installazione andando nella directory del repository locale, di solito in ~/.m2/repository

Ogni plugin Gradle ha un id che viene utilizzato nell'istruzione apply . Ad esempio, scrivendo quanto segue nel file di build, si traduce in un trigger di Gradle per trovare e applicare il plug-in con id scala .

apply plugin: 'scala'

Allo stesso modo, vorremmo applicare il nostro nuovo plugin nel modo seguente,

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

il che significa che il nostro plugin avrà l'ID com.btesila.scala.plugin .

Per impostare questo ID, aggiungi il seguente file:
src / main / resources / META-INF / Gradle-plugin / com.btesil.scala.plugin.properties

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

Successivamente, esegui di nuovo gradle install .

Utilizzando il plugin

1. crea un nuovo progetto Gradle vuoto e aggiungi il seguente al file di build

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 - ora dovresti avere tutte le directory sorgente generate
3. sostituisci la versione di scala aggiungendo questo al file di build:

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

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

4. aggiungere una libreria di dipendenze compatibile con binario con la versione di Scala

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

Questo è tutto! Ora puoi usare questo plugin su tutti i tuoi progetti senza ripetere lo stesso vecchio standard.