We have UTF-8 Java files containing Umlauts (ä, ö, ü, ß). While gradle spotlessApply works reliably on those files, the vscode-spotless-gradle plugin doesn't. I guess the plugin does not parse the file content as UTF-8 but uses some default encoding (we use Microsoft Windows by the way).

The extension by default will run on all languages that Spotless supports.

When running diagnostics/formatting on a supported language for which there's no configured Spotless formatter, the extension gets into an unrecoverable state with "Gradle: Tasl :spotlessApply SUCCESS" shown in the statusbar:

The first time the call fails, the status is correctly reported to the output channel and the extension is still working. The extenion hangs on the second call to spotless.

I'm trying to format Gradle files, but I have this error.

There is no formatter for 'gradle' files installed.

How do we use this extension?

I have a Gradle project that I would like to format using this extension. This is my build.gradle, with the spotless configuration at the end of the file.

When I run gradle spotlessApply outside of VSCode, Gradle is successful, and issues in the files are fixed.

When I run the spotlessApply task using the Gradle Tasks extension, it is successful and works.

When I format the document, though, the issues are not fixed. I get this notification in VSCode:

The following is logged to the Gradle Tasks output:

[info] Completed build: spotlessApply -PspotlessIdeHook=/home/koopa/Documents/Projects/Java/Robot/Robot2021/src/main/java/frc/robot/Robot.java -PspotlessIdeHookUseStdIn -PspotlessIdeHookUseStdOut --quiet

The following is logged to the Spotless Gradle output:

[info] Running spotlessApply on Robot.java
[error] Unable to apply formatting: No status received from Spotless

Some other notes:

• If this is the first time I'm formatting since reloading VSCode, the notification goes away in a second.
• When formatting for the second time, the notification does not seem to go away. It seems that the build hangs after the first attempt. When cancelling this task, the following is logged to Gradle Tasks:

[info] Cancel build: Cancel build requested
[info] Build cancelled: spotlessApply -PspotlessIdeHook=/home/koopa/Documents/Projects/Java/Robot/Robot2021/src/main/java/frc/robot/Robot.java -PspotlessIdeHookUseStdIn -PspotlessIdeHookUseStdOut --quiet: Could not execute build using Gradle distribution 'https://services.gradle.org/distributions/gradle-6.0.1-bin.zip'.

• After cancelling the second format, it's inconsistent as to whether or not it hangs.
• When manually running the command from the Gradle Tasks output, the issues in the code are not fixed.

OS: Arch Linux
Gradle Version: 6.0.1
Gradle Tasks Version: 3.5.2
Spotless Gradle Version: 1.1.3

I added a mergeability app to check for changelog changes but this breaks CI when dependabot sends dep updates. As we're using GitHub releases & release drafter we don't need to keep a separate changelog updated.

• remove the mergability app
• update CHANGELOG.md to link to the releases page

Getting this pop-up when trying to format Java files

• VS Code version: 1.81.0-insider
• Gradle version: 8.2.1
• Java version: 17.0.5
• Gradle for Java extension: v3.12.7

Spotless Settings in VS Code:

"java.format.enabled": false,
"files.trimTrailingWhitespace": false,
"spotlessGradle.diagnostics.enable": true,
"spotlessGradle.format.enable": true,
"editor.codeActionsOnSave": {
  "source.fixAll.spotlessGradle": true
},
"[java]": {
  "editor.defaultFormatter": "richardwillis.vscode-spotless-gradle"
},
"[kotlin]": {
  "editor.defaultFormatter": "richardwillis.vscode-spotless-gradle"
},
"[kotlinGradle]": {
  "editor.defaultFormatter": "richardwillis.vscode-spotless-gradle"
}

Sample Project: https://github.com/overfullstack/ds-algo
Spotless Config: https://github.com/overfullstack/ds-algo/blob/master/buildSrc/src/main/kotlin/ds-algo.root-conventions.gradle.kts#L26

spotless {
  lineEndings = PLATFORM_NATIVE
  kotlin {
    ktfmt().googleStyle()
    target("**/*.kt")
    trimTrailingWhitespace()
    endWithNewline()
    targetExclude("**/build/**", "**/.gradle/**", "**/generated/**")
  }
  kotlinGradle {
    ktfmt().googleStyle()
    target("**/*.gradle.kts")
    trimTrailingWhitespace()
    endWithNewline()
    targetExclude("**/build/**", "**/.gradle/**", "**/generated/**")
  }
  java {
    toggleOffOn()
    target("**/*.java")
    importOrder()
    removeUnusedImports()
    googleJavaFormat()
    trimTrailingWhitespace()
    indentWithSpaces(2)
    endWithNewline()
    targetExclude("**/build/**", "**/.gradle/**", "**/generated/**")
  }
  format("xml") {
    targetExclude("pom.xml")
    target("*.xml")
    eclipseWtp(XML)
  }
  format("documentation") {
    target("*.md", "*.adoc")
    trimTrailingWhitespace()
    indentWithSpaces(2)
    endWithNewline()
  }
}

This has a mix of both Kotlin and Java

• ./gradlew spotlessDiagnose --no-configuration-cache succeeds and Spotless is setup correctly as ./gradlew spotlessApply works as expected

This is evident on slow machines. When running spotless you see in the statusbar "Configure project" etc.

I just upgraded to vscode-gradle 3.7.0 to fix issue with using a local version of Gradle. However now I get the error: "Cannot activate the 'Spotless Gradle' extension because it depends on an unknown 'richardwillis.vscode-gradle' extension."

I think this should be an easy change to microsoft.vscode-gradle, but am unsure. Thank you!

EDIT: It appears that badsyntax has been working diligently on this issue to resolve it. Feel free to close out this issue once that's merged.

Dear @badsyntax ,

I configured succesfully the extension for VSCODE under WIN10 and all the configuration about spotless was already there (because working on an open source project already existing).

I've disabled the "diagnose" and set just for "formatting" on both save or format document.
There aren't issue at all and the single file will be formatted properly, but it take 2-3 seconds to run "spotlessApply".

Too slow for me; there is something that i can do to improve or something that you can do to speed up?

My guess is that it will starts gradle every time (like it not use daemon) so there is a lot of overhead before really apply spotlessApply; or maybe spotlessApply is simply slow.

I must use (cause the project is open source and cannot be changed) gradle 4.4.1, spotless plugin 3.30, JDK 1.8, GoogleJavaFormat style.

I've been using this extension for a while and due to the amount of installs I assume others have been BETA testing it. No has reported any issues, and I haven't found any issues with it, so I assume it's pretty stable and worthy of a 1.0.0 stable release. I don't see any reason for waiting any longer.

TODO:

• Bump version
• Review and update README

Don't run the task if it doesn't exist. Perhaps show a warning if it doesn't exist.

In contrast, do we need to wait for vscode-gradle to query the build before running the spotlessApply task? Probably, but worth exploring this as a potential performance improvement.

Spotless 5.2.0 added support for black (python) and clang-format (c, c++, c#, objective-c, protobuf, javascript, and java). So might want to hook into those VS Code project types as well.

Getting the following warning when publishing:

This extension consists of 147 files, out of which 116 are JavaScript files. 
For performance reasons, you should bundle your extension: https://aka.ms/vscode-bundle-extension . 
You should also exclude unnecessary files by adding them to your .vscodeignore: https://aka.ms/vscode-vscodeignore

Hello,

Thanks for this nice extension 👍

It perfectly worked last weeks but not anymore recently.

The official VS Code Gradle for Java 3.10 crashes when enabling this extension (version 1.2).

The "Refresh gradle tasks" command goes into e.getDebuggable error.

Gradle for Java output :

[info] Gradle Version: 7.3.3
[info] Deprecated Gradle features were used in this build, making it incompatible with Gradle 8.0.

You can use '--warning-mode all' to show the individual deprecation warnings and determine if they come from your own scripts or plugins.

See https://docs.gradle.org/7.3.3/userguide/command_line_interface.html#sec:command_line_warnings

CONFIGURE SUCCESSFUL in 5s
[error] Unable to refresh tasks: e.getDebuggable is not a function

Gradle tasks works fine when spotless gradle extension disabled.

Tested on Windows and Ubuntu on basic empty gradle project with minimal Java extensions without any specific settings.

Any idea ?

Hi,

I'm attempting to get this extension running for a java project. I can run spotless via CLI using gradlew spotlessApply but when I try adding the following settings
"java.format.enabled": false, "files.trimTrailingWhitespace": false, "spotlessGradle.diagnostics.enable": true, "spotlessGradle.format.enable": true, "editor.codeActionsOnSave": { "source.fixAll.spotlessGradle": true }, "[java]": { "editor.defaultFormatter": "richardwillis.vscode-spotless-gradle", },
I'm not able to see any changes after save or any sort of output in the Gradle for Java plugins output. Any recommendations?

See diffplug/spotless#1082.

While vscode-gradle matures, the public API and internals might change and break this extension. As there's no way to use the vscode extension architecture to specify dependency versions, this must be managed within the extension itself.

Create a feature to ensure compatibility between extension versions. If the versions don't match show an error message informing the user which version of vscode-gradle they need to install.

Would you mind publishing this on open-vsx.org? Gradle Tasks is already there.

I'd like to be able to show the invalid formatting within the document, similar to how other linters work in vscode, for example (TypeScript, eslint & Prettier):

This feature depends on:

• can i run spotlessCheck on individual files? can i use the same stdin/stdout mechanism?
• can i parse the output of spotlessCheck in such a way as to provide useful feedback?
  • i'd like to highlight the diff of the changes similar to the screenshot above
  • ideal data format would be: line, column, endLine, endColumn

I'll need to do this through a vscode language server.

Typical spotlessCheck output for reference:

> The following files had format violations:
      gradle-server/src/main/java/com/github/badsyntax/gradle/GradleBuildCancellation.java
          @@ -25,14 +25,12 @@
           ··}
           
           ··public·static·void·cancelBuild(String·cancellationKey)·throws·GradleCancellationException·{
          -····if·(··Strings.isNullOrEmpty(·cancellationKey))
          -········{
          -························throw·new·GradleCancellationException("No·cancellation·key·specified");
          +····if·(Strings.isNullOrEmpty(cancellationKey))·{
          +······throw·new·GradleCancellationException("No·cancellation·key·specified");
           ····}
           ····CancellationTokenSource·cancellationTokenSource·=·tokens.get(cancellationKey);
           ····if·(cancellationTokenSource·==·null)·{
           
          -
           ······throw·new·GradleCancellationException("Build·is·not·running·for·key:·"·+·cancellationKey);
           ····}·else·{
           
      gradle-server/src/main/java/com/github/badsyntax/gradle/GradleWrapper.java
          @@ -23,7 +23,7 @@
           ······if·(args.length·==·0)·{
           ········throw·new·GradleWrapperException("No·wrapper·args·supplied");
           ······}
          -······················Process·process·=·new·Process(projectRoot);
          +······Process·process·=·new·Process(projectRoot);
           ······process.setUnixCommand(GRADLE_WRAPPER_UNIX);
           ······process.setWindowsCommand(GRADLE_WRAPPER_WINDOWS);
           ······process.exec(args);
  Run './gradlew :gradle-server:spotlessApply' to fix these violations.

cc @nedtwigg

Today this extension cannot be used property as a default formatter for languages it supports since the extension doesn't advertise it self as supporting those languages into vscode runtime.

This can be simply enabled by adding the following to contribution section of the extension manifest package.json file. Example support for java which I tested with

		"languages": [
			{
				"id": "java",
				"aliases": [
					"Java"
				],
				"extensions": [
					"java"
				]
			}
		]

Similar approaches in other formatter extensions

• https://github.com/mwpb/java-prettier-formatter/blob/master/package.json

This is both a bug report and a feature request.

• A recent change to add --no-configuration-cache is throwing an error in Gradle versions < 6.6. Refs #274 & #273 & #217 (comment). See also: https://blog.gradle.org/introducing-configuration-caching
• Some people are experiencing slow performance in older projects, see: #217

What we need to do is:

• Determine the minimum supported version of Gradle & Spotless Grade Plugin and gather this information from vscode-gradle
• Show a message to the user informing them of any incompatibility

This will require a change in vscode-gradle to surface build information (Gradle version and dependency versions). vscode-gradle already has this information, there's just no public API to access it.

cc @nedtwigg