Posibility to write templated files out with memoization based on passed variables

[iilyak]

I'm currently dealing with a common challenge in managing dependencies across various files in my project. Specifically, I have separate files, such as .tools-version and Dockerfile, that contain the dependency versions. While I use .tools-versions for local development, I utilize the Dockerfile during Continuous Integration (CI). However, when I update a dependency version, I need to remember to modify each file accordingly, which can sometimes result in oversight.

To address this issue, I would like to manage all dependencies' versions in one centralized place and generate other files using templates based on the version information and current architecture. The current architecture aspect is important because some tools are downloaded using curl and I do verify the hash of the downloaded file. The hash would be different on different architectures. I've could use Makefile or git's post-checkout hook. However this approach would introduce lots of boilerplate code and would be hard to maintain. Some generic memoization mechanism is needed. This mechanism should take into account what files where updated and which arguments are used by template.

Dockerfile

# install coursier
ARG CS_VERSION=2.1.10
ARG CS_CHECKSUM=a099483f27e3d916342a031505ae1dd3a0f0c8f03d37c227d296314559d36495
RUN <<EOF
package_filename=cs-x86_64-pc-linux-static.gz
ghrd github.com/coursier/coursier "${package_filename}" "v${CS_VERSION}" "${CS_CHECKSUM}"
gunzip -c "${package_filename}" > /usr/local/bin/coursier
chmod +x /usr/local/bin/coursier
rm "${package_filename}"
coursier version
EOF

.tools-version

coursier 2.1.10

The main idea for mise is to use existing tera template engine to render arbitrary files and implement caching/memoization mechanism to avoid rendering the files over and over. Since rewriting the files would break incremental builds.

[jdx]

I would probably just write a script that uses something like envsubst

[iilyak]

Interesting project https://blaze-monorepo.dev/docs/guides/caching and configuration design.

{
    "targets": {
        "my-target": {
            "cache": {
                "invalidateWhen": {
                    "inputChanges": [
                        {
                            "pattern": "**",
                            "exclude": [
                                "node_modules/**"
                            ]
                        }
                    ]
                }
            }
        }
    }
}

which could be translated into toml as

[tasks.build]
description = 'Build the CLI'
run = "cargo build"
sources = ['Cargo.toml', 'src/**/*.rs'] # skip running if these files haven't changed
outputs = ['target/debug/mycli']
"cache.invalidateWhen.inputChanges" = [ 'additionalFile.json' ]
"cache.invalidateWhen.sourceChanges.exclude" = [ 'src/**/generated_*.rs' ]
"cache.invalidateWhen.envChanges" = [ 'TARGET_ARCH' ]
"cache.invalidateWhen.varChanges" = [ 'myVar' ]

Then template rendering with cache would be easy to implement.