How to prohibit importing certain classes like checkstyle ImportControl module

[liugddx]

If you are submitting a bug, please include the following:

• summary of problem
• gradle or maven version
• spotless version
• operating system and version
• copy-paste your full Spotless configuration block(s), and a link to a public git repo that reproduces the problem if possible
• copy-paste the full content of any console errors emitted by gradlew spotless[Apply/Check] --stacktrace

If you're just submitting a feature request or question, no need for the above.

[nedtwigg]

Sure, here's an example.

example for pre-Gradle 8

https://github.com/diffplug/spotless/blob/f78cfe86d9900ed0b753e015d2645e4c8bd98e71/gradle/spotless.gradle#L3-L28

EDIT as of plugin-gradle 8.0.0 and plugin-maven 3.0.0

spotless/gradle/spotless.gradle

Line 15 in c997379

forbidRegex('ForbidGradleInternal', 'import org\\.gradle\\.api\\.internal\\.(.*)', "Don't use Gradle's internal API")

and in maven

<forbidRegex>
  <name>Forbid FooBar</name>
  <searchRegex>import foo\.bar\.(.*)</searchRegex>
  <lintDetail>foobar is officially abandoned, use fizzbuzz instead</lintDetail>
</forbidRegex>

[liugddx]

noInternalDepsClosure

Is there a similar method in maven?

[nedtwigg]

The best we have in maven is to replace or replaceRegex, and replace with something like "WARNING REMOVED" which will give you a compile error.

[liugddx]

The best we have in maven is to replace or replaceRegex, and replace with something like "WARNING REMOVED" which will give you a compile error.

Thank you very much. Let me try it.

[mymx2]

Simple Regex Step

import com.diffplug.spotless.FormatterFunc
import com.diffplug.spotless.FormatterStep
import java.io.Serializable

class DisableRegularExpressionStep {
  companion object {
    fun create(regExpList: List<Regex> = listOf()): FormatterStep {
      val state = State(regExpList.map { it.pattern })

      return FormatterStep.create("DisableRegularExpressionStep", state) { s ->
        FormatterFunc { unixStr ->
          val regex = s.patterns.firstOrNull { Regex(it).containsMatchIn(unixStr) }
          if (regex != null) {
            val re = Regex(regex)
            val match = re.find(unixStr)
            val lineNumber =
              match?.let { unixStr.take(it.range.first).count { c -> c == '\n' } + 1 } ?: -1
            val snippet = match?.value ?: unixStr.take(200)

            throw AssertionError(
              buildString {
                  appendLine("[${regex}]L$lineNumber")
                  appendLine(snippet)
                }
                .trim()
            )
          }
          unixStr
        }
      }
    }
  }

  data class State(val patterns: List<String>) : Serializable
}

or use forbidRegex , like checkstyle-import-control:

spotless {
  val importControlMap =
    mapOf(
      "**/mymx2/dao/*" to listOf("import java\\.sql\\..*"),
      "**/mymx2/spring/*" to listOf("import org\\.springframework\\.web\\.bind\\.annotation\\.(.*)"),
    )

  val targetFiles = spotlessFileTree().apply { include("**/*.java", "**/*.kt") }
  importControlMap.entries.forEachIndexed { index, (pathPattern, regexList) ->
    format("importControl$index") {
      target(targetFiles.matching { include(pathPattern) })
      regexList.forEachIndexed { regexIndex, regex ->
        forbidRegex("disallowRule${index}_${regexIndex}", regex, "disallow import: $regex")
      }
    }
  }
}

but you should re-group task, it will gen too too much task.

[nedtwigg]

As of plugin-gradle 8.0.0 and plugin-maven 3.0.0 , we have the forbidRegex step which throws a lint with nice line numbers (and a way to suppress the lint). That is new the recommended way to solve this problem, see comment above: #1851 (comment)