[CMake] Versioning and release/distribution management with cmake and git
Roger Leigh
rleigh at codelibre.net
Mon Sep 23 17:41:19 EDT 2013
Hi,
For a number of years, I've been using autoconf/automake with a custom
extension for managing version numbering with git,including releasing
and distribution of the software directly in git.
(http://anonscm.debian.org/gitweb/?p=buildd-tools/schroot.git;a=blob;f=scripts/git-dist.mk;hb=refs/heads/schroot-1.6)
Over the last couple of weeks, I've been converting this project to use
cmake to replace the existing autoconf/automake build system. I plan to
have both running in parallel for a period. However, I've rewritten
the above as a cmake script which I have further generalised to make it
more generally usable (attached). I've written some documentation for
how it all works at the start of the script, so I'll not repeat it
unnecessarily here.
To summarise its use, version numbering is handled externally from the
source tree in git tags. These are found when cmake runs. When it
comes to releasing, a git-release target handles tagging the git
repository, which also sets the version number in the release tag. It
also handles distribution creation on a separate git branch, and will
embed the version number on the branch so it will work outside git with
e.g. tar/zip files; this branch is exportable to a release tar/zipfile.
This allows flexible and automated control over making releases without
any manual work in the source tree, so that it can integrate with CI
systems such as jenkins quite easily.
Example:
git://anonscm.debian.org/buildd-tools/schroot.git (development + release tags)
git://anonscm.debian.org/buildd-tools/schroot-dist.git (distribution +
distribution tags)
If you add both as remotes, you can see how the distribution and release
history ties together for each major release series with e.g. gitk.
While the script is currently functional, it's not yet perfect. I'd like
to contribute it to the cmake project as a module once it's in a better
state, but prior to that I'd really appreciate some review in case I'm not
doing things the "cmake way". In particular, reuse of the script as both
a module and standalone script is not too elegant with the use of a
generated script to pass configuration parameters.
I'd also like to allow end users to extend the creating of the distribution
directory with an automake-like "dist-hook" target or equivalent. But I'm
unsure how to write a generic target with cmake which will invoke the
registered hooks. Examples are to add generated files to the releases
(e.g. docs, translations) and perform pre-release sanity checks. Are there
any examples of such hook uses?
Another minor annoyance I've run into is that when I define a function and
make use of a global variable, it appears to expand the variable during
definition, rather than evaluating it when I call the function. Is it
possible to make the function evaluate the variable lazily at
invocation time rather than when defined?
Kind regards,
Roger
--
.''`. Roger Leigh
: :' : Debian GNU/Linux http://people.debian.org/~rleigh/
`. `' Printing on GNU/Linux? http://gutenprint.sourceforge.net/
`- GPG Public Key: 0x25BFB848 Please GPG sign your mail.
-------------- next part --------------
# Copyright ? 2009-2013 Roger Leigh <rleigh at debian.org>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see
# <http://www.gnu.org/licenses/>.
#
#####################################################################
# Versioning, releasing and distribution management with git and cmake
# ====================================================================
#
# This facility is a cmake reimplementation of an earlier
# autoconf/automake version from
# http://anonscm.debian.org/gitweb/?p=buildd-tools/schroot.git;a=blob;f=scripts/git-dist.mk;hb=refs/heads/schroot-1.6
# but is further generalised and is rather more configurable, and
# integrates quite seamlessly with cmake.
#
# Most projects currently handle versioning by hardcoding the version
# number in the source repository in some form, for example in the
# cmake scripts, or in the sources or some other file. This script
# handles release versioning using the metadata in git tags, and for
# distributed release archives, it embeds a generated file so that git
# isn't required to retrieve the release metadata.
#
# This script also handles release and distribution of a project
# entirely within git, which is described in more detail below.
#
# A number of variables customise the behaviour of the script for a
# particular project; set them before including this file. While the
# defaults will work for most projects, it will typically require
# adapting to the existing conventions used by a particular project.
#
# The intended use of this facility is to replace a manual step in the
# release process with an automated one, such that releasing may be
# done entirely automatically, and the version numbering may be
# controlled at a higher level, for example via a continuous
# integration system such as Jenkins, or by a release manager, etc.
# The versioning is handled external to the source tree, but is done
# entirely within the git repository.
#
# Terms
# -----
#
# Release
# Tagging the working git branch with a "release tag". This tag is
# signed by default, and the naming scheme allows identification of
# the current or previous release when running cmake.
#
# Distribution
# Creation of a distributable form of the tagged release. This
# involves committing of the tagged release source tree to a
# "distribution branch" and creation of a "distribution tag". This
# tag is signed by default. The distributed source tree is the
# release source tree with the addition of release metadata
# including the version number, and may also include other generated
# data, e.g. documentation. This tagged distribution may be
# subsequently exported as a tarfile or zipfile with "git archive",
# or used directly from git by downstream consumers.
#
#
# Version metadata
# ----------------
#
# Set GIT_VERSION_FILE, which is the location of a cmake script
# relative to PROJECT_SOURCE_DIR. The default is "version.cmake".
# For backward compatibility with the preexisting autoconf/automake
# implementation, GIT_VERSION_FILE_COMPAT may also be set, defaulting
# to "VERSION"; this also needs GIT_VERSION_FILE_USE_COMPAT setting to
# ON (default is OFF).
#
# When developing from git, no version file will be used; version
# information will be obtained directly from git. When using a
# distributed release, version information will be obtained from the
# version file.
#
#
# Release configuration
# ---------------------
#
# This script will not allow tagging of a release if the working git
# branch contains uncommitted changes. This is in order to prevent
# creation of broken releases?the working tree may appear to build
# and work correctly, but the uncommitted changes won't be tagged.
# Additionally, it will not allow tagging of a release if untracked
# files are present in the tree (for the same reasons--the untracked
# files may require adding and committing). Set
# GIT_RELEASE_CHECK_UNTRACKED to OFF to allow releasing if untracked
# files are present.
#
# Releasing isn't enabled by default in order to prevent unintentional
# or accidental modification of the git repository. That is to say,
# making a release must be explicitly requested as a safety check; set
# GIT_RELEASE_ENABLE to ON in order to make a release.
#
# Release tagging is customised using the following options:
#
# GIT_RELEASE_TAG_OPTIONS
# A list of options to pass to "git tag"; defaults to "-s" to sign
# the tag.
#
# GIT_RELEASE_TAG_NAME
# The name of the release tag. Defaults to
# "release/${CMAKE_PROJECT_NAME}-${GIT_RELEASE_VERSION}", but may be
# changed to just "v${GIT_RELEASE_VERSION}" or any name desired.
# The only restriction is that it must contain the release version
# somewhere in the string, and must be a valid git tag name.
#
# GIT_RELEASE_TAG_MATCH
# A pattern to patch all release versions when using "git describe
# --match". Defaults to "release/${CMAKE_PROJECT_NAME}-*",
# i.e. containing the constant part of GIT_RELEASE_TAG_NAME without
# the version number. Must be changed appropriately if
# GIT_RELEASE_TAG_NAME is customised.
#
# GIT_RELEASE_TAG_REGEX
# A regular expression to match the release version in the tag name.
# The release version number must be the first match ("\1").
# Defaults to "^release/${CMAKE_PROJECT_NAME}-([0-9].*)\$". Must be
# changed appropriately if GIT_RELEASE_TAG_NAME is customised.
#
# GIT_RELEASE_TAG_MESSAGE
# The release tag message. Any text is permitted here, though it is
# advisable (but not required) to include GIT_RELEASE_VERSION as
# part of the message.
#
#
# Releasing
# ---------
#
# Run "cmake" as normal, but add the options:
#
# -DGIT_RELEASE_ENABLE=ON -DGIT_RELEASE_VERSION=${new_version}
#
# This will provide a new "git-release" target. If using make, run:
#
# make git-release
#
# If tag signing is enabled, you'll be prompted for your key
# passphrase.
#
# Run "git log --decorate" or "git describe" and you'll see the
# release tag. This tag marks the current commit as the release of
# version ${new_version}.
#
#
# Distribution configuration
# --------------------------
#
# Making a distribution of a release requires releasing first (as
# documented above)
#
# Distributing isn't enabled by default in order to prevent
# unintentional or accidental modification of the git repository.
# That is to say, making a distribution must be explicitly requested
# as a safety check; set GIT_DIST_ENABLE to ON in order to make a
# distribution.
#
# Distribution tagging is customised using the following options:
#
# GIT_DIST_TAG_OPTIONS
# A list of options to pass to "git tag"; defaults to "-s" to sign
# the tag.
#
# GIT_DIST_TAG_NAME
# The name of the distribution tag. Defaults to
# "distribution/${CMAKE_PROJECT_NAME}-${GIT_RELEASE_VERSION}", but
# may be changed to just "v${GIT_RELEASE_VERSION}" or any name
# desired. The only restriction is that it must contain the
# distribution version somewhere in the string, and must be a valid
# git tag name.
#
# GIT_DIST_TAG_MESSAGE
# The distribution tag message. Any text is permitted here, though
# it is advisable (but not required) to include GIT_DIST_VERSION as
# part of the message.
#
# Distribution committing and branching is customised using the
# following options:
#
# GIT_DIST_BRANCH
# The name of the branch to commit onto. The branch will be created
# if it does not already exist. The default is
# "distribution/${CMAKE_PROJECT_NAME}-${GIT_RELEASE_VERSION_MAJOR}.${GIT_RELEASE_VERSION_MINOR}"
# which is to say that it includes the major and minor version
# numbers, so that you get a new distribution branch each time the
# major or minor number is changed, with the patch release versions
# being committed in sequence on each branch. This enables
# downstream tracking of a given release series, and maintenance of
# multiple release series in parallel. It is advised to customise
# this to meet the project's versioning and release strategy such
# that major stable release series are kept on different branches.
#
# GIT_DIST_COMMIT_MESSAGE
# The distribution commit message. Any text is permitted here,
# though it is advisable (but not required) to include
# GIT_DIST_VERSION as part of the message.
#
# GIT_DIST_NAME
# Naming scheme for the release. This is the name of the release
# directory, and will be used to prefix the path for release
# archives. Defaults to
# "${CMAKE_PROJECT_NAME}-${GIT_RELEASE_VERSION}".
#
# GIT_DIST_TMPDIR
# Temporary directory used for staging the release distribution tree
# prior to committing into git. Defaults to
# "${PROJECT_BINARY_DIR}/git-release" but may be
# adjusted if this clashes with existing usage of this path.
#
# GIT_DIST_ROOT
# Root of the staged release distribution. Defaults to
# "${GIT_DIST_TMPDIR}/${GIT_DIST_NAME}".
#
#
#
# Distributing
# ------------
#
# Run "cmake" as normal, but add the option:
#
# -DGIT_DIST_ENABLE=ON
#
# This will provide a new "git-dist" target. If using make, run:
#
# make git-dist
#
# If tag signing is enabled, you'll be prompted for your key
# passphrase.
#
# Look at the distribution branch with "git log --decorate --graph" or
# "gitk". You'll see that the distribution has the tagged release as
# its parent and (if present) the prior distribution. That is to say,
# the relationships between the releases and distributions are
# explicitly defined. While this might not be of immediately obvious
# benefit, it means that downstream consumers can make changes and
# push them back to you; merging the changes back upstream is much
# easier since the origin of the changes is fully described by the
# dependency graph.
cmake_policy(SET CMP0007 NEW)
# When running in script mode, source the configuration first
if (CMAKE_SCRIPT_MODE_FILE)
include("${CMAKE_BINARY_DIR}/git-release-settings.cmake")
endif (CMAKE_SCRIPT_MODE_FILE)
if (NOT CMAKE_SCRIPT_MODE_FILE)
# Version file settings
set(GIT_VERSION_FILE "version.cmake"
CACHE FILEPATH "Relative path to cmake version file in distributed source tree")
set(GIT_VERSION_FILE_COMPAT "VERSION"
CACHE FILEPATH "Relative path to compatibility version file in distributed source tree")
set(GIT_VERSION_FILE_USE_COMPAT OFF
CACHE FILEPATH "Create compatibility version file in distributed source tree")
mark_as_advanced(FORCE GIT_VERSION_FILE GIT_VERSION_FILE_COMPAT GIT_VERSION_FILE_USE_COMPAT)
# Release sanity checking
set(GIT_RELEASE_CHECK_UNCOMMITTED ON
CACHE BOOL "Check for uncommitted files in working tree")
set(GIT_RELEASE_CHECK_UNTRACKED ON
CACHE BOOL "Check for untracked files in working tree")
set(GIT_RELEASE_ENABLE OFF
CACHE BOOL "Enable to permit git-release; not enabled by default for safety")
mark_as_advanced(FORCE GIT_RELEASE_CHECK_UNCOMMITTED GIT_RELEASE_CHECK_UNTRACKED GIT_RELEASE_ENABLE)
# Release matching
set(GIT_RELEASE_TAG_MATCH "release/${CMAKE_PROJECT_NAME}-*"
CACHE STRING "Pattern match for all release tags for use with \"git describe --match\"")
set(GIT_RELEASE_TAG_REGEX "^release/${CMAKE_PROJECT_NAME}-([0-9].*)\$"
CACHE STRING "Regular expression to extract the version number from the tag name")
mark_as_advanced(FORCE GIT_RELEASE_TAG_MATCH GIT_RELEASE_TAG_REGEX)
# Distribution sanity checking
set(GIT_DIST_ENABLE OFF
CACHE BOOL "Enable to permit git-dist; not enabled by default for safety")
mark_as_advanced(FORCE GIT_DIST_ENABLE)
endif (NOT CMAKE_SCRIPT_MODE_FILE)
# Split a version number into separate components
# version the version number to split
# major variable name to store the major version in
# minor variable name to store the minor version in
# patch variable name to store the patch version in
# extra variable name to store a version suffix in
function(git_release_version_split version major minor patch extra)
string(REGEX MATCH "([0-9]+)\\.([0-9]+)\\.([0-9]+)(.*)?" version_valid ${version})
if(version_valid)
string(REGEX REPLACE "([0-9]+)\\.([0-9]+)\\.([0-9]+)(.*)?" "\\1;\\2;\\3;\\4" VERSION_MATCHES ${version})
list(GET VERSION_MATCHES 0 version_major)
set(${major} ${version_major} PARENT_SCOPE)
list(GET VERSION_MATCHES 1 version_minor)
set(${minor} ${version_minor} PARENT_SCOPE)
list(GET VERSION_MATCHES 2 version_patch)
set(${patch} ${version_patch} PARENT_SCOPE)
list(GET VERSION_MATCHES 3 version_extra)
set(${extra} ${version_extra} PARENT_SCOPE)
else(version_valid)
message(AUTHOR_WARNING "Bad version ${version}; falling back to 0 (have you made an initial release?)")
set(${major} "0" PARENT_SCOPE)
set(${minor} "" PARENT_SCOPE)
set(${patch} "" PARENT_SCOPE)
set(${extra} "" PARENT_SCOPE)
endif(version_valid)
endfunction(git_release_version_split)
function(git_release_version_from_file_compat git_version_file)
if(NOT EXISTS ${git_version_file})
message(FATAL_ERROR "git version file ${git_version_file} does not exist")
endif(NOT EXISTS ${git_version_file})
FILE(READ "${git_version_file}" VERSION_CONTENT)
STRING(REGEX REPLACE ";" "\\\\;" VERSION_CONTENT "${VERSION_CONTENT}")
STRING(REGEX REPLACE "\n" ";" VERSION_CONTENT "${VERSION_CONTENT}")
foreach(line ${VERSION_CONTENT})
string(REGEX MATCH "^([A-Z][a-zA-Z-]*): (.*)" line_valid ${line})
if(line_valid)
string(REGEX REPLACE "^([A-Z][a-zA-Z-]*): (.*)" "\\1;\\2" line_matches ${line})
list(GET line_matches 0 key)
list(GET line_matches 1 value)
if (${key} STREQUAL "Package")
if (NOT ${CMAKE_PROJECT_NAME} STREQUAL ${value})
message(FATAL_ERROR "Project name ${CMAKE_PROJECT_NAME} does not match name in ${git_version_file} (${value})")
endif (NOT ${CMAKE_PROJECT_NAME} STREQUAL ${value})
set(GIT_RELEASE_PACKAGE ${value} PARENT_SCOPE)
endif(${key} STREQUAL "Package")
if (${key} STREQUAL "Version")
set(GIT_RELEASE_VERSION ${value} PARENT_SCOPE)
endif(${key} STREQUAL "Version")
if (${key} STREQUAL "Release-Date")
set(GIT_RELEASE_DATE ${value} PARENT_SCOPE)
endif(${key} STREQUAL "Release-Date")
if (${key} STREQUAL "Release-Date-Unix")
set(GIT_RELEASE_DATE_UNIX ${value} PARENT_SCOPE)
endif(${key} STREQUAL "Release-Date-Unix")
if (${key} STREQUAL "Released-By")
set(GIT_RELEASE_BY ${value} PARENT_SCOPE)
endif(${key} STREQUAL "Released-By")
if (${key} STREQUAL "Git-Tag")
set(GIT_RELEASE_TAG ${value} PARENT_SCOPE)
endif(${key} STREQUAL "Git-Tag")
endif(line_valid)
endforeach(line)
endfunction(git_release_version_from_file_compat)
function(git_release_version_from_file git_version_file)
include("${git_version_file}")
set(GIT_RELEASE_PACKAGE ${GIT_RELEASE_PACKAGE} PARENT_SCOPE)
set(GIT_RELEASE_VERSION ${GIT_RELEASE_VERSION} PARENT_SCOPE)
set(GIT_RELEASE_DATE ${GIT_RELEASE_DATE} PARENT_SCOPE)
set(GIT_RELEASE_DATE_UNIX ${GIT_RELEASE_DATE_UNIX} PARENT_SCOPE)
set(GIT_RELEASE_BY ${GIT_RELEASE_BY} PARENT_SCOPE)
set(GIT_RELEASE_TAG ${GIT_RELEASE_TAG} PARENT_SCOPE)
endfunction(git_release_version_from_file)
function(git_release_version_from_git_tag git_tag tag_exists)
execute_process(COMMAND git show ${git_tag}
OUTPUT_VARIABLE tag_content RESULT_VARIABLE show_fail ERROR_QUIET
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR})
if (tag_exists AND show_fail)
message(FATAL_ERROR "Could not obtain release tag ${git_tag} from git")
endif (tag_exists AND show_fail)
STRING(REGEX REPLACE ";" "\\\\;" tag_content "${tag_content}")
STRING(REGEX REPLACE "\n" ";" tag_content "${tag_content}")
foreach(line ${tag_content})
string(REGEX MATCH "^Tagger: (.*)" tagger_valid ${line})
if (tagger_valid)
string(REGEX REPLACE "^Tagger: (.*)" "\\1" tagger ${line})
endif (tagger_valid)
endforeach(line)
# If tagger is undefined, set to "Unreleased".
if(NOT tagger)
set(tagger "Unreleased")
endif(NOT tagger)
set(GIT_RELEASE_BY ${tagger} PARENT_SCOPE)
set(GIT_RELEASE_TAG ${git_tag} PARENT_SCOPE)
execute_process(COMMAND git rev-parse "${git_tag}^{}"
OUTPUT_VARIABLE commit RESULT_VARIABLE revparse_fail ERROR_QUIET
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR})
if (revparse_fail)
message(FATAL_ERROR "Could not obtain release commit information from git")
endif (revparse_fail)
string(REPLACE "\n" "" commit "${commit}")
execute_process(COMMAND git log -1 "${commit}" --pretty=%ai
OUTPUT_VARIABLE commit_date RESULT_VARIABLE revparse_fail ERROR_QUIET
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR})
if (revparse_fail)
message(FATAL_ERROR "Could not obtain release commit date from git")
endif (revparse_fail)
string(REPLACE "\n" "" commit_date "${commit_date}")
execute_process(COMMAND git log -1 "${commit}" --pretty=%at
OUTPUT_VARIABLE commit_date_unix RESULT_VARIABLE revparse_fail ERROR_QUIET
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR})
if (revparse_fail)
message(FATAL_ERROR "Could not obtain release commit timestamp from git")
endif (revparse_fail)
string(REPLACE "\n" "" commit_date_unix "${commit_date_unix}")
set(GIT_RELEASE_DATE ${commit_date} PARENT_SCOPE)
set(GIT_RELEASE_DATE_UNIX ${commit_date_unix} PARENT_SCOPE)
set(GIT_RELEASE_PACKAGE ${CMAKE_PROJECT_NAME} PARENT_SCOPE)
string(REGEX REPLACE "^release/${CMAKE_PROJECT_NAME}-([0-9].*)\$" "\\1" git_release_version ${git_tag})
set(GIT_RELEASE_VERSION ${git_release_version} PARENT_SCOPE)
endfunction(git_release_version_from_git_tag)
function(git_release_version_from_git tag_match)
set(tag_exists TRUE)
execute_process(COMMAND git describe --match "${tag_match}" --exact-match
OUTPUT_VARIABLE git_tag RESULT_VARIABLE git_fail ERROR_QUIET
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR})
string(REPLACE "\n" "" git_tag "${git_tag}")
if(git_fail)
set(tag_exists FALSE)
# This commit is not a tagged release;
execute_process(COMMAND git describe --match "${tag_match}"
OUTPUT_VARIABLE git_tag RESULT_VARIABLE git_fail2 ERROR_QUIET
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR})
string(REPLACE "\n" "" git_tag "${git_tag}")
if(git_fail2)
message(FATAL_ERROR "Could not obtain release information from git")
endif(git_fail2)
endif(git_fail)
git_release_version_from_git_tag(${git_tag} ${tag_exists})
set(GIT_RELEASE_PACKAGE ${GIT_RELEASE_PACKAGE} PARENT_SCOPE)
set(GIT_RELEASE_VERSION ${GIT_RELEASE_VERSION} PARENT_SCOPE)
set(GIT_RELEASE_DATE ${GIT_RELEASE_DATE} PARENT_SCOPE)
set(GIT_RELEASE_DATE_UNIX ${GIT_RELEASE_DATE_UNIX} PARENT_SCOPE)
set(GIT_RELEASE_BY ${GIT_RELEASE_BY} PARENT_SCOPE)
set(GIT_RELEASE_TAG ${GIT_RELEASE_TAG} PARENT_SCOPE)
endfunction(git_release_version_from_git)
function(git_release_version_to_file_compat git_version_file)
set(keys
"Package: ${CMAKE_PROJECT_NAME}"
"Version: ${GIT_RELEASE_VERSION}")
if (GIT_RELEASE_DATE)
set(keys ${keys} "Release-Date: ${GIT_RELEASE_DATE}")
endif (GIT_RELEASE_DATE)
if (GIT_RELEASE_BY)
set(keys ${keys} "Released-By: ${GIT_RELEASE_BY}")
endif (GIT_RELEASE_BY)
if (GIT_RELEASE_TAG)
set(keys ${keys} "Git-Tag: ${GIT_RELEASE_TAG}")
endif (GIT_RELEASE_TAG)
STRING(REGEX REPLACE ";" "\\n" keys "${keys}")
get_filename_component(dirname ${git_version_file} PATH)
file(MAKE_DIRECTORY "${dirname}")
file(WRITE "${git_version_file}" "${keys}\n")
endfunction(git_release_version_to_file_compat)
function(git_release_version_to_file git_version_file)
set(lines
"set(GIT_RELEASE_PACKAGE \"${CMAKE_PROJECT_NAME}\")")
set(lines ${lines}
"set(GIT_RELEASE_VERSION \"${GIT_RELEASE_VERSION}\")")
if (GIT_RELEASE_DATE)
set(lines ${lines}
"set(GIT_RELEASE_DATE \"${GIT_RELEASE_DATE}\")")
endif (GIT_RELEASE_DATE)
if (GIT_RELEASE_DATE_UNIX)
set(lines ${lines}
"set(GIT_RELEASE_DATE_UNIX \"${GIT_RELEASE_DATE_UNIX}\")")
endif (GIT_RELEASE_DATE_UNIX)
if (GIT_RELEASE_BY)
set(lines ${lines}
"set(GIT_RELEASE_BY \"${GIT_RELEASE_BY}\")")
endif (GIT_RELEASE_BY)
if (GIT_RELEASE_TAG)
set(lines ${lines}
"set(GIT_RELEASE_TAG \"${GIT_RELEASE_TAG}\")")
endif (GIT_RELEASE_TAG)
STRING(REGEX REPLACE ";" "\\n" lines "${lines}")
get_filename_component(dirname ${git_version_file} PATH)
file(MAKE_DIRECTORY "${dirname}")
file(WRITE "${git_version_file}" "${lines}\n")
endfunction(git_release_version_to_file)
function(git_release_version tag_match)
if(GIT_RELEASE_ENABLE OR GIT_DIST_ENABLE)
if (NOT GIT_RELEASE_VERSION)
message(FATAL_ERROR "GIT_RELEASE_VERSION not set; required if GIT_RELEASE_ENABLE or GIT_DIST_ENABLE is enabled")
endif (NOT GIT_RELEASE_VERSION)
else(GIT_RELEASE_ENABLE OR GIT_DIST_ENABLE)
if(EXISTS "${PROJECT_SOURCE_DIR}/${GIT_VERSION_FILE}")
message("Reading release metadata from ${GIT_VERSION_FILE}")
git_release_version_from_file("${PROJECT_SOURCE_DIR}/${GIT_VERSION_FILE}")
else(EXISTS "${PROJECT_SOURCE_DIR}/${GIT_VERSION_FILE}")
if(GIT_VERSION_FILE_USE_COMPAT AND EXISTS "${PROJECT_SOURCE_DIR}/${GIT_VERSION_FILE_COMPAT}")
message("Reading release metadata from ${GIT_VERSION_FILE_COMPAT}")
git_release_version_from_file_compat("${PROJECT_SOURCE_DIR}/${GIT_VERSION_FILE_COMPAT}")
else(GIT_VERSION_FILE_USE_COMPAT AND EXISTS "${PROJECT_SOURCE_DIR}/${GIT_VERSION_FILE_COMPAT}")
message("Reading release metadata from git")
git_release_version_from_git("${tag_match}")
endif(GIT_VERSION_FILE_USE_COMPAT AND EXISTS "${PROJECT_SOURCE_DIR}/${GIT_VERSION_FILE_COMPAT}")
endif(EXISTS "${PROJECT_SOURCE_DIR}/${GIT_VERSION_FILE}")
endif(GIT_RELEASE_ENABLE OR GIT_DIST_ENABLE)
git_release_version_split(${GIT_RELEASE_VERSION} major minor patch extra)
if(NOT GIT_RELEASE_DATE)
set(GIT_RELEASE_DATE "unreleased")
endif(NOT GIT_RELEASE_DATE)
if(NOT GIT_RELEASE_DATE_UNIX)
set(GIT_RELEASE_DATE_UNIX 0)
endif(NOT GIT_RELEASE_DATE_UNIX)
set(GIT_RELEASE_PACKAGE ${GIT_RELEASE_PACKAGE} PARENT_SCOPE)
set(GIT_RELEASE_VERSION ${GIT_RELEASE_VERSION} PARENT_SCOPE)
set(GIT_RELEASE_VERSION_MAJOR ${major} PARENT_SCOPE)
set(GIT_RELEASE_VERSION_MINOR ${minor} PARENT_SCOPE)
set(GIT_RELEASE_VERSION_PATCH ${patch} PARENT_SCOPE)
set(GIT_RELEASE_VERSION_EXTRA ${extra} PARENT_SCOPE)
set(GIT_RELEASE_DATE ${GIT_RELEASE_DATE} PARENT_SCOPE)
set(GIT_RELEASE_DATE_UNIX ${GIT_RELEASE_DATE_UNIX} PARENT_SCOPE)
set(GIT_RELEASE_BY ${GIT_RELEASE_BY} PARENT_SCOPE)
set(GIT_RELEASE_TAG ${GIT_RELEASE_TAG} PARENT_SCOPE)
endfunction(git_release_version)
if (NOT CMAKE_SCRIPT_MODE_FILE)
# Get initial version information
git_release_version("${GIT_RELEASE_TAG_MATCH}")
set(GIT_RELEASE_VERSION "${GIT_RELEASE_VERSION}"
CACHE STRING "Release version number")
mark_as_advanced(FORCE GIT_RELEASE_VERSION)
# Release tagging
set(GIT_RELEASE_TAG_OPTIONS "-s"
CACHE STRING "GPG release tagging options; signing enabled by default")
set(GIT_RELEASE_TAG_NAME "release/${CMAKE_PROJECT_NAME}-${GIT_RELEASE_VERSION}"
CACHE STRING "Naming scheme for release tags; must include version number")
set(GIT_RELEASE_TAG_MESSAGE "Release of ${CMAKE_PROJECT_NAME}-${GIT_RELEASE_VERSION}"
CACHE STRING "Message for release tags")
mark_as_advanced(FORCE GIT_RELEASE_TAG_OPTIONS GIT_RELEASE_TAG_NAME GIT_RELEASE_TAG_MESSAGE)
# Distribution tagging
set(GIT_DIST_TAG_OPTIONS "-s"
CACHE STRING "GPG distribution tagging options; signing enabled by default")
set(GIT_DIST_TAG_NAME distribution/${CMAKE_PROJECT_NAME}-${GIT_RELEASE_VERSION}
CACHE STRING "Naming scheme for distribution tags; must include version number")
set(GIT_DIST_TAG_MESSAGE "Distribution of ${CMAKE_PROJECT_NAME}-${GIT_RELEASE_VERSION}"
CACHE STRING "Message for distribution tags")
mark_as_advanced(FORCE GIT_DIST_TAG_OPTIONS GIT_DIST_TAG_NAME GIT_DIST_TAG_MESSAGE)
# Distribution branch commit
set(GIT_DIST_BRANCH distribution/${CMAKE_PROJECT_NAME}-${GIT_RELEASE_VERSION_MAJOR}.${GIT_RELEASE_VERSION_MINOR}
CACHE STRING "Branch to place distributed release on")
# Message for distribution commit
set(GIT_DIST_COMMIT_MESSAGE "Distribution of ${CMAKE_PROJECT_NAME} version ${GIT_RELEASE_VERSION}"
CACHE STRING "Message for distribution commit")
# Release directory to distribute
set(GIT_DIST_NAME ${CMAKE_PROJECT_NAME}-${GIT_RELEASE_VERSION}
CACHE STRING "Name of the release distribution; must include version number")
set(GIT_DIST_TMPDIR ${PROJECT_BINARY_DIR}/git-release
CACHE STRING "Temporary staging directory for release")
set(GIT_DIST_ROOT ${GIT_DIST_TMPDIR}/${GIT_DIST_NAME}
CACHE STRING "Release directory to distribute; must include version number")
mark_as_advanced(FORCE GIT_DIST_BRANCH GIT_DIST_COMMIT_MESSAGE GIT_DIST_NAME GIT_DIST_TMPDIR GIT_DIST_ROOT)
endif (NOT CMAKE_SCRIPT_MODE_FILE)
function(git_check_repo)
if(NOT EXISTS ${PROJECT_SOURCE_DIR}/.git)
message(FATAL_ERROR "Source directory ${PROJECT_SOURCE_DIR} is not a git repository")
endif(NOT EXISTS ${PROJECT_SOURCE_DIR}/.git)
endfunction(git_check_repo)
# Check that the working tree and index are clean prior to making any
# changes. If dirty, then the changes may be unreproducible and not
# match what was expected. For example, the distributed files may not
# match those actually committed or may not even be under version
# control.
#
# Project customisation:
# Checking of untracked files may be disabled by setting
# GIT_RELEASE_CHECK_UNTRACKED to OFF.
function(git_check_clean)
git_check_repo()
execute_process(COMMAND git diff-index --quiet HEAD
RESULT_VARIABLE diff_index_status
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR})
if(diff_index_status GREATER 1)
message(FATAL_ERROR "Error checking git index git diff-index: error status ${diff_index_status}")
endif(diff_index_status GREATER 1)
if(diff_index_status EQUAL 1)
if (GIT_RELEASE_CHECK_UNCOMMITTED)
message(FATAL_ERROR "Uncommitted changes in source directory")
else (GIT_RELEASE_CHECK_UNCOMMITTED)
message(WARNING "Uncommitted changes in source directory")
endif (GIT_RELEASE_CHECK_UNCOMMITTED)
endif(diff_index_status EQUAL 1)
if(diff_index_status EQUAL 0 OR diff_index_status EQUAL 1)
execute_process(COMMAND git ls-files --others --exclude-standard --error-unmatch .
OUTPUT_FILE /dev/null
ERROR_FILE /dev/null
RESULT_VARIABLE ls_files_status
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR})
# Exit status 1 is OK.
if(ls_files_status GREATER 1)
message(FATAL_ERROR "Error checking working directory with git ls-files: error status ${ls_files_status}")
endif(ls_files_status GREATER 1)
if(ls_files_status EQUAL 0)
if (GIT_RELEASE_CHECK_UNTRACKED)
message(FATAL_ERROR "Untracked files present in working directory")
else (GIT_RELEASE_CHECK_UNTRACKED)
message(WARNING "Untracked files present in working directory")
endif (GIT_RELEASE_CHECK_UNTRACKED)
endif(ls_files_status EQUAL 0)
endif(diff_index_status EQUAL 0 OR diff_index_status EQUAL 1)
endfunction(git_check_clean)
# Make a release.
#
# The current working tree is tagged as a new release. If the release
# tag already exists then the operation will do nothing if the tag
# matches the current working tree, or else it will abort with an
# error. If the repository has been accidentally tagged previously,
# then remove the tag with "git tag -d TAG" before releasing.
#
# NOTE: Set GIT_RELEASE_ENABLE=true when running make. This is a
# safety check to avoid accidental damage to the git repository.
#
# NOTE: Running release-git independently of dist-git is NOT
# RECOMMENDED. The distdir rule can update files in the working tree
# (for example, gettext translations in po/), so running "make
# distdir" prior to tagging the release will ensure the tagged release
# will not differ from the distributed release.
#
# Project customisation:
# The tag will be signed by default; set GIT_RELEASE_TAG_OPTIONS to
# alter. The tag will be named using GIT_RELEASE_TAG_NAME with the
# GIT_RELEASE_TAG_MESSAGE specifying an appropriate message for the
# tag.
function(git_release fail_if_tag_exists)
# Check if release tag exists
execute_process(COMMAND git show-ref --tags -q ${GIT_RELEASE_TAG_NAME}
RESULT_VARIABLE show_ref_status
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR})
if (show_ref_status EQUAL 0)
# Release tag already exists
if(fail_if_tag_exists)
message(FATAL_ERROR "git release tag ${GIT_RELEASE_TAG_NAME} already exists; not releasing")
else(fail_if_tag_exists)
message(STATUS "git release tag ${GIT_RELEASE_TAG_NAME} found")
endif(fail_if_tag_exists)
else(show_ref_status EQUAL 0)
# Release tag does not exist
if (NOT GIT_RELEASE_ENABLE)
message(FATAL_ERROR "GIT_RELEASE_ENABLE not set; not releasing")
endif (NOT GIT_RELEASE_ENABLE)
# Check repository is clean to tag
git_check_clean()
# Create release tag
message("Releasing ${CMAKE_PROJECT_NAME}-${GIT_RELEASE_VERSION}")
message("Creating git release tag ${GIT_RELEASE_TAG_NAME}")
execute_process(COMMAND git tag -m "${GIT_RELEASE_TAG_MESSAGE}"
${GIT_RELEASE_TAG_OPTIONS} "${GIT_RELEASE_TAG_NAME}"
HEAD
RESULT_VARIABLE tag_status
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR})
if(tag_status GREATER 0)
message(FATAL_ERROR "Failed to create release tag ${GIT_RELEASE_TAG_NAME}: error status ${tag_status}")
endif(tag_status GREATER 0)
message(STATUS "${CMAKE_PROJECT_NAME} ${GIT_RELEASE_VERSION} release tagged as ${GIT_RELEASE_TAG_NAME}")
endif (show_ref_status EQUAL 0)
endfunction(git_release)
# Make a distribution of a release.
#
# A distribution is created and committed onto the specified branch.
# The commit is then tagged. The distribution commit will have the
# release commit and the previous distribution (if any) as its
# parents. Thus distribution releases appear to git as merges (with
# the exception of the initial release).
#
# NOTE: Set GIT_DIST_ENABLE=true when running make, plus
# GIT_RELEASE_ENABLE=true if the working tree has not already been
# tagged with a release tag. This is a safety check to avoid
# accidental damage to the git repository.
#
# Project customisation:
# GIT_DIST_COMMIT_MESSAGE specifies the commit message for the commit,
# and GIT_DIST_BRANCH specifies the branch to add the commit to.
# The tag will be signed by default; set GIT_DIST_TAG_OPTIONS to
# alter. The tag will be named using GIT_DIST_TAG_NAME with the
# GIT_DIST_TAG_MESSAGE specifying an appropriate message for the
# tag.
function(git_rev_parse ref var)
execute_process(COMMAND git rev-parse ${ref}
OUTPUT_VARIABLE rev_parse_output
RESULT_VARIABLE rev_parse_status
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR})
if(rev_parse_status GREATER 0)
message(FATAL_ERROR "git rev-parse failed to parse ref ${ref}")
endif(rev_parse_status GREATER 0)
string(REPLACE "\n" "" rev_parse_output "${rev_parse_output}")
set(${var} ${rev_parse_output} PARENT_SCOPE)
endfunction(git_rev_parse)
function(git_archive_tree)
# TODO: Add full export.
file(REMOVE_RECURSE "${GIT_DIST_TMPDIR}")
file(MAKE_DIRECTORY "${GIT_DIST_TMPDIR}")
execute_process(COMMAND git archive --prefix "${GIT_DIST_NAME}/"
-o "${GIT_DIST_TMPDIR}/tmp.tar" "${GIT_RELEASE_TAG_NAME}"
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR})
execute_process(COMMAND tar -xf tmp.tar
WORKING_DIRECTORY "${GIT_DIST_TMPDIR}")
file(REMOVE "${GIT_DIST_TMPDIR}/tmp.tar")
endfunction(git_archive_tree)
function(git_dist)
git_release(OFF)
git_rev_parse("${GIT_RELEASE_TAG_NAME}^{}" release_commit)
git_rev_parse(HEAD head_commit)
if(NOT ${release_commit} STREQUAL ${head_commit})
message(FATAL_ERROR "Working directory is not at release tag ${GIT_RELEASE_TAG_NAME}^{} (commit ${release_commit}); not distributing")
endif(NOT ${release_commit} STREQUAL ${head_commit})
git_check_clean()
git_archive_tree()
git_release_version_from_git_tag("${GIT_RELEASE_TAG_NAME}" TRUE)
git_release_version_to_file("${GIT_DIST_ROOT}/${GIT_VERSION_FILE}")
if(GIT_VERSION_FILE_USE_COMPAT)
git_release_version_to_file_compat("${GIT_DIST_ROOT}/${GIT_VERSION_FILE_COMPAT}")
endif(GIT_VERSION_FILE_USE_COMPAT)
git_dist_generic()
endfunction(git_dist)
# Make a distribution of an arbitrary release.
#
# The same as git_dist, but this allows addition of any distribution
# rather than just the release in the current working tree. This rule
# is intended for allowing retrospective addition of a project's
# entire release history (driven by a shell script), for example.
# See below for an example of how to do this.
#
# GIT_DIST_ROOT must be set to specify the release to distribute and
# GIT_RELEASE_VERSION must match the release version. GIT_DIST_BRANCH may also
# require setting if not using the default. GIT_RELEASE_TAG_NAME must
# be set to the tag name of the existing release.
function(git_dist_generic)
git_check_repo()
execute_process(COMMAND git show-ref --tags -q ${GIT_DIST_TAG_NAME}
RESULT_VARIABLE show_ref_status
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR})
if (show_ref_status EQUAL 0)
message(FATAL_ERROR "git dist tag ${GIT_DIST_TAG_NAME} already exists; not distributing")
endif (show_ref_status EQUAL 0)
if (NOT GIT_DIST_ENABLE)
message(FATAL_ERROR "GIT_DIST_ENABLE not set; not distributing")
endif (NOT GIT_DIST_ENABLE)
message("Distributing ${CMAKE_PROJECT_NAME}-${GIT_RELEASE_VERSION} on git branch ${GIT_DIST_BRANCH}")
set(dist_index "${GIT_DIST_TMPDIR}/index")
if(EXISTS ${dist_index})
file(REMOVE ${dist_index})
endif(EXISTS ${dist_index})
set(ENV{GIT_INDEX_FILE} ${dist_index})
set(ENV{GIT_WORK_TREE} ${GIT_DIST_ROOT})
execute_process(COMMAND git add -A -f
RESULT_VARIABLE git_add_status
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR})
unset(ENV{GIT_WORK_TREE})
if(git_add_status GREATER 0)
message(FATAL_ERROR "Failed to add archive tree to git index")
endif(git_add_status GREATER 0)
execute_process(COMMAND git write-tree
OUTPUT_VARIABLE tree
RESULT_VARIABLE git_write_tree_status
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR})
string(REPLACE "\n" "" tree "${tree}")
if(git_tree_write_status GREATER 0)
message(FATAL_ERROR "Failed to write git index to tree")
endif(git_tree_write_status GREATER 0)
unset(ENV{GIT_INDEX_FILE})
file(REMOVE ${dist_index})
string(LENGTH ${tree} tree_length)
if (tree_length EQUAL 0)
message(FATAL_ERROR "Failed to get tree hash")
endif (tree_length EQUAL 0)
git_rev_parse("${GIT_RELEASE_TAG_NAME}^{}" release_commit)
set(commit_options -p ${release_commit})
execute_process(COMMAND git show-ref --heads -s refs/heads/${GIT_DIST_BRANCH}
OUTPUT_VARIABLE dist_parent
RESULT_VARIABLE show_ref_status
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR})
string(REPLACE "\n" "" dist_parent "${dist_parent}")
if (show_ref_status GREATER 0)
set(newroot "(root-commit) ")
else (show_ref_status GREATER 0)
set(commit_opts ${commit_opts} -p ${dist_parent})
endif (show_ref_status GREATER 0)
file(WRITE "${GIT_DIST_TMPDIR}/commit-message" "${GIT_DIST_COMMIT_MESSAGE}")
execute_process(COMMAND git commit-tree -F "${GIT_DIST_TMPDIR}/commit-message" "${tree}" ${commit_options}
OUTPUT_VARIABLE commit
RESULT_VARIABLE commit_status
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR})
file(REMOVE "${GIT_DIST_TMPDIR}/commit-message")
string(REPLACE "\n" "" commit "${commit}")
if (commit_status GREATER 0)
message(FATAL_ERROR "Failed to commit tree")
endif (commit_status GREATER 0)
string(LENGTH ${commit} commit_length)
if(${commit_length} EQUAL 0)
message(FATAL_ERROR "Failed to get commit hash")
endif(${commit_length} EQUAL 0)
execute_process(COMMAND git update-ref "refs/heads/${GIT_DIST_BRANCH}" ${commit} ${dist_parent}
RESULT_VARIABLE update_ref_status
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR})
if (update_ref_status GREATER 0)
message(FATAL_ERROR "Failed to update reference for commit")
endif (update_ref_status GREATER 0)
message("[${GIT_DIST_BRANCH} ${newroot}${commit}] ${GIT_DIST_COMMIT_MESSAGE}")
message("Creating git distribution tag ${GIT_DIST_TAG_NAME}")
execute_process(COMMAND git tag -m "${GIT_DIST_TAG_MESSAGE}" ${GIT_DIST_TAG_OPTIONS} "${GIT_DIST_TAG_NAME}" ${commit}
RESULT_VARIABLE tag_status
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR})
if(tag_status GREATER 0)
message(FATAL_ERROR "Failed to create distribution tag ${GIT_DIST_TAG_NAME}: error status ${tag_status}")
endif(tag_status GREATER 0)
message(STATUS "${CMAKE_PROJECT_NAME} ${GIT_RELEASE_VERSION} distribution tagged as ${GIT_DIST_TAG_NAME}")
endfunction(git_dist_generic)
# Add targets if not in script mode
if (NOT CMAKE_SCRIPT_MODE_FILE)
set(script_options
-D CMAKE_PROJECT_NAME=${CMAKE_PROJECT_NAME}
-D PROJECT_SOURCE_DIR=${PROJECT_SOURCE_DIR}
-D PROJECT_BINARY_DIR=${PROJECT_BINARY_DIR})
if (GIT_RELEASE_ENABLE OR GIT_DIST_ENABLE)
# Preserve current configuration in a form which may be sourced by
# a standalone script file.
file(WRITE "${CMAKE_BINARY_DIR}/git-release-settings.cmake"
"set(GIT_VERSION_FILE \"${GIT_VERSION_FILE}\")
set(GIT_VERSION_FILE_COMPAT \"${GIT_VERSION_FILE_COMPAT}\")
set(GIT_VERSION_FILE_USE_COMPAT \"${GIT_VERSION_FILE_USE_COMPAT}\")
set(GIT_RELEASE_VERSION \"${GIT_RELEASE_VERSION}\")
set(GIT_RELEASE_CHECK_UNCOMMITTED ${GIT_RELEASE_CHECK_UNCOMMITTED})
set(GIT_RELEASE_CHECK_UNTRACKED ${GIT_RELEASE_CHECK_UNTRACKED})
set(GIT_RELEASE_ENABLE ${GIT_RELEASE_ENABLE})
set(GIT_RELEASE_TAG_OPTIONS \"${GIT_RELEASE_TAG_OPTIONS}\")
set(GIT_RELEASE_TAG_NAME \"${GIT_RELEASE_TAG_NAME}\")
set(GIT_RELEASE_TAG_MATCH \"${GIT_RELEASE_TAG_MATCH}\")
set(GIT_RELEASE_TAG_REGEX \"${GIT_RELEASE_TAG_REGEX}\")
set(GIT_RELEASE_TAG_MESSAGE \"${GIT_RELEASE_TAG_MESSAGE}\")
set(GIT_DIST_ENABLE ${GIT_DIST_ENABLE})
set(GIT_DIST_TAG_OPTIONS \"${GIT_DIST_TAG_OPTIONS}\")
set(GIT_DIST_TAG_NAME \"${GIT_DIST_TAG_NAME}\")
set(GIT_DIST_TAG_MESSAGE \"${GIT_DIST_TAG_MESSAGE}\")
set(GIT_DIST_BRANCH \"${GIT_DIST_BRANCH}\")
set(GIT_DIST_COMMIT_MESSAGE \"${GIT_DIST_COMMIT_MESSAGE}\")
set(GIT_DIST_NAME \"${GIT_DIST_NAME}\")
set(GIT_DIST_TMPDIR \"${GIT_DIST_TMPDIR}\")
set(GIT_DIST_ROOT \"${GIT_DIST_ROOT}\")
")
# The following targets re-execute this script file with the above
# configuration.
add_custom_target(git-check-repo
COMMAND ${CMAKE_COMMAND} ${script_options}
-D git_release_command=git-check-repo
-P ${CMAKE_CURRENT_LIST_FILE})
endif (GIT_RELEASE_ENABLE OR GIT_DIST_ENABLE)
if (GIT_RELEASE_ENABLE)
add_custom_target(git-check-clean
COMMAND ${CMAKE_COMMAND} ${script_options}
-D PROJECT_SOURCE_DIR=${PROJECT_SOURCE_DIR}
-D git_release_command=git-check-clean
-P ${CMAKE_CURRENT_LIST_FILE})
add_custom_target(git-release
COMMAND ${CMAKE_COMMAND} ${script_options}
-D PROJECT_SOURCE_DIR=${PROJECT_SOURCE_DIR}
-D git_release_command=git-release
-P ${CMAKE_CURRENT_LIST_FILE})
endif (GIT_RELEASE_ENABLE)
if (GIT_DIST_ENABLE)
add_custom_target(git-dist
COMMAND ${CMAKE_COMMAND} ${script_options}
-D PROJECT_SOURCE_DIR=${PROJECT_SOURCE_DIR}
-D git_release_command=git-dist
-P ${CMAKE_CURRENT_LIST_FILE})
endif (GIT_DIST_ENABLE)
endif (NOT CMAKE_SCRIPT_MODE_FILE)
# In script mode, run specified command
if (CMAKE_SCRIPT_MODE_FILE)
if(git_release_command)
if(git_release_command STREQUAL git-check-repo)
git_check_repo()
endif(git_release_command STREQUAL git-check-repo)
if(git_release_command STREQUAL git-check-clean)
git_check_clean()
endif(git_release_command STREQUAL git-check-clean)
if(git_release_command STREQUAL git-release)
git_release(ON)
endif(git_release_command STREQUAL git-release)
if(git_release_command STREQUAL git-dist)
git_dist()
endif(git_release_command STREQUAL git-dist)
endif(git_release_command)
endif (CMAKE_SCRIPT_MODE_FILE)
# Example: How to retrospectively insert the complete distribution
# history for a project. Note: GIT_RELEASE_TAG_NAME must match the
# pattern used to tag all previous releases since this requires tags
# for all releases.
#
# #!/bin/sh
#
# set -e
#
# # Clean up any existing distribution branches and tags which could
# # interfere with addition of a complete clean distribution history.
# git tag -l | grep distribution | while read tag; do
# git tag -d $tag
# done;
# git branch -l | grep distribution | while read branch; do
# git branch -D $branch
# done;
#
# # Read an ordered list of versions from release-versions and get
# # distribution for each version from the given path and distribute
# # in git
# while read version; do
# make git_dist_generic GIT_DIST_ROOT="/path/to/unpacked/releases/$package-$version" GIT_RELEASE_VERSION="$version" GIT_DIST_ENABLE=true
# done < release-versions
# Example: How to check that the added distributions are correctly
# representing the content of the old distributed releases following
# import as in the above example.
#
# #!/bin/sh
#
# set -e
#
# # For each version in the list of releases, check out and unpack
# # that version, and then compare it with the original.
# while read version; do
# git checkout distribution/package-$version
# rm -rf /tmp/package-$version
# mkdir /tmp/package-$version
# git archive HEAD | tar -x -C /tmp/$package-$version
# diff -urN /tmp/$package-$version "/path/to/unpacked/releases/$package-$version" | lsdiff
# rm -rf /tmp/package-$version
# done < release-versions
-------------- next part --------------
A non-text attachment was scrubbed...
Name: not available
Type: application/pgp-signature
Size: 836 bytes
Desc: Digital signature
URL: <http://www.cmake.org/pipermail/cmake/attachments/20130923/d93ad40d/attachment-0001.pgp>
More information about the CMake
mailing list