Scala Language
Praca z Gradle

Podstawowe ustawienia

1. Utwórz plik o nazwie SCALA_PROJECT/build.gradle z następującą zawartością:

   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. Uruchom gradle tasks aby zobaczyć dostępne zadania.

3. Uruchom gradle create-dirs aby utworzyć katalog src/scala, src/resources .

4. Uruchom gradle build aby zbudować projekt i pobrać zależności.

Utwórz własną wtyczkę Gradle Scala

Po przejściu przykładu konfiguracji podstawowej może się zdarzyć, że powtórzysz większość z niego w każdym projekcie Scala Gradle. Pachnie jak kod płyty grzewczej ...

Co, jeśli zamiast zastosować wtyczkę Scala oferowaną przez Gradle, możesz zastosować własną wtyczkę Scala, która byłaby odpowiedzialna za obsługę całej wspólnej logiki kompilacji, rozszerzając jednocześnie istniejącą już wtyczkę.

Ten przykład przekształci poprzednią logikę kompilacji w wtyczkę Gradle wielokrotnego użytku.

Na szczęście w Gradle możesz łatwo pisać niestandardowe wtyczki za pomocą interfejsu API Gradle, jak opisano w dokumentacji . Jako język implementacji możesz używać samej Scali, a nawet Java. Jednak większość przykładów, które można znaleźć w całej dokumentacji, jest napisana w Groovy. Jeśli potrzebujesz więcej próbek kodu lub chcesz zrozumieć, co kryje się za wtyczką Scala, możesz na przykład sprawdzić repozytorium github .

Pisanie wtyczki

Wtyczka niestandardowa doda następującą funkcjonalność po zastosowaniu do projektu:

• obiekt właściwości scalaVersion , który będzie miał dwie nadrzędne właściwości domyślne
  • major = „2.12”
  • minor = „0”
• funkcja withScalaVersion , która zastosowała się do nazwy zależności, doda główną wersję Scala, aby zapewnić zgodność binarną (operator sbt %% może zadzwonić, w przeciwnym razie przejdź tutaj przed kontynuowaniem)
• zadanie createDirs aby utworzyć niezbędne drzewo katalogów, dokładnie tak jak w poprzednim przykładzie

1. utwórz nowy projekt gradalny i dodaj następujące do build.gradle

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

repositories {
    mavenLocal()
    mavenCentral()
}

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

Uwagi :

• implementacja wtyczki jest napisana w Scali, dlatego potrzebujemy wtyczki Gradle Scala
• w celu korzystania z wtyczki z innych projektów używana jest wtyczka Gradle Maven; dodaje to zadanie install użyte do zapisania słoika projektu w lokalnym repozytorium Maven
• compile gradleApi() dodaje gradle-api-<gradle_version>.jar do ścieżki klasy

2. utwórz nową klasę Scala dla implementacji wtyczki

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

Uwagi :

• w celu wykonania wtyczki, po prostu przedłużyć Plugin cechę typu Project i zastąpić apply metodę
• w ramach metody Apply masz dostęp do instancji Project , do której jest zastosowana wtyczka i możesz jej użyć do dodania do niej logiki kompilacji
• ta wtyczka nie robi nic poza zastosowaniem już istniejącej wtyczki Gradle Scala

3. dodaj scalaVersion obiektu scalaVersion

Po pierwsze tworzymy klasę ScalaVersion , która będzie przechowywać dwie właściwości wersji

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

Jedną fajną rzeczą w wtyczkach Gradle jest to, że zawsze możesz dodawać lub zastępować określone właściwości. Wtyczka otrzymuje tego rodzaju wprowadzanych przez użytkownika za pośrednictwem ExtensionContainer dołączony do Gradle Project instancji. Aby uzyskać więcej informacji, sprawdź to .
Przez dodanie następujących do apply metody, jesteśmy w zasadzie to robi:

• jeśli w projekcie nie zdefiniowano właściwości scalaVersion , dodajemy ją z wartościami domyślnymi
• w przeciwnym razie otrzymamy istniejącą jako instancję ScalaVersion , aby użyć jej dalej

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]

Jest to równoważne z zapisaniem następującego pliku kompilacji projektu, który stosuje wtyczkę:

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

}

4. dodaj bibliotekę scala-lang do zależności projektu, używając scalaVersion

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

Jest to równoważne z zapisaniem następującego pliku kompilacji projektu, który stosuje wtyczkę:

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

5. dodaj funkcję 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. na koniec utwórz zadanie createDirs i dodaj je do projektu
   Zaimplementuj zadanie Gradle, rozszerzając 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())
    }
  }
}

Uwaga : SourceSetContainer zawiera informacje o wszystkich katalogach źródłowych obecnych w projekcie. Tym, co robi wtyczka Gradle Scala, jest dodawanie dodatkowych zestawów źródłowych do zestawów Java, jak widać w dokumentacji wtyczek .

Dodaj createDir zadanie projektu, dołączając do tego apply metody:

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

Ostatecznie klasa ScalaCustomPlugin powinna wyglądać następująco:

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

Można to zrobić naprawdę łatwo, uruchamiając gradle install
Możesz sprawdzić instalację, przechodząc do lokalnego katalogu repozytorium, zwykle znajdującego się w ~/.m2/repository

Każdy plugin Gradle ma id , który jest używany w apply oświadczenia. Na przykład, pisząc następujące polecenie w pliku kompilacji, tłumaczy on wyzwalacz na Gradle, aby znaleźć i zastosować wtyczkę z id scala .

apply plugin: 'scala'

W ten sam sposób chcielibyśmy zastosować naszą nową wtyczkę w następujący sposób:

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

co oznacza, że nasza wtyczka będzie miała identyfikator com.btesila.scala.plugin .

Aby ustawić ten identyfikator, dodaj następujący plik:
src / main / resources / META-INF / gradle-plugin / com.btesil.scala.plugin.properties

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

Następnie uruchom ponownie gradle install .

Korzystanie z wtyczki

1. utwórz nowy pusty projekt Gradle i dodaj następujące elementy do pliku kompilacji

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. uruchom gradle createDirs - powinieneś teraz wygenerować wszystkie katalogi źródłowe
3. przesłonić wersję Scala, dodając to do pliku kompilacji:

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

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

4. dodaj bibliotekę zależności, która jest binarnie zgodna z wersją Scala

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

Otóż to! Teraz możesz używać tej wtyczki we wszystkich swoich projektach bez powtarzania tej samej starej płyty.