Skip to content

Commit

Permalink
Use MapProperty for check names/severity and options
Browse files Browse the repository at this point in the history
  • Loading branch information
@tbroyer
tbroyer committed Apr 14, 2019
1 parent 205e996 commit eeb6325
Show file tree
Hide file tree
Showing 3 changed files with 53 additions and 15 deletions.
4 changes: 2 additions & 2 deletions README.md
View file
Original file line number Diff line number Diff line change
Expand Up @@ -341,9 +341,9 @@ import net.ltgt.gradle.errorprone.errorprone
| `warn(checkNames...)` | Adds checks with warning severity.
| `error(checkNames...)` | Adds checks with error severity.
| `check(checkName to severity...)` | (Kotlin DSL only) Adds pairs of check name to severity.
| `check(checkName, severity)` | Adds a check with a given severity.
| `check(checkName, severity)` | Adds a check with a given severity. The severity can be passed as a provider for lazy configuration.
| `option(optionName)` | Enables a boolean check option. Equivalent to `option(checkName, true)`.
| `option(optionName, value)` | Adds a check option with a given value. Value can be a boolean or a string.
| `option(optionName, value)` | Adds a check option with a given value. Value can be a boolean or a string, or a provider of string.

A check severity can take values: `DEFAULT`, `OFF`, `WARN`, or `ERROR`.
Note that the `net.ltgt.gradle.errorprone.CheckSeverity` needs to be `import`ed into your build scripts (see examples above).
19 changes: 13 additions & 6 deletions src/main/kotlin/net/ltgt/gradle/errorprone/ErrorProneOptions.kt
View file
Original file line number Diff line number Diff line change
Expand Up @@ -24,8 +24,8 @@ open class ErrorProneOptions constructor(
@get:Input val ignoreSuppressionAnnotations = objectFactory.property<Boolean>().convention(false)
@get:Input val isCompilingTestOnlyCode = objectFactory.property<Boolean>().convention(false)
@get:Input @get:Optional val excludedPaths = objectFactory.property<String>()
@get:Input var checks: MutableMap<String, CheckSeverity> = linkedMapOf()
@get:Input var checkOptions: MutableMap<String, String> = linkedMapOf()
@get:Input val checks = objectFactory.mapProperty<String, CheckSeverity>().empty()
@get:Input val checkOptions = objectFactory.mapProperty<String, String>().empty()
@get:Input val errorproneArgs = objectFactory.listProperty<String>().empty()
@get:Nested val errorproneArgumentProviders: MutableList<CommandLineArgumentProvider> = arrayListOf()

Expand All @@ -38,7 +38,11 @@ open class ErrorProneOptions constructor(
fun check(vararg pairs: Pair<String, CheckSeverity>) = pairs.forEach { (checkName, severity) -> check(checkName, severity) }
fun check(checkName: String, severity: CheckSeverity) {
validateName(checkName)
checks[checkName] = severity
checks.put(checkName, severity)
}
fun check(checkName: String, severity: Provider<CheckSeverity>) {
validateName(checkName)
checks.put(checkName, severity)
}

fun enable(vararg checkNames: String) = set(*checkNames, atSeverity = CheckSeverity.DEFAULT)
Expand All @@ -51,7 +55,10 @@ open class ErrorProneOptions constructor(

@JvmOverloads fun option(name: String, value: Boolean = true) = option(name, value.toString())
fun option(name: String, value: String) {
checkOptions[name] = value
checkOptions.put(name, value)
}
fun option(name: String, value: Provider<String>) {
checkOptions.put(name, value)
}

override fun toString(): String {
Expand All @@ -66,8 +73,8 @@ open class ErrorProneOptions constructor(
booleanOption("-XepCompilingTestOnlyCode", isCompilingTestOnlyCode),
stringOption("-XepExcludedPaths", excludedPaths)
).filterNotNull() +
checks.asSequence().map { (name, severity) -> validateName(name); "-Xep:$name${severity.asArg}" } +
checkOptions.asSequence().map { (name, value) -> "-XepOpt:$name=$value" } +
checks.getOrElse(emptyMap()).asSequence().map { (name, severity) -> validateName(name); "-Xep:$name${severity.asArg}" } +
checkOptions.getOrElse(emptyMap()).asSequence().map { (name, value) -> "-XepOpt:$name=$value" } +
errorproneArgs.getOrElse(emptyList()) +
errorproneArgumentProviders.asSequence().flatMap { it.asArguments().asSequence() }
).onEach(::validate)
Expand Down
45 changes: 38 additions & 7 deletions src/test/kotlin/net/ltgt/gradle/errorprone/ErrorProneOptionsTest.kt
View file
Original file line number Diff line number Diff line change
Expand Up @@ -5,6 +5,8 @@ import com.google.errorprone.ErrorProneOptions.Severity
import com.google.errorprone.InvalidCommandLineOptionException
import org.gradle.api.InvalidUserDataException
import org.gradle.api.model.ObjectFactory
import org.gradle.api.provider.ProviderFactory
import org.gradle.kotlin.dsl.property
import org.gradle.process.CommandLineArgumentProvider
import org.gradle.testfixtures.ProjectBuilder
import org.junit.Assert.fail
Expand All @@ -18,9 +20,13 @@ class ErrorProneOptionsTest {
@JvmField @ClassRule val projectDir = TemporaryFolder()

lateinit var objects: ObjectFactory
lateinit var providers: ProviderFactory

@JvmStatic @BeforeClass fun setup() {
objects = ProjectBuilder.builder().withProjectDir(projectDir.root).build().objects
ProjectBuilder.builder().withProjectDir(projectDir.root).build().let { project ->
objects = project.objects
providers = project.providers
}
}
}

Expand All @@ -40,12 +46,12 @@ class ErrorProneOptionsTest {
doTestOptions { error("ArrayEquals") }
doTestOptions { check("ArrayEquals" to CheckSeverity.OFF) }
doTestOptions { check("ArrayEquals", CheckSeverity.WARN) }
doTestOptions { checks["ArrayEquals"] = CheckSeverity.ERROR }
doTestOptions { checks = mutableMapOf("ArrayEquals" to CheckSeverity.DEFAULT) }
doTestOptions { checks.put("ArrayEquals", CheckSeverity.ERROR) }
doTestOptions { checks.set(mutableMapOf("ArrayEquals" to CheckSeverity.DEFAULT)) }
doTestOptions { option("Foo") }
doTestOptions { option("Foo", "Bar") }
doTestOptions { checkOptions["Foo"] = "Bar" }
doTestOptions { checkOptions = mutableMapOf("Foo" to "Bar") }
doTestOptions { checkOptions.put("Foo", "Bar") }
doTestOptions { checkOptions.set(mutableMapOf("Foo" to "Bar")) }

doTestOptions {
disableAllChecks.set(true)
Expand Down Expand Up @@ -93,6 +99,31 @@ class ErrorProneOptionsTest {
})
}

@Test
fun `correctly allows lazy configuration`() {
doTestOptions({
check("NullAway", isCompilingTestOnlyCode.map { if (it) CheckSeverity.WARN else CheckSeverity.ERROR })
}, {
error("NullAway")
})

doTestOptions({
check("NullAway", isCompilingTestOnlyCode.map { if (it) CheckSeverity.WARN else CheckSeverity.ERROR })
isCompilingTestOnlyCode.set(providers.provider { true })
}, {
isCompilingTestOnlyCode.set(true)
warn("NullAway")
})

doTestOptions({
val annotatedPackages = objects.property<String>()
option("NullAway:AnnotatedPackages", annotatedPackages)
annotatedPackages.set(providers.provider { "net.ltgt.gradle.errorprone" })
}, {
option("NullAway:AnnotatedPackages", "net.ltgt.gradle.errorprone")
})
}

private fun doTestOptions(configure: ErrorProneOptions.() -> Unit, reference: ErrorProneOptions.() -> Unit) {
val options = ErrorProneOptions(objects).apply(reference)
val parsedOptions = parseOptions(ErrorProneOptions(objects).apply(configure))
Expand Down Expand Up @@ -162,8 +193,8 @@ class ErrorProneOptionsTest {
assertThat(parsedOptions.isIgnoreSuppressionAnnotations).isEqualTo(options.ignoreSuppressionAnnotations.get())
assertThat(parsedOptions.isTestOnlyTarget).isEqualTo(options.isCompilingTestOnlyCode.get())
assertThat(parsedOptions.excludedPattern?.pattern()).isEqualTo(options.excludedPaths.orNull)
assertThat(parsedOptions.severityMap).containsExactlyEntriesIn(options.checks.mapValues { it.value.toSeverity() })
assertThat(parsedOptions.flags.flagsMap).containsExactlyEntriesIn(options.checkOptions)
assertThat(parsedOptions.severityMap).containsExactlyEntriesIn(options.checks.get().mapValues { it.value.toSeverity() })
assertThat(parsedOptions.flags.flagsMap).containsExactlyEntriesIn(options.checkOptions.get())
assertThat(parsedOptions.remainingArgs).isEmpty()
}

Expand Down

0 comments on commit eeb6325

Please sign in to comment.