Scala Language
Arbeta med Gradle

Grundläggande installation

1. Skapa en fil med namnet SCALA_PROJECT/build.gradle med dessa innehåll:

   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. Kör gradle tasks att se tillgängliga uppgifter.

3. Kör gradle create-dirs att skapa en src/scala, src/resources katalog.

4. Kör gradle build att bygga projektet och ladda ner beroenden.

Skapa din egen Gradle Scala-plugin

När du har gått igenom Basic Setup- exemplet kan du komma att upprepa större delen av det i varje Scala Gradle-projekt. Luktar som pannkodskod ...

Tänk om du istället för att tillämpa Scala-plugin som erbjuds av Gradle, skulle du kunna använda din egen Scala-plugin, som skulle vara ansvarig för att hantera all din gemensamma build-logik och samtidigt utöka det redan existerande plugin.

Detta exempel kommer att förvandla den tidigare bygglogiken till ett återanvändbart Gradle-plugin.

Lyckligtvis i Gradle kan du enkelt skriva anpassade plugins med hjälp av Gradle API, som beskrivs i dokumentationen . Som implementeringsspråk kan du använda själva Scala eller till och med Java. De flesta av exemplen som du hittar i dokumenten är emellertid skrivna i Groovy. Om du behöver fler kodprover eller om du vill förstå vad som ligger bakom Scala-plugin, till exempel, kan du kontrollera graden github repo .

Skriva plugin

Den anpassade plugin kommer att lägga till följande funktionalitet när den tillämpas på ett projekt:

• ett scalaVersion egenskapsobjekt, som kommer att ha två överdrivbara standardegenskaper
  • major = "2,12"
  • mindre = "0"
• en withScalaVersion funktion, som tillämpas på ett beroende-namn, kommer att lägga till den huvudsakliga versionen av scala för att säkerställa binär kompatibilitet (operatör sbt %% kan ringa en klocka, annars gå hit innan du fortsätter)
• en createDirs uppgift för att skapa det nödvändiga katalogträdet, precis som i föregående exempel

1. skapa ett nytt gradprojekt och lägg till följande i build.gradle

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

repositories {
    mavenLocal()
    mavenCentral()
}

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

Anmärkningar :

• pluginimplementeringen är skriven i Scala, därför behöver vi Gradle Scala Plugin
• för att använda plugin från andra projekt används Gradle Maven Plugin; detta lägger till install används för att spara projektburk till Maven Local Repository
• compile gradleApi() lägger till gradle-api-<gradle_version>.jar till klassvägen

2. skapa en ny Scala-klass för plugin-implementeringen

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

Anmärkningar :

• för att implementera ett plugin, utökar du bara Plugin egenskaper av typen Project och åsidosätter apply
• inom tillämpningsmetoden har du tillgång till Project som pluginprogrammet tillämpas på och du kan använda den för att lägga till bygglogik till den
• detta plugin gör ingenting annat än att tillämpa det redan existerande Gradle Scala Plugin

3. lägg till scalaVersion objekt

För det första skapar vi en ScalaVersion klass som kommer att innehålla de två versionegenskaperna

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

En cool sak med Gradle-plugins är det faktum att du alltid kan lägga till eller åsidosätta specifika egenskaper. En plugin får den här typen av användarinmatning via ExtensionContainer kopplad till en gradle Project instans. För mer information, kolla detta .
Genom att lägga till följande till apply vi i princip detta:

• om det inte finns en scalaVersion egenskap som definieras i projektet lägger vi till en med standardvärdena
• annars får vi den befintliga som förekomst av ScalaVersion , för att använda den ytterligare

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]

Detta motsvarar skrivandet av följande till byggfilen för projektet som tillämpar plugin:

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

}

4. lägg till scala-lang biblioteket till projektberoenden med scalaVersion

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

Detta motsvarar skrivandet av följande till byggfilen för projektet som tillämpar plugin:

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

5. lägg till funktionen 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. slutligen, skapa createDirs uppgiften och lägg till den i projektet
   Implementera en Gradle-uppgift genom att utöka 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())
    }
  }
}

Obs : SourceSetContainer har information om alla SourceSetContainer finns i projektet. Vad Gradle Scala Plugin gör är att lägga till de extra källuppsättningarna till Java-dem, som du kan se i plugin-dokumenten .

Lägg till createDir uppgiften till projektet genom att lägga till detta till apply :

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

I slutändan bör din ScalaCustomPlugin klass se ut så här:

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

Detta görs riktigt enkelt genom att köra gradle install
Du kan kontrollera installationen genom att gå till en lokal katalog som vanligtvis finns på ~/.m2/repository

Varje Gradle-plugin har ett id som används i apply . Till exempel, genom att skriva följande till build-filen, översätts det till en trigger till Gradle för att hitta och tillämpa plugin med id- scala .

apply plugin: 'scala'

På samma sätt vill vi använda vårt nya plugin på följande sätt,

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

vilket betyder att vår plugin kommer att ha com.btesila.scala.plugin id.

Lägg till följande fil för att ställa in denna id:
src / main / resources / META-INF / gradle-plugin / com.btesil.scala.plugin.properties

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

gradle install igen gradle install .

Använda plugin-programmet

1. skapa ett nytt tomt Gradle-projekt och lägg till följande i build-filen

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. kör gradle createDirs - du borde nu generera gradle createDirs
3. åsidosätta skala-versionen genom att lägga till den i build-filen:

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

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

4. lägg till ett beroendebibliotek som är binärt kompatibelt med Scala-versionen

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

Det är allt! Du kan nu använda det här pluginet i alla dina projekt utan att upprepa samma gamla pannplatta.