Simplify version extraction from a file

[ubitux]

Providing some way to replace the following pattern would be welcome:

project('foo', 'c',
  version: run_command(
    find_program('python'), '-c', 'import sys;print(open(sys.argv[1]).read())', files('VERSION')
  ).stdout().strip(),
)

Drawbacks with this current approach:

• we can't move the run_command() in a variable before project(), which likely implies this is currently a nasty hack where we're probably not supposed to do that
• some system may have python3 and not python, and the other way around is also true
• using run_command(find_program('cat'), ...) instead of python would be fatal on Windows
• having a dedicated Python script is quite an overhead, and doesn't address the external subprocess hack to just read a file

Rationale

So the current scenario we're in is the following: we are managing our releases through Github, where making a release is basically simply pushing a tag. So we have the following primitive make-release.sh script:

#!/bin/sh

#
# Release process:
# 1. on a clean git state, run this script with the new version as argument
# 2. check the last commit and tag
# 3. git push && git push --tags
#

set -eu

if [ $# -ne 1 ]; then
	echo "Usage $0 <major.minor.micro>"
	exit 1
fi

cd "$(dirname $0)"

if ! git diff-index --quiet HEAD; then
	echo "Git index is not clean"
	exit 1
fi

set -x
VERSION="$1"
echo "$VERSION" > VERSION
git add VERSION
git commit -m "Release $VERSION"
git tag "v$VERSION"

The VERSION file is basically the channel of communication between this script and meson.build

Alternative considered

• hot-patching meson.build within the release script, but it's not exactly cleaner to say the least
• using dist scripts with meson; unfortunately we're running git commands at an unfortunate timing, and it involves quite some logistic
• requesting in the release process to patch the meson.build with the new version, and then extracting the version with the meson introspection with tools like jq in the release script; this creates an annoying dependency to jq, and it also makes the release process much more clumsy than just running a script

How it could look like

Here are a two usage suggestions that would simplify and make this workflow much more reliable, which I believe are not very intrusive:

• project('foo', 'c', version: files('VERSION')) (it's part of the source files after all)
• project('foo', 'c', version: meson.get_file_content('VERSION'))

[jpakkane]

Alternatively:

project('foo', 'c', version_file: 'VERSION')

Specifying both version and version_file should be a hard error.

[dcbaker]

@jpakkane, we had discussed this at some length I'm the past, and had come up with both of these solutions. Do your prefer version_file? I'd really like this for Mesa

[jpakkane]

The thing I like about version_file is that it is more readable and higher level, i.e. "this is what I want" vs "do these steps to achieve something".

[jpakkane]

Though if the file is always called VERSION, then having to write that seems superfluous. Maybe we could just always check for it and use it if it's there? Having both a version file and version kwarg should still be a hard error.

[dcbaker]

That's a bit too implicit and magical for me. And it would be a backwards compatibility problem for mesa

[ldrumm]

Adopting something like cmake's FILE(READ... is less magical and is much more flexible for other uses. I can imagine a fair few scenarios where reading the contents of a file might be useful in meson for configuration and trivially enables the behaviour needed by Mesa

I'd definitely be happy to see the following (from the example above) for my own purposes

project('foo', 'c', version: meson.get_file_content('VERSION')).strip())

cmake's interfaces for files are pretty unpalatable to work with, but I think this is an excellent way to solve the problem in a general way.

@jpakkane I'd be happy to provide a patch for the above. Let me know if that's the route you want to take and I'll push a PR

[bruce-richardson]

Just by way of reference for anyone needing to support this on older versions of meson, while "cat" doesn't work on windows, "more" works fine as an acceptable substitute for short files like a versionfile. Therefore one can do the following:

project(...., version: run_command(find_program('cat', 'more'),
                files('VERSION')).stdout().strip(), ...)

Horrible, yes, but it also works. :-)

[nielsdg]

For my own use case at work: we need to be able to parse the version from a Debian changelog file in a cross-platform way (yay), so for us it would be a better option to have meson.get_file_content() over a version_file kwarg.

But feel free to add both, we solved it by using a similar workaround as the description of this issue 🙂