Zarządzanie zależnościami projektu za pomocą Gradle i IntelliJ

Question

Chciałbym użyć Gradle do zbudowania mojego projektu opartego na Groovy/Grails, dla którego używamy IntelliJ Idea jako IDE.

Używam wersji IntelliJ 11.1.4, Gradle w wersji 1.2.

Mój projekt jest skonfigurowany jako kompilacja wielu projektów z różnymi podprojektami Grails.

Miałam nadzieję, że to daje mi ten sam rodzaj wsparcia IDE, że chciałbym dostać jeśli zarządzający kompilacji przez Maven, takich jak:

• Automatyczne zarządzanie zależność (import nowych zależności do IntelliJ po dodaniu do różne build.gradle)
• budować poparcie DSL
• Realizacja zadań kompilacji
• Korzystanie z bazowego systemu kompilacji (Gradle) IDE kiedy wykonujących buduje \

Zaimportowałem mój projekt do IntelliJ, otwierając plik root build.gradle.

Dotychczas idę przeciwko kilku irytujących problemów:

1. IntelliJ nie rozpoznaje (lub uznając losowo) zmiany w zależnościach w build.gradle plików i dlatego zależności nie są aktualizowane.
2. Wtyczka "idea" gradle nie działa z projektami wielomodułowymi.

W jaki sposób ludzie pracują z Gradle w IntelliJ? Czy zarządzasz zależnościami ręcznie w IntelliJ?

Answer 1

Używam plugin Gradle od pewnego czasu i działa bardzo dobrze. Ponieważ wtyczka "idea" po prostu generuje pliki konfiguracyjne projektu IntelliJ, jest nieco ograniczona pod względem tego, co można z nią zrobić, ale mimo to odniosłem z nim więcej sukcesów w porównaniu ze wsparciem IntelliJ gradle (sprawa JetGradle).

Wtyczka "idea" Gradle działa z projektami wielomodułowymi, nigdy nie miał z tym problemu. Zawsze umieszczam nadrzędną konfigurację projektu w folderze master (patrz Initialization chapter), która wydaje się działać. Nigdy jednak nie próbowałem zagnieżdżonej struktury.

W tym celu dodatkowej konfiguracji IntelliJ można zrobić kilka .ipr i .iml majstrować z Gradle lub alternatywnie spróbować użyć jednego z my plugins (patrz Utilities wtyczki), który zrobi większość majstrować dla Ciebie.

Answer 2

W końcu poszedłem z sugestią rodionu powyżej i użyłem wtyczki pomysłu. Okazuje się, że nie skonfigurowałem go poprawnie za pierwszym razem, gdy go wypróbowałem (zastosowałem tylko wtyczkę do projektu głównego, a nie podprojekty).

Znalazłem to dopiero po napisaniu własnego zadania, aby zaktualizować zależności dla projektu IntelliJ (w oparciu o strukturę projektu layoutu katalogu .idea). Mam zamiar użyć wtyczki, ponieważ będzie mniej konserwacji, ale tutaj jest moje rozwiązanie dla potomności iw przypadku, gdy jest użyteczne dla każdego:

ext { 
    intelliJLibraryDir = "$gradle.rootProject.rootDir/.idea/libraries" 
    userHomeDir = gradle.gradleUserHomeDir.parent 
} 


task cleanIntelliJLibraries << { 
    ant.delete (includeEmptyDirs: 'true') { 
     fileset(dir: intelliJLibraryDir, includes: '*.xml') 
    } 
} 


task createIntelliJLibraries(dependsOn: cleanIntelliJLibraries) << { 

    // The unique set of dependency artifacts across all subprojects 
    def uniqueProjectArtifacts = subprojects.collectMany { 
     if (it.configurations.compile) { 
      it.configurations.compile.resolvedConfiguration.resolvedArtifacts.findAll { 
       it.moduleVersion.id.group != "my.project" 
      } 
     } 
     else { [] } 
    }.unique() 

    // Output a library xml file for each of the dependency artifacts 
    uniqueProjectArtifacts.each { artifact -> 

     def artifactPath = artifact.file.path      
     def artifactName = artifact.moduleVersion.id.with { "$group:$name:$version" } 

     def intelliJLibraryPath = artifactPath.replace(userHomeDir, '$USER_HOME$')     
     def intelliJLibraryFileName = "Gradle__$artifactName".replace(':', '_').replace('.','_') + ".xml" 

     new File("$intelliJLibraryDir/$intelliJLibraryFileName").withWriter { writer -> 

      def dependencyXML = new MarkupBuilder(writer) 

      dependencyXML.component (name: "libraryTable") { 
       library (name: "Gradle: $artifactName") { 
        CLASSES { 
         root (url: "jar://$intelliJLibraryPath!/") 
        } 
        JAVADOC {} 
        SOURCES {} 
       } 
      } 
     } 
    }   
} 


task updateIntelliJModules(dependsOn: createIntelliJLibraries) << { 

    subprojects.each { project -> 

     def root = new XmlSlurper().parse(new File("${project.name}.iml")) 

     // Remove the existing dependencies 
     root.component.orderEntry.findAll { it.@type == "library" && it.@level == "project" }.replaceNode {} 

     // Add in the new dependencies 
     if (project.configurations.compile) { 

      project.configurations.compile.resolvedConfiguration.resolvedArtifacts.findAll { 
       it.moduleVersion.id.group != "my.project" 
      }.each { artifact -> 
       def artifactName = artifact.moduleVersion.id.with { "Gradle: $group:$name:$version" } 

       root.component.appendNode { 
        orderEntry (type: "library", exported: "", name: artifactName, level: "project") 
       } 
      } 

     } 

     def outputBuilder = new StreamingMarkupBuilder() 

     new File("${project.name}.iml").withWriter { writer -> 
      groovy.xml.XmlUtil.serialize(outputBuilder.bind{ mkp.yield root }, writer) 
     } 
    } 
}