From mobile apps to microservices, from small startups to big enterprises, Gradle helps teams build, automate and deliver better software, faster.

Gradle Community

trying to print the projects version to stdout so I can capture it, and only it in a shell variable. It should always be printed

```var printVersion = tasks.register("printVersion") {
  outputs.upToDateWhen { false }
  println(version)
}```
```&gt; Task :printVersion UP-TO-DATE
Skipping task ':printVersion' as it has no actions.```


Move the println to a doLast {...} block.

although I didn't put this, seems to have the issue that it's not configuration cache safe

1 problem was found storing the configuration cache.
- Task `:printVersion` of type `org.gradle.api.DefaultTask`: cannot serialize Gradle script object references as these are not supported with the configuration cache.

I suppose I could always run it with --no-configuration-cache but that feels silly

`version` is really `project.version`
Store `project.version` in a local variable, then CC is happy.

Besides that, you don't need the `outputs.upToDateWhen`, because you did not declare any outputs, your task will never be up-to-date anyway. And if you would need to do something like that, better use `doNotTrackState()` instead, but also that is not necessary here.

```val printVersion by tasks.registering {
  val version = version
  doLast {
    println(version)
  }
}```
  should do what you want I think

Well, not "always", as `println` goes to stdout which goes to lifecycle log level which would be suppressed when using `-q` :slightly_smiling_face:

❯ ./gradlew printVersion --quiet
0.11.1

this would be a lazy version, meaning that the version (not project.version) won't get calculated until the dolast block is called right?

```var printVersion = tasks.register("printVersion") {
  val version = project.providers.provider { this.project.extensions.getByType(SemverExtension::class).gitDescribed  }
  doLast { println(version.get()) }
}```


&gt; ❯ ./gradlew printVersion --quiet
&gt; 0.11.1
Huh, ok, must have remembered wrongly, either the log level on which stdout is captured or what quiet displays
&gt; this would be a lazy version
yes
&gt; meaning that the version won't get calculated until the dolast block is called right?
no
Well, depends on whether CC is enabled.
Without CC, yes.
With CC it would be evaluated at the time the CC entry is serialized.
When CC is reused it will not be reevaluated but the value from CC is used.
If that is not what you need, you need to use a value source instead.

seems to work in this case with/without CC now, I imagine that's because that's reading from git and changing git invalidates that part of the CC

Probably depends on how you read from Git.

maybe, wasn't able to find a good way out of it though

I actually suspect I'm as lazy as I can get given that the publishing plugins aren't actually lazy