See https://github.com/JetBrains/gradle-idea-ext-plugin/wiki/Change-log-DSL-v0.2#gradle-tasks-triggers-settings

I have configured a test project to do this: https://github.com/nddipiazza/test-intellij-gradle-plugin

Git clone and import this project as a gradle project. Notice that the taskTriggers do nothing.

Tested with:

IntelliJ IDEA 2017.3.5 (Community Edition)
Build #IC-173.4674.33, built on March 5, 2018
JRE: 1.8.0_152-release-1024-b15 amd64
JVM: OpenJDK 64-Bit Server VM by JetBrains s.r.o
Linux 4.15.0-32-generic

and

IntelliJ IDEA 2018.1.6 (Community Edition)
Build #IC-181.5540.7, built on July 11, 2018
JRE: 1.8.0_152-release-1136-b39 amd64
JVM: OpenJDK 64-Bit Server VM by JetBrains s.r.o
Linux 4.15.0-30-generic

and

IntelliJ IDEA 2018.2.1 (Community Edition)
Build #IC-182.3911.36, built on August 6, 2018
JRE: 1.8.0_152-release-1248-b8 amd64
JVM: OpenJDK 64-Bit Server VM by JetBrains s.r.o
Linux 4.15.0-30-generic

Does not work on any of these environments.

Having a difficult time configuring the runConfiguration DSL task in Kotlin. Only example I could find was in the Gradle Kotlin DSL project. Are there any plans to provide further documentation for this? @eskatos

Please add support for ArtifactManager. Use case is building Kotlin project using JPS. This elements is required for project:

• directory
• archive
• module-output
• file-copy
• dir-copy
• library
• extracted-dir.

Currently this is generated using external tool called pill based on gradle copy tasks definition: https://github.com/JetBrains/kotlin/blob/master/buildSrc/src/main/kotlin/pill/kotlinPluginArtifact.kt.

It would be super cool if this will be supported through "native" Idea Gradle Import.

The Artifacts DSL example in the wiki doesn't work; it gives me this error:

Could not find method settings() for arguments [build_4z8uydoahxkv32xgrlo47x8ut$_run_closure6@6e62c97c] on object of type org.gradle.plugins.ide.idea.model.IdeaProject.

The configured task triggers are not shown in the Gradle tab in IDEA, when configured with the gradle-idea-ext-plugin. When configured manually by right click on a task and select a phase, it will be shown within braces:

I guess this needs to be fixed in IDEA itself, as the plugin properly sets the task triggers. But as this is a proof of concept plugin, I created the issue here.

Just like we can do it for Java and Groovy today using:

idea {
    project {
        settings {
            codeStyle {
                java {
                    forForceBraces = FORCE_BRACES_ALWAYS
                }
                groovy {
                    forForceBraces = FORCE_BRACES_ALWAYS
                }
            }
        }
    }
}

it would be great to be able to configure Kotlin formatting, e.g.:

idea {
    project {
        settings {
            codeStyle {
                kotlin {
                    forForceBraces = FORCE_BRACES_ALWAYS
                    // applicable options
                }
            }
        }
    }
}

What we have internally now is a Gradle plugin that uses Miniconda to generate Python environments in a multi-project Gradle build. Right now, we:

1. Run the Gradle tasksto generate the environment
2. Add an SDK pointing to that environment
3. Add the Python facet to the correct module from the previous project import

It would be awesome if we could use this plugin to apply those changes programmatically on import/refresh/any changes to any of the Gradle projects.

Another thing I manually automate via XML wrangling is data source creation. It'd be swell to be able to define 'em in the DSL instead. 👍

There is a couple of settings that configures which charset should be used:

But the plugin doesn't provide an ability that enables to configure these encoding settings at the moment.

Environment:

• IJ IDEA CE 2018.1.6
• Plugin version: 0.2

Desirable configuration:

buildscript {
    repositories {
        maven {
            url "https://plugins.gradle.org/m2/"
        }
    }
    dependencies {
        classpath group: 'gradle.plugin.org.jetbrains.gradle.plugin.idea-ext', name: 'gradle-idea-ext', version: 0.2
    }
}

apply(plugin: 'org.jetbrains.gradle.plugin.idea-ext')

idea.project.settings {
    delegateActions {
        delegateBuildRunToGradle = true
        testRunner = 'GRADLE'
    }
}

But no effect found

Test project:

builddelegation.zip

What's the right syntax to apply settings with Kotlin DSL?
I tried this, but settings is not resolved:

idea {
    project{
        settings{
        }
    }
}

Things don't seem to work correctly unless you apply the plugin directly in the main build file.

I prefer to keep IDE related stuff in a separate .gradle file that is applied, something like:

apply from: 'gradle/idea.gradle'

I thought I was hitting an old bug because when I did that I got errors like:
Cannot create a Application because this type is not known to this container. Known types are: Application, JUnit, Remote

If instead of the plugin syntax you use something like this in the applied build file:

buildscript{
	repositories{
		maven{
			url "https://plugins.gradle.org/m2/"
		}
	}
	dependencies{
		classpath "gradle.plugin.org.jetbrains.gradle.plugin.idea-ext:gradle-idea-ext:0.4.2"
	}
}

apply plugin: 'idea'
apply plugin: org.jetbrains.gradle.ext.IdeaExtPlugin

It won't throw errors.

Cannot create a Application because this type is not known to this container. Known types are: Application, JUnit, Remote

Error generated by the following file:

plugins {
    id "org.jetbrains.gradle.plugin.idea-ext" version "0.1"
}

idea {
    project {
        settings {

            runConfigurations {
                "MyApp"(Application) {                       // Create new run configuration "MyApp" that will run class foo.App
                    mainClass = 'foo.App'
                    moduleName = getProject().idea.module.name
                }
            }

            copyright { }
            // other project level settings
        }
    }
}

Update the version in your readme.md

right now it reads 0.2

latest version is 0.4.1

I don't like Idea detecting web facet from the build, so I'm trying to get rid of it with the plugin.
Here's the trivial build I'm doing my tests on: https://github.com/jk1/idea-ext-plugin-test

1. I have tried to apply the plugin to the root project
2. In idea removed web facet and artifacts
3. Run gradle sync from Idea
4. Facet and artifacts reappeared

Also tried to apply the plugin to the web subproject directly. Upon gradle project refresh it just fails with an exception.

So, what's the proper way of going it?

We have multiple branches where each branch wants to be built and tested against a different JDK.

We currently deal with this by having the Gradle wrapper set the path to the right JDK before starting up. It would be nice if we could somehow have our build either specify the right JDK to use programmatically, or for IDEA to automatically pick up the same JDK that Gradle is building with.

The language level itself doesn't work because sometimes both JDKs are the same language level (as is the case for us right now.)

I'd like to see #com.intellij.j2ee.web.tomcat.TomcatRunConfigurationFactory and TestNG options since that's what I'm working with right now. 😃

I think for the Tomcat stuff we'll probably need the JEE facet and artifact bits?

Is adding things like this just a matter of tweaking this plugin, or does stuff need to be done inside IDEA as well? Could one just slap in a class TestNG extends BaseRunConfiguration type deal and have things work?

Something we had working with gradle idea but lost when moving to IDEA to import the project was that we were setting the location of XML annotation files for all the libraries into a directory in the project.

    withXml { provider ->
      def node = provider.asNode()
      def libraries = node.component.orderEntry.each { orderEntry ->
        if (orderEntry.attribute('type') == 'module-library') {
          orderEntry.library.each { library ->
            library.children().add(0, new Node(null, 'ANNOTATIONS', [:], [new Node(null, 'root', [url: 'file://$PROJECT_DIR$/.idea/annotations'])]))
          }
        }
      }
    }

This avoids the hassle of having to re-specify the annotation directory every time you try to use one of the actions in IDEA which adds an annotation to a third-party method.

I don't know what makes the most sense, programmatically hacking at the XML of the module file, or having a specific API for just this one thing.

If you use Gradle to generate the module files, you can control where they are stored by setting idea.module.iml.generateTo to the directory you want the file to be stored in. If the extended DSL this plugin brings to the table picked up on that setting, it would be even more nifty.

Storing project metadata in a custom location is I think the highest voted, longest running issue for IDEA, and it seems to me that this Gradle stuff has the most potential for an implementation that could eventually be used to close that issue.

Ideally it would be great to be able to set the main project configuration directory, but there's already some stuff on the IDEA side for configuring the modules configuration location ("Store generated project files externally"), so I thought it might be the lowest hanging fruit and a good place to start. Next could be the workspace metadata file maybe (also already modeled in the existing Gradle DSL), but being able to control the .idea path would make that kind of moot.

Just something to think about-- I really dig being able to express agnostic IDE settings in gradle files (no machine-specific paths, thus can be committed to the same VCS repo as the code, if so desired, unlike the current project metadata)... it's clear that before long we'll be able to ignore the .idea folder (lots of "churn" currently) and yet still configure the things we'd like automatically configured for other developers using IDEA-- without the need for hokey file copying or XML manhandling.

I'll lay off the issues for a bit, and apologies for creating so many. I do think this stuff has the potential to make the IDE better in ways not even specific to Gradle though, and I'm a fan of solutions that solve multiple problems (to avoid the bird killing analogy 😃 ) so keep up the good work!

To configure the same code styles we configure now in the gradle/gradle build, there are still some configurations missing. Compare https://github.com/gradle/gradle/blob/5fee26b5895389e7fc9c6d3c6e3a87d79eca45c4/buildSrc/subprojects/ide/src/main/kotlin/org/gradle/gradlebuild/ide/IdePlugin.kt#L590-L637 vs https://github.com/gradle/gradle/blob/5fee26b5895389e7fc9c6d3c6e3a87d79eca45c4/buildSrc/subprojects/ide/src/main/kotlin/org/gradle/gradlebuild/ide/IdePlugin.kt#L641-L668

I think the following is still missing:

General:

• set the line separator (not super important, but I think we should be able to set this to \n) Let's use .editorconfig for this.
• enable formatter tags
• what is the replacement for USE_SAME_INDENTS?

Java/Groovy

• Names count to use static import with *

What about Kotlin? How can we set some code styles for Kotlin?

I'd like to customize Intellij module type. Is it something, that's currently possible to achieve with the plugin?

We want our .iml files to live under .idea/modules, but right now that doesn't seem possible to achieve through the plugin, am I correct @nskvortsov?

Copyright settings are not delivered to Idea

Versions

org.jetbrains.gradle.plugin.idea-ext 0.2
IntelliJ IDEA 2018.3 EAP (Ultimate Edition)
Build #IU-183.156, built on June 19, 2018
JRE: 1.8.0_152-release-1282-b2 x86_64
JVM: OpenJDK 64-Bit Server VM by JetBrains s.r.o
macOS 10.13.5

Steps to reproduce

configure idea plugin as follows:

task example {
    doFirst {
        println 'EXAMPLE'
    }
}

idea {
    project {
        settings {
            runConfigurations {
                'App'(Application) {
                    ...
                    beforeRun {
                        'beforeApp'(GradleTask) {
                            task = example
                        }
                    }
                }
            }
        }
    }
}

Problems

With default projectPath : App fails with following error:

The newly created daemon process has a different context than expected.
It won't be possible to reconnect to this daemon. Context mismatch: 
Java home is different.
...

Problem is gone when Gradle project for example selected manually in Before launch menu.
Resulting run configuration in xml:

...
<!--works-->
<option name="Gradle.BeforeRunTask" enabled="true" tasks="example" externalProjectPath="$PROJECT_DIR$" />
<!--fails-->
<option name="Gradle.BeforeRunTask" enabled="true" tasks="example" externalProjectPath=":" />
...

Can we get access to workspace settings by their identifiers?
This way one could customise almost any 3rd party plugin! 🙏

Example issue

When compiling an Android project (right after import) in the IDE, with Gradle 4.6+, one gets the following failure:

Executing tasks: [:android:generateDebugSources, :android:generateDebugAndroidTestSources, :android:mockableAndroidJar]

Configuration on demand is an incubating feature.

FAILURE: Build failed with an exception.

...

* What went wrong:
An exception occurred applying plugin request [id: 'com.android.library']
> Failed to apply plugin [id 'com.android.library']
   > Configuration on demand is not supported by the current version of the Android Gradle plugin since you are using Gradle version 4.6 or above. Suggestion: disable configuration on demand by setting org.gradle.configureondemand=false in your gradle.properties file or use a Gradle version less than 4.6.

...

Despite what the error message says, the only way to fix it is to uncheck Configure on demand in the settings:

which adds the following to .idea/workspace.xml:

<component name="AndroidGradleBuildConfiguration">
  <option name="USE_CONFIGURATION_ON_DEMAND" value="false" />
</component>

Note that compiling directly from Gradle always works, this is an IDE-specific issue!

Any project which has generated sources, if imported directly into IDEA, isn't going to compile until someone manually runs the generateSources task.

Is there a way with this plugin to specify a series of tasks which must be run as part of the import process?

Can I add runConfigurations from a task triggered by taskTrigger?

I have a bunch of setup necessary (done in a task) to figure out what runConfigurations to add and I've tried something along the lines of this (without success):

project.getRootProject().getPluginManager().withPlugin("org.jetbrains.gradle.plugin.idea-ext", {
    project.tasks.findByName(TASK_PARSE_CONFIGURATION).doLast {
        project.getRootProject().idea.project.settings.runConfigurations {
            "After"(Application) {
                mainClass = 'foo.App'
            }
        }
    }

    project.getRootProject().idea.project.settings.taskTriggers {
        afterSync project.tasks.getByName(TASK_PARSE_CONFIGURATION)
    }

For example, in IDEA I can specify that I want the IDE to execute a certain Gradle task when the project is built, when it is synchronized, etc.

As a concrete use case, in the Hibernate build we have a task that synchronizes the IDEA test resources folder from the Gradle test resources file. And every time the project is imported the developer has to go into each sub-project in the "Gradle tree" and enable this task to be executed "After build". It would be nice to tell IntelliJ to do this when the project is imported.

Not quite sure what kind of description would be the best. We can either use inspection class names or inspection text names.

I tried to set up a run configuration to be automatically created:

idea {
  project {
    settings {
      runConfigurations {

        'Desktop Test'(Application) {
          mainClass = 'com.acme.main.DesktopMain'
          moduleName = getProject(':main').idea.module.name
          workingDirectory = rootDir
          jvmArgs = '...'
          envs = ext.environmentVars
        }

      }
    }
  }
}

But when I try to sync the project, I get a confusing error message:

Cannot create a Application because this type is not known to this container. Known types are: Application, JUnit, Remote

Versions

org.jetbrains.gradle.plugin.idea-ext 0.2
IntelliJ IDEA 2018.3 EAP (Ultimate Edition)
Build #IU-183.156, built on June 19, 2018
JRE: 1.8.0_152-release-1282-b2 x86_64
JVM: OpenJDK 64-Bit Server VM by JetBrains s.r.o
macOS 10.13.5

Steps to reproduce

• configure idea plugin as follows:

task example {
    doFirst {
        println 'EXAMPLE'
    }
}

idea {
    project {
        settings {
            taskTriggers {
                beforeBuild example
            }
        }
    }
}

• rename example to some another name

Problem

workspace.xml still contains example:

...
<component name="ExternalProjectsManager">
    <system id="GRADLE">
      <state>
        <task path="$PROJECT_DIR$">
          <activation>
            <before_compile>
              <task name=":example" />
...

which results in error:

FAILURE: Build failed with an exception.

* What went wrong:
Task 'example' not found in root project ...

e.g., use compiler from module target JDK when possible

I'd like to request that support for configuring WebSphere Server Run Configurations is added as a future enhancement. This would include the ability to add Local and Remote Configuration.

When importing a Gradle build into IntelliJ IDEA, one can use "one module per source set" (the default) or "one module per project".

Some builds out there work only in one of these modes. Moreover, some settings might need to be different depending on the used mode (e.g. output paths are different and might be used in run configurations settings).

It would be great if the build could decide what mode to use when importing.

During build import, the choice is currently made before starting to import so I suppose it may not be a trivial change.

Versions

org.jetbrains.gradle.plugin.idea-ext 0.2
IntelliJ IDEA 2018.3 EAP (Ultimate Edition)
Build #IU-183.156, built on June 19, 2018
JRE: 1.8.0_152-release-1282-b2 x86_64
JVM: OpenJDK 64-Bit Server VM by JetBrains s.r.o
macOS 10.13.5

Steps to reproduce

• configure idea plugin as follows:

task example {
    doFirst {
        println 'EXAMPLE'
    }
}

idea {
    project {
        settings {
            runConfigurations {
                'App'(Application) {
                    ...
                    beforeRun {
                        'beforeApp'(GradleTask) {
                            task = example
                        }
                    }
                }
            }
        }
    }
}

• refresh Gradle projects a few times

Problems

• App run configuration contains many duplicated entries in Before launch.
• If example was renamed then old name also remains there, possibly related to #14

Currently file templates and live templates are stored in the user settings on a machine and are globally visible. Almost every template I have ever written was specific to a project, it would be great if I could check in an xml file to the repo and point at it with this plugin DSL

A step two would be the ability to package these configurations in a jar for distribution with library projects.

Publishing/distributing templates and structural search replace configurations could be used as a way to automate/ease breaking change migrations.

I made a similar request to google for android studio and the AAR package format. this could potentially invalidate that request. https://issuetracker.google.com/issues/37127571

In a Kotlin project, I'm trying out the example with IntelliJ 2018.3, but on Gradle sync I'm getting Cannot invoke method settings() on null object. Any idea why idea.project is null? I also tried wrapping it in afterEvaluate without any luck.

to RunConfigurationsContainer
This will avoid extra casts when using defaults block in Kotlin-based DSL

Currently the task triggers
https://github.com/JetBrains/gradle-idea-ext-plugin/wiki/Change-log-DSL-v0.2#gradle-tasks-triggers-settings are defined by passing a Task instance. Changing that to be an absolute task name as String simplifies the configuration of these task triggers.

Instead of

    idea.project.settings.taskTriggers {
        afterSync tasks.getByName('afterSyncTask')
    }

it should be

    idea.project.settings.taskTriggers {
        afterSync ':afterSyncTask'
    }

Please add support for UnloadedModulesList.

Use case: building Kotlin project with JPS without stdlib.

I'm running IDEA 2018.2.4. In our build, we have:

gradle.taskGraph.whenReady {
  idea.project.settings.taskTriggers {
    afterSync project(':some-subproject').tasks.getByName('generateGrammarSource')
  }
}

But after syncing the Gradle project, the task does not get run.

The example on the Wiki doesn't include the gradle.taskGraph.whenReady fragment, but it turns out that if you don't do that, the task doesn't exist yet, so you can't reference it. So we wait until all tasks are loaded before setting the property, but setting the property itself doesn't appear to work.

Tested for all versions (0.1, 0.2, 0.3)

Desirable configuration:

idea.project.settings.runConfigurations {
    "localhost:8080"(Remote) {
        host 'localhost'
        port 8787
    }
}

But the default port is specified in created configuration:

The issue can be reproduced with this small project:

ideaplugin.zip

requested in #11

On run configs of all types, it would be nice if we could set "Shorten command line" from the Gradle build.

At present, Windows developers have to set this manually after the project is imported, or all run configs fail for them.

The GradleTask endpoint is defined inside Application calling the specified Gradle task before launch. It would be nice to support creating Gradle run configurations directly.

I tried the following:

idea {
    project {
        settings {

            runConfigurations {
                "MyApp"(Application) {
                    mainClass = 'foo.App'
                    moduleName = "hi"
                    workingDirectory = "/home/alex"
                }
            }

            copyright { }
        }
    }
}

And I get the launcher, but my working directory is shown as /home/alex/projects/testcase

Intellij IDEA has an ability to delegate IDE build/run actions to Gradle (Build, Execution, Deployment -> Build Tools -> Gradle -> Runner).

It will be great to be able to configure this setting.

The withXml feature of the Gradle generated configs is great as it exposes the low-level stuff for folks willing to look at a bit of IDEA configuration XML. It would be awesome if the DSL could do something similar for peeps willing to look at the IDEA configuration sources.

I've looked at the plugin source but have not looked at the source on the IDE side, so I'm not sure how things have been done, or what is possible, but it would be swell if there was more of a one-to-one mapping, and an easy way to expand on what's already here. For instance I thought I might be able to extend the Facet class within my buildSrc to add some ad-hoc ones (Hibernate for instance), but I was unsuccessful with a little go at it (can't remember why offhand, but it made me abandon that approach pretty quick, whatever it was).

When I say one-to-one, I mean that the IDEA Spring configuration takes a fileset, but the DSL only supports a single file, and TestNG has the working directory but not the output directory, nor some of the other options...

Ultimately it would be good to be able to set anything that one can set in the IDEA config via the DSL, and without looking at the sources (so said famously) it seems like there should be a way to avoid a bunch of duplication, or needing to "manually" per se bridge the two. Similar to how withXml is just a communication channel to the configuration versus an implementation per se.

Without looking at the other side of the model I don't know what's possible, though from the plugin model it looks like it's just maps being passed, so maybe something generic could be done, but ¯_(ツ)_/¯.

It should be possible to enable/disable inspections by name via the idea-ext plugin. It would be nice to change the severity.

The current workaround we use is to check-in the .idea/inspectionProfiles directory.