class AbstractContext(object):
result: Result = None
def __init__(self):
self.result = Result()
def warn(self, message, reason):
self.result.warn(message, reason)
def error(self, exit_code, message, reason, throw: bool = False):
self.result.error(exit_code, message, reason, throw)
def fail(self, exit_code, message, reason):
self.result.fail(exit_code, message, reason)
def add_subresult(self, subresult):
self.result.add_subresult(subresult)
def has_errors(self):
return self.result.has_errors()
def abort_on_error(self):
return self.result.abort_on_error()
def abort(self):
return self.result.abort()
def version_bump_to_release(version_config: VersionConfig,
version: Optional[str], global_seq: Optional[int]):
result = Result()
version_info = semver.parse_version_info(
version) if version is not None else semver.parse_version_info("0.0.0")
if version_config.versioning_scheme == VersioningScheme.SEMVER_WITH_SEQ:
result.error(
os.EX_USAGE,
_("Failed to increment version to release: {version}.").format(
version=repr(version)),
_("Sequential versions cannot be release versions."))
return result
if not version_info.prerelease:
result.error(
os.EX_DATAERR,
_("Failed to increment version to release: {version}.").format(
version=repr(version)),
_("Only pre-release versions can be incremented to a release version."
))
if not result.has_errors():
result.value = semver.format_version(version_info.major,
version_info.minor,
version_info.patch, None, None)
return result
def version_bump_qualifier(version_config: VersionConfig,
version: Optional[str], global_seq: Optional[int]):
result = Result()
version_info = semver.parse_version_info(
version) if version is not None else semver.parse_version_info("0.0.0")
new_qualifier = None
if not version_config.qualifiers:
result.error(
os.EX_USAGE,
_("Failed to increment the pre-release qualifier of version {version}."
).format(version=repr(version)),
_("The version scheme does not contain qualifiers"))
return result
if version_info.prerelease:
prerelease_version_elements = version_info.prerelease.split(".")
qualifier = prerelease_version_elements[0]
qualifier_index = version_config.qualifiers.index(
qualifier) if qualifier in version_config.qualifiers else -1
if qualifier_index < 0:
result.error(
os.EX_DATAERR,
_("Failed to increment the pre-release qualifier of version {version}."
).format(version=repr(version)),
_("The current qualifier is invalid: {qualifier}").format(
qualifier=repr(qualifier)))
else:
qualifier_index += 1
if qualifier_index < len(version_config.qualifiers):
new_qualifier = version_config.qualifiers[qualifier_index]
else:
result.error(
os.EX_DATAERR,
_("Failed to increment the pre-release qualifier {qualifier} of version {version}."
).format(qualifier=qualifier, version=repr(version)),
_("There are no further qualifiers with higher precedence, configured qualifiers are:\n"
"{listing}\n"
"The sub command 'bump-to-release' may be used for a final bump."
).format(listing='\n'.join(
' - ' + repr(qualifier)
for qualifier in version_config.qualifiers)))
else:
result.error(
os.EX_DATAERR,
_("Failed to increment the pre-release qualifier of version {version}."
).format(version=version),
_("Pre-release increments cannot be performed on release versions."
))
if not result.has_errors() and new_qualifier is not None:
result.value = semver.format_version(version_info.major,
version_info.minor,
version_info.patch,
new_qualifier + ".1", None)
return result
def version_bump_prerelease(version_config: VersionConfig,
version: Optional[str], global_seq: Optional[int]):
result = Result()
version_info = semver.parse_version_info(
version) if version is not None else semver.parse_version_info("0.0.0")
if version_info.prerelease:
prerelease_version_elements = version_info.prerelease.split(".")
if len(prerelease_version_elements
) > 0 and prerelease_version_elements[0].upper() == "SNAPSHOT":
if len(prerelease_version_elements) == 1:
result.error(
os.EX_DATAERR,
_("The pre-release increment has been skipped."),
_("In order to retain Maven compatibility, "
"the pre-release component of snapshot versions must not be versioned."
))
else:
result.error(
os.EX_DATAERR,
_("Failed to increment the pre-release component of version {version}."
).format(version=repr(version)),
_("Snapshot versions must not have a pre-release version.")
)
result.value = version
elif len(prerelease_version_elements) == 1:
if version_config.versioning_scheme != VersioningScheme.SEMVER_WITH_SEQ:
result.error(
os.EX_DATAERR,
_("Failed to increment the pre-release component of version {version}."
).format(version=repr(version)),
_("The qualifier {qualifier} must already be versioned.").
format(qualifier=repr(prerelease_version_elements[0])))
result.value = semver.bump_prerelease(version)
else:
result.error(
os.EX_DATAERR,
_("Failed to increment the pre-release component of version {version}."
).format(version=repr(version)),
_("Pre-release increments cannot be performed on release versions."
))
if result.has_errors():
result.value = None
elif result.value is not None and not semver.compare(
result.value, version) > 0:
result.value = None
if not result.value:
result.error(
os.EX_SOFTWARE,
_("Failed to increment the pre-release of version {version} for unknown reasons."
).format(version=repr(version)), None)
return result
def evaluate_version_increment(a: Version, b: Version, strict: bool, prerelase_keywords_list: list = None):
result = Result()
initial_version = Version()
initial_version.major = 1
initial_version.minor = 0
initial_version.patch = 0
if prerelase_keywords_list is not None and len(prerelase_keywords_list):
initial_version.prerelease = list()
for index, token_config in enumerate(prerelase_keywords_list):
if token_config is not None:
if isinstance(token_config, list) and len(token_config):
initial_version.prerelease.append(token_config[0])
elif isinstance(token_config, int):
initial_version.prerelease.append(token_config)
else:
raise ValueError()
else:
initial_version.prerelease.append(0)
reset = False
reset = evaluate_numeric_increment(result, 'major', reset, initial_version.major, strict, a.major, b.major)
reset = evaluate_numeric_increment(result, 'minor', reset, initial_version.minor, strict, a.minor, b.minor)
reset = evaluate_numeric_increment(result, 'patch', reset, initial_version.patch, strict, a.patch, b.patch)
# check pre-release convention
index = 0
for sub_a, sub_b in itertools.zip_longest(a.prerelease or [],
b.prerelease or []):
keywords = prerelase_keywords_list[index] \
if prerelase_keywords_list is not None \
and index < len(prerelase_keywords_list) \
else None
reset = evaluate_prerelease_increment(result, "prerelease", index,
reset, initial_version.prerelease[index]
if initial_version.prerelease is not None
and index < len(initial_version.prerelease)
else 0,
strict, sub_a, sub_b, keywords)
index += 1
if result.has_errors():
result.error(os.EX_USAGE if strict else os.EX_OK,
_("Version increment is flawed."),
_("A version increment from {version_a} to {version_b} is inconsistent.")
.format(version_a=repr(format_version(a)), version_b=repr(format_version(b)))
)
return result
def download_file(source_uri: str, dest_file: str, hash_hex: str):
from urllib import request
import hashlib
result = Result()
hash = bytes.fromhex(hash_hex)
download = False
if not os.path.exists(dest_file):
cli.print("file does not exist: " + dest_file)
download = True
elif hash_file(hashlib.sha256(), dest_file) != hash:
cli.print("file hash does not match: " + dest_file)
download = True
else:
cli.print("keeping file: " + dest_file + ", sha256 matched: " +
hash_hex)
if download:
cli.print("downloading: " + source_uri + " to " + dest_file)
request.urlretrieve(url=str(source_uri), filename=dest_file + "~")
filesystem.replace_file(dest_file + "~", dest_file)
if hash is not None:
actual_hash = hash_file(hashlib.sha256(), dest_file)
if actual_hash != hash:
result.error(
os.EX_IOERR, _("File verification failed."),
_("The file {file} is expected to hash to {expected_hash},\n"
"The actual hash is: {actual_hash}").format(
file=repr(dest_file),
expected_hash=repr(hash_hex),
actual_hash=repr(actual_hash.hex()),
))
if not result.has_errors():
result.value = dest_file
return result
def version_bump_patch(version_config: VersionConfig, version: Optional[str],
global_seq: Optional[int]):
result = Result()
try:
global_seq = filter_sequence_number(version_config, version,
global_seq)
except ValueError as e:
result.error(os.EX_DATAERR, "version increment failed", str(e))
if not result.has_errors():
version_info = semver.parse_version_info(
semver.bump_patch(version)
) if version is not None else semver.parse_version_info("0.0.0")
pre_release = True
result.value = semver.format_version(
version_info.major, version_info.minor, version_info.patch,
(version_config.qualifiers[0] +
".1" if pre_release else None) if version_config.versioning_scheme
!= VersioningScheme.SEMVER_WITH_SEQ else global_seq + 1, None)
return result
def clone_repository(context: Context, branch: str) -> Result:
"""
:rtype: Result
"""
result = Result()
remote = repotools.git_get_remote(context.repo, context.config.remote_name)
if remote is None:
result.fail(
os.EX_DATAERR, _("Failed to clone repo."),
_("The remote {remote} does not exist.").format(
remote=repr(context.config.remote_name)))
tempdir_path = tempfile.mkdtemp(prefix=os.path.basename(context.repo.dir) +
".gitflow-clone.")
try:
if os.path.exists(tempdir_path):
os.chmod(path=tempdir_path, mode=0o700)
if os.path.isdir(tempdir_path):
if os.listdir(tempdir_path):
result.fail(
os.EX_DATAERR, _("Failed to clone repo."),
_("Directory is not empty: {path}").format(
path=tempdir_path))
else:
result.fail(
os.EX_DATAERR, _("Failed to clone repo."),
_("File is not a directory: {path}").format(
path=tempdir_path))
else:
result.fail(
os.EX_DATAERR, _("Failed to clone repo."),
_("File does not exist: {path}").format(path=tempdir_path))
if context.config.push_to_local:
returncode, out, err = repotools.git_raw(git=context.repo.git,
args=[
'clone', '--branch',
branch, '--shared',
context.repo.dir,
tempdir_path
],
verbose=context.verbose)
else:
returncode, out, err = repotools.git_raw(git=context.repo.git,
args=[
'clone', '--branch',
branch, '--reference',
context.repo.dir,
remote.url,
tempdir_path
],
verbose=context.verbose)
if returncode != os.EX_OK:
result.error(os.EX_DATAERR, _("Failed to clone the repository."),
_("An unexpected error occurred."))
except:
result.error(os.EX_DATAERR, _("Failed to clone the repository."),
_("An unexpected error occurred."))
finally:
context.add_subresult(result)
if not result.has_errors():
repo = RepoContext()
repo.git = context.repo.git
repo.dir = tempdir_path
repo.verbose = context.repo.verbose
result.value = repo
else:
shutil.rmtree(path=tempdir_path)
return result
def main(argv: list = sys.argv) -> int:
if ENABLE_PROFILER:
import cProfile
profiler = cProfile.Profile()
profiler.enable()
else:
profiler = None
result = Result()
args = docopt.docopt(argv=argv[1:], doc=__doc__, version=const.VERSION, help=True, options_first=False)
try:
context = Context.create(args, result)
except GitFlowException as e:
context = None
pass # errors are in result
if context is not None:
try:
if context.verbose >= const.DEBUG_VERBOSITY:
cli.print("GitFlow version: " + const.VERSION)
cli.print("Python version:" + sys.version.replace('\n', ' '))
cli.print("cwd: " + os.getcwd())
if args['--hook'] is not None:
if context.verbose >= const.TRACE_VERBOSITY:
cli.print('hook=' + args['--hook'])
hook_func = cli.get_cmd([
hook_pre_commit,
hook_pre_push,
], args['--hook'], 'hook_')
try:
hook_result = hook_func(context)
except GitFlowException as e:
hook_result = e.result
result.errors.extend(hook_result.errors)
else:
commands = {
'status': cmd_status,
'bump-major': cmd_bump_major,
'bump-minor': cmd_bump_minor,
'bump-patch': cmd_bump_patch,
'bump-prerelease-type': cmd_bump_prerelease_type,
'bump-prerelease': cmd_bump_prerelease,
'bump-to-release': cmd_bump_to_release,
'bump-to': cmd_bump_to,
'discontinue': cmd_discontinue,
'start': cmd_start,
'finish': cmd_finish,
'log': cmd_log,
'assemble': cmd_build,
'test': cmd_build,
'integration-test': cmd_build,
'drop-cache': cmd_drop_cache,
'convert-config': cmd_convert_config,
}
command_funcs = list()
for command_name, command_func in commands.items():
if args[command_name] is True:
command_funcs.append(command_func)
if not len(command_funcs):
cli.fail(os.EX_SOFTWARE, "unimplemented command")
if context.verbose >= const.TRACE_VERBOSITY:
cli.print("commands: " + repr(command_funcs))
start_branch = repotools.git_get_current_branch(context.repo) if context.repo is not None else None
for command_func in command_funcs:
try:
command_result = command_func(context)
except GitFlowException as e:
command_result = e.result
result.errors.extend(command_result.errors)
if result.has_errors():
break
current_branch = repotools.git_get_current_branch(context.repo) if context.repo is not None else None
if current_branch is not None and current_branch != start_branch:
cli.print(_("You are now on {branch}.")
.format(branch=repr(current_branch.short_name) if current_branch is not None else '-'))
finally:
context.cleanup()
exit_code = os.EX_OK
if len(result.errors):
sys.stderr.flush()
sys.stdout.flush()
for error in result.errors:
if error.exit_code != os.EX_OK and exit_code != os.EX_SOFTWARE:
exit_code = error.exit_code
cli.eprint('\n'.join(filter(None, [error.message, error.reason])))
# print dry run status, if possible
if context is not None:
if exit_code == os.EX_OK:
if context.dry_run:
cli.print('')
cli.print("dry run succeeded")
else:
pass
else:
if context.dry_run:
cli.print('')
cli.eprint("dry run failed")
else:
pass
if profiler is not None:
profiler.disable()
# pr.dump_stats('profile.pstat')
profiler.print_stats(sort="calls")
return exit_code
def create_version_branch(command_context: CommandContext,
operation: Callable[[VersionConfig, Optional[str], Optional[int]], Result]) -> Result:
result = Result()
context: Context = command_context.context
if command_context.selected_ref.name not in [
repotools.create_ref_name(const.LOCAL_BRANCH_PREFIX, context.config.release_branch_base),
repotools.create_ref_name(const.REMOTES_PREFIX,
context.config.remote_name,
context.config.release_branch_base)]:
result.fail(os.EX_USAGE,
_("Failed to create release branch based on {branch}.")
.format(branch=repr(command_context.selected_ref.name)),
_("Release branches (major.minor) can only be created off {branch}")
.format(branch=repr(context.config.release_branch_base))
)
existing_release_branches = list(repotools.git_list_refs(context.repo, repotools.ref_name([
const.REMOTES_PREFIX,
context.config.remote_name,
'release'])))
release_branch_merge_bases = dict()
for release_branch in context.get_release_branches():
merge_base = repotools.git_merge_base(context.repo, context.config.release_branch_base, release_branch)
if merge_base is None:
result.fail(os.EX_DATAERR,
"Failed to resolve merge base.",
None)
branch_refs = release_branch_merge_bases.get(merge_base)
if branch_refs is None:
release_branch_merge_bases[merge_base] = branch_refs = list()
branch_refs.append(release_branch)
latest_branch = None
branch_points_on_same_commit = list()
subsequent_branches = list()
for history_commit in repotools.git_list_commits(
context=context.repo,
start=None,
end=command_context.selected_commit,
options=const.BRANCH_COMMIT_SCAN_OPTIONS):
branch_refs = release_branch_merge_bases.get(history_commit.obj_name)
if branch_refs is not None and len(branch_refs):
branch_refs = list(
filter(lambda tag_ref: context.release_branch_matcher.format(tag_ref.name) is not None,
branch_refs))
if not len(branch_refs):
continue
branch_refs.sort(
reverse=True,
key=utils.cmp_to_key(
lambda tag_ref_a, tag_ref_b: semver.compare(
context.release_branch_matcher.format(tag_ref_a.name),
context.release_branch_matcher.format(tag_ref_b.name)
)
)
)
if latest_branch is None:
latest_branch = branch_refs[0]
if history_commit.obj_name == command_context.selected_commit:
branch_points_on_same_commit.extend(branch_refs)
# for tag_ref in tag_refs:
# print('<<' + tag_ref.name)
break
for history_commit in repotools.git_list_commits(context.repo,
command_context.selected_commit,
command_context.selected_ref):
branch_refs = release_branch_merge_bases.get(history_commit.obj_name)
if branch_refs is not None and len(branch_refs):
branch_refs = list(
filter(lambda tag_ref: context.release_branch_matcher.format(tag_ref.name) is not None,
branch_refs))
if not len(branch_refs):
continue
branch_refs.sort(
reverse=True,
key=utils.cmp_to_key(
lambda tag_ref_a, tag_ref_b: semver.compare(
context.release_branch_matcher.format(tag_ref_a.name),
context.release_branch_matcher.format(tag_ref_b.name)
)
)
)
# for tag_ref in tag_refs:
# print('>>' + tag_ref.name)
subsequent_branches.extend(branch_refs)
if context.verbose:
cli.print("Branches on same commit:\n"
+ '\n'.join(' - ' + repr(tag_ref.name) for tag_ref in branch_points_on_same_commit))
cli.print("Subsequent branches:\n"
+ '\n'.join(' - ' + repr(tag_ref.name) for tag_ref in subsequent_branches))
if latest_branch is not None:
latest_branch_version = context.release_branch_matcher.format(latest_branch.name)
latest_branch_version_info = semver.parse_version_info(latest_branch_version)
else:
latest_branch_version = None
latest_branch_version_info = None
if latest_branch_version is not None:
version_result = operation(context.config.version_config, latest_branch_version,
get_global_sequence_number(context))
result.add_subresult(version_result)
new_version = version_result.value
new_version_info = semver.parse_version_info(new_version)
else:
new_version_info = semver.parse_version_info(context.config.version_config.initial_version)
new_version = version.format_version_info(new_version_info)
scheme_procedures.get_sequence_number(context.config.version_config, new_version_info)
if context.config.sequential_versioning:
new_sequential_version = create_sequence_number_for_version(context, new_version)
else:
new_sequential_version = None
try:
config_in_selected_commit = read_config_in_commit(context.repo, command_context.selected_commit)
except FileNotFoundError:
config_in_selected_commit = dict()
try:
properties_in_selected_commit = read_properties_in_commit(context,
context.repo,
config_in_selected_commit,
command_context.selected_commit)
except FileNotFoundError:
properties_in_selected_commit = dict()
if not context.config.allow_shared_release_branch_base and len(branch_points_on_same_commit):
result.fail(os.EX_USAGE,
_("Branch creation failed."),
_("Release branches cannot share a common ancestor commit.\n"
"Existing branches on commit {commit}:\n"
"{listing}")
.format(commit=command_context.selected_commit,
listing='\n'.join(' - ' + repr(tag_ref.name) for tag_ref in branch_points_on_same_commit)))
if len(subsequent_branches):
result.fail(os.EX_USAGE,
_("Branch creation failed."),
_("Subsequent release branches in history: %s\n")
% '\n'.join(' - ' + repr(tag_ref.name) for tag_ref in subsequent_branches))
if context.config.tie_sequential_version_to_semantic_version \
and len(existing_release_branches):
prompt_result = prompt_for_confirmation(
context=context,
fail_title=_("Failed to create release branch based on {branch}.")
.format(branch=repr(command_context.selected_ref.name)),
message=_("This operation disables version increments "
"on all existing release branches.\n"
"Affected branches are:\n"
"{listing}")
.format(listing=os.linesep.join(repr(branch.name) for branch in existing_release_branches))
if not context.config.commit_version_property
else _("This operation disables version increments on all existing branches.\n"
"Affected branches are:\n"
"{listing}")
.format(listing=os.linesep.join(repr(branch.name) for branch in existing_release_branches)),
prompt=_("Continue?"),
)
result.add_subresult(prompt_result)
if result.has_errors() or not prompt_result.value:
return result
if not result.has_errors():
if new_version is None:
result.error(os.EX_SOFTWARE,
_("Internal error."),
_("Missing result version.")
)
if latest_branch_version is not None and semver.compare(latest_branch_version, new_version) >= 0:
result.error(os.EX_DATAERR,
_("Failed to increment version from {current_version} to {new_version}.")
.format(current_version=repr(latest_branch_version), new_version=repr(new_version)),
_("The new version is lower than or equal to the current version.")
)
result.abort_on_error()
branch_name = get_branch_name_for_version(context, new_version_info)
tag_name = get_tag_name_for_version(context, new_version_info)
clone_result = clone_repository(context, context.config.release_branch_base)
cloned_repo: RepoContext = clone_result.value
# run version change hooks on new release branch
git_or_fail(cloned_repo, result, ['checkout', '--force',
'-b', branch_name,
command_context.selected_commit],
_("Failed to check out release branch."))
clone_context: Context = create_temp_context(context, result, cloned_repo.dir)
clone_context.config.remote_name = 'origin'
commit_info = CommitInfo()
commit_info.add_message("#version: " + cli.if_none(new_version))
if (context.config.commit_version_property and new_version is not None) \
or (context.config.commit_sequential_version_property and new_sequential_version is not None):
update_result = update_project_property_file(clone_context,
properties_in_selected_commit,
new_version,
new_sequential_version,
commit_info)
result.add_subresult(update_result)
if result.has_errors():
result.fail(os.EX_DATAERR,
_("Property update failed."),
_("An unexpected error occurred.")
)
if new_version is not None:
execute_version_change_actions(clone_context, latest_branch_version, new_version)
if commit_info is not None:
if command_context.selected_commit != command_context.selected_ref.target.obj_name:
result.fail(os.EX_USAGE,
_("Failed to commit version update."),
_("The selected parent commit {commit} does not represent the tip of {branch}.")
.format(commit=command_context.selected_commit,
branch=repr(command_context.selected_ref.name))
)
# commit changes
commit_info.add_parent(command_context.selected_commit)
object_to_tag = create_commit(clone_context, result, commit_info)
else:
object_to_tag = command_context.selected_commit
# show info and prompt for confirmation
cli.print("ref : " + cli.if_none(command_context.selected_ref.name))
cli.print("ref_" + const.DEFAULT_VERSION_VAR_NAME + " : " + cli.if_none(latest_branch_version))
cli.print("new_branch : " + cli.if_none(branch_name))
cli.print("new_" + const.DEFAULT_VERSION_VAR_NAME + " : " + cli.if_none(new_version))
cli.print("selected object : " + cli.if_none(command_context.selected_commit))
cli.print("tagged object : " + cli.if_none(object_to_tag))
prompt_result = prompt_for_confirmation(
context=context,
fail_title=_("Failed to create release branch based on {branch}.")
.format(branch=repr(command_context.selected_ref.name)),
message=_("The branch and tags are about to be pushed."),
prompt=_("Continue?"),
)
result.add_subresult(prompt_result)
if result.has_errors() or not prompt_result.value:
return result
# push atomically
push_command = ['push', '--atomic']
if context.dry_run:
push_command.append('--dry-run')
if context.verbose:
push_command.append('--verbose')
push_command.append(context.config.remote_name)
# push the base branch commit
# push_command.append(commit + ':' + const.LOCAL_BRANCH_PREFIX + selected_ref.local_branch_name)
# push the new branch or fail if it exists
push_command.extend(
['--force-with-lease=' + repotools.create_ref_name(const.LOCAL_BRANCH_PREFIX, branch_name) + ':',
repotools.ref_target(object_to_tag) + ':' + repotools.create_ref_name(const.LOCAL_BRANCH_PREFIX,
branch_name)])
# push the new version tag or fail if it exists
push_command.extend(['--force-with-lease=' + repotools.create_ref_name(const.LOCAL_TAG_PREFIX, tag_name) + ':',
repotools.ref_target(object_to_tag) + ':' + repotools.create_ref_name(
const.LOCAL_TAG_PREFIX, tag_name)])
git_or_fail(cloned_repo, result, push_command, _("Failed to push."))
return result
def create_version_tag(command_context: CommandContext,
operation: Callable[[VersionConfig, Optional[str], Optional[int]], Result]) -> Result:
result = Result()
context: Context = command_context.context
release_branches = command_context.context.get_release_branches(reverse=True)
# TODO configuration
allow_merge_base_tags = True # context.config.allow_shared_release_branch_base
selected_branch = command_context.selected_ref
selected_branch_base_version = context.release_branch_matcher.format(command_context.selected_ref.name)
if selected_branch_base_version is not None:
selected_branch_base_version_info = semver.parse_version_info(selected_branch_base_version)
else:
selected_branch_base_version_info = None
if selected_branch_base_version is None:
result.fail(os.EX_USAGE,
_("Cannot bump version."),
_("{branch} is not a release branch.")
.format(branch=repr(command_context.selected_ref.name)))
latest_version_tag = None
preceding_version_tag = None
preceding_branch_version_tag = None
version_tags_on_same_commit = list()
subsequent_version_tags = list()
enclosing_versions = set()
# abort scan, when a preceding commit for each tag type has been processed.
# enclosing_versions now holds enough information for operation validation,
# assuming the branch has not gone haywire in earlier commits
# TODO evaluate upper and lower bound version for efficiency
abort_version_scan = False
on_selected_branch = False
before_commit = False
before_selected_branch = False
for release_branch in release_branches:
# fork_point = repotools.git_merge_base(context.repo, context.config.release_branch_base,
# command_context.selected_commit)
# if fork_point is None:
# result.fail(os.EX_USAGE,
# _("Cannot bump version."),
# _("{branch} has no fork point on {base_branch}.")
# .format(branch=repr(command_context.selected_ref.name),
# base_branch=repr(context.config.release_branch_base)))
fork_point = None
branch_base_version = context.release_branch_matcher.format(release_branch.name)
if branch_base_version is not None:
branch_base_version_info = semver.parse_version_info(branch_base_version)
else:
branch_base_version_info = None
on_selected_branch = not before_selected_branch and release_branch.name == selected_branch.name
for history_commit in repotools.git_list_commits(
context=context.repo,
start=fork_point,
end=release_branch.obj_name,
options=const.BRANCH_COMMIT_SCAN_OPTIONS):
at_commit = not before_commit and on_selected_branch and history_commit.obj_name == command_context.selected_commit
version_tag_refs = None
assert not at_commit if before_commit else not before_commit
for tag_ref in repotools.git_get_tags_by_referred_object(context.repo, history_commit.obj_name):
version_info = context.version_tag_matcher.to_version_info(tag_ref.name)
if version_info is not None:
tag_matches = version_info.major == branch_base_version_info.major \
and version_info.minor == branch_base_version_info.minor
if tag_matches:
if version_tag_refs is None:
version_tag_refs = list()
version_tag_refs.append(tag_ref)
else:
if fork_point is not None:
# fail stray tags on exclusive branch commits
result.fail(os.EX_DATAERR,
_("Cannot bump version."),
_("Found stray version tag: {version}.")
.format(version=repr(version.format_version_info(version_info)))
)
else:
# when no merge base is used, abort at the first mismatching tag
break
if not abort_version_scan and version_tag_refs is not None and len(version_tag_refs):
version_tag_refs.sort(
reverse=True,
key=utils.cmp_to_key(
lambda tag_ref_a, tag_ref_b: semver.compare(
context.version_tag_matcher.format(tag_ref_a.name),
context.version_tag_matcher.format(tag_ref_b.name)
)
)
)
if latest_version_tag is None:
latest_version_tag = version_tag_refs[0]
if at_commit:
version_tags_on_same_commit.extend(version_tag_refs)
if at_commit or before_commit:
if preceding_version_tag is None:
preceding_version_tag = version_tag_refs[0]
if on_selected_branch and preceding_branch_version_tag is None:
preceding_branch_version_tag = version_tag_refs[0]
else:
subsequent_version_tags.extend(version_tag_refs)
for tag_ref in version_tag_refs:
enclosing_versions.add(context.version_tag_matcher.format(tag_ref.name))
if before_commit:
abort_version_scan = True
if at_commit:
before_commit = True
if on_selected_branch:
before_commit = True
before_selected_branch = True
if abort_version_scan:
break
if context.config.sequential_versioning and preceding_version_tag is not None:
match = context.version_tag_matcher.fullmatch(preceding_version_tag.name)
preceding_sequential_version = match.group(context.version_tag_matcher.group_unique_code)
else:
preceding_sequential_version = None
if preceding_sequential_version is not None:
preceding_sequential_version = int(preceding_sequential_version)
if context.verbose:
cli.print("Tags on selected commit:\n"
+ '\n'.join(' - ' + repr(tag_ref.name) for tag_ref in version_tags_on_same_commit))
cli.print("Tags in subsequent history:\n"
+ '\n'.join(' - ' + repr(tag_ref.name) for tag_ref in subsequent_version_tags))
if preceding_branch_version_tag is not None:
latest_branch_version = context.version_tag_matcher.format(preceding_branch_version_tag.name)
else:
latest_branch_version = None
global_sequence_number = get_global_sequence_number(context)
if latest_branch_version is not None:
version_result = operation(context.config.version_config, latest_branch_version, global_sequence_number)
result.add_subresult(version_result)
new_version = version_result.value
if result.has_errors():
return result
else:
template_version_info = semver.parse_version_info(context.config.version_config.initial_version)
new_version = semver.format_version(
major=selected_branch_base_version_info.major,
minor=selected_branch_base_version_info.minor,
patch=template_version_info.patch,
prerelease=str(global_sequence_number + 1) if context.config.tie_sequential_version_to_semantic_version and global_sequence_number is not None else template_version_info.prerelease,
build=template_version_info.build,
)
new_version_info = semver.parse_version_info(new_version)
new_sequential_version = scheme_procedures.get_sequence_number(context.config.version_config, new_version_info)
if new_version_info.major != selected_branch_base_version_info.major or new_version_info.minor != selected_branch_base_version_info.minor:
result.fail(os.EX_USAGE,
_("Tag creation failed."),
_("The major.minor part of the new version {new_version}"
" does not match the branch version {branch_version}.")
.format(new_version=repr(new_version),
branch_version=repr(
"%d.%d" % (selected_branch_base_version_info.major, selected_branch_base_version_info.minor)))
)
try:
config_in_selected_commit = read_config_in_commit(context.repo, command_context.selected_commit)
except FileNotFoundError:
config_in_selected_commit = dict()
try:
properties_in_selected_commit = read_properties_in_commit(context,
context.repo,
config_in_selected_commit,
command_context.selected_commit)
except FileNotFoundError:
properties_in_selected_commit = dict()
if context.verbose:
print("properties in selected commit:")
print(json.dumps(obj=properties_in_selected_commit, indent=2))
valid_tag = False
# validate the commit
if len(version_tags_on_same_commit):
if config_in_selected_commit is None:
result.fail(os.EX_DATAERR,
_("Tag creation failed."),
_("The selected commit does not contain a configuration file.")
)
version_property_name = config_in_selected_commit.get(const.CONFIG_VERSION_PROPERTY)
if version_property_name is not None \
and properties_in_selected_commit.get(version_property_name) is None:
result.warn(_("Missing version info."),
_("The selected commit does not contain a version in property '{property_name}'.")
.format(property_name=version_property_name)
)
if len(version_tags_on_same_commit):
if context.config.allow_qualifier_increments_within_commit:
preceding_commit_version = context.version_tag_matcher.format(
version_tags_on_same_commit[0].name)
prerelease_keywords_list = [context.config.version_config.qualifiers, 1]
preceding_commit_version_ = version.parse_version(preceding_commit_version)
new_commit_version_ = version.parse_version(new_version)
version_delta = version.determine_version_delta(preceding_commit_version_,
new_commit_version_,
prerelease_keywords_list
)
version_increment_eval_result = version.evaluate_version_increment(preceding_commit_version_,
new_commit_version_,
context.config.strict_mode,
prerelease_keywords_list)
result.add_subresult(version_increment_eval_result)
if result.has_errors():
return result
if not version_delta.prerelease_field_only(0, False):
result.fail(os.EX_USAGE,
_("Tag creation failed."),
_("The selected commit already has version tags.\n"
"Operations on such a commit are limited to pre-release type increments.")
)
valid_tag = True
else:
result.fail(os.EX_USAGE,
_("Tag creation failed."),
_("There are version tags pointing to the selected commit {commit}.\n"
"Consider reusing these versions or bumping them to stable."
"{listing}")
.format(commit=command_context.selected_commit,
listing='\n'.join(
' - ' + repr(tag_ref.name) for tag_ref in subsequent_version_tags))
)
if not valid_tag:
if len(subsequent_version_tags):
result.fail(os.EX_USAGE,
_("Tag creation failed."),
_("There are version tags in branch history following the selected commit {commit}:\n"
"{listing}")
.format(commit=command_context.selected_commit,
listing='\n'.join(
' - ' + repr(tag_ref.name) for tag_ref in subsequent_version_tags))
)
global_seq_number = global_sequence_number
if context.config.tie_sequential_version_to_semantic_version \
and global_seq_number is not None \
and new_sequential_version is not None \
and preceding_sequential_version != global_seq_number:
result.fail(os.EX_USAGE,
_("Tag creation failed."),
_(
"The preceding sequential version {seq_val} "
"does not equal the global sequential version {global_seq_val}.")
.format(seq_val=preceding_sequential_version
if preceding_sequential_version is not None
else '<none>',
global_seq_val=global_seq_number)
)
if not result.has_errors():
if new_version is None:
result.fail(os.EX_SOFTWARE,
_("Internal error."),
_("Missing result version.")
)
if latest_branch_version is not None and semver.compare(latest_branch_version, new_version) >= 0:
result.fail(os.EX_DATAERR,
_("Failed to increment version from {current} to {new}.")
.format(current=repr(latest_branch_version), new=repr(new_version)),
_("The new version is lower than or equal to the current version.")
)
if context.config.push_to_local \
and command_context.current_branch.short_name == command_context.selected_ref.short_name:
if context.verbose:
cli.print(
_('Checking out {base_branch} in order to avoid failing the push to a checked-out release branch')
.format(base_branch=repr(context.config.release_branch_base)))
git_or_fail(context.repo, result, ['checkout', context.config.release_branch_base])
original_current_branch = command_context.current_branch
else:
original_current_branch = None
branch_name = get_branch_name_for_version(context, new_version_info)
tag_name = get_tag_name_for_version(context, new_version_info)
clone_result = clone_repository(context, context.config.release_branch_base)
cloned_repo = clone_result.value
commit_info = CommitInfo()
commit_info.add_message("#version: " + cli.if_none(new_version))
# run version change hooks on release branch
checkout_command = ['checkout', '--force', '--track', '-b', branch_name,
repotools.create_ref_name(const.REMOTES_PREFIX,
context.config.remote_name,
branch_name)]
returncode, out, err = repotools.git(cloned_repo, *checkout_command)
if returncode != os.EX_OK:
result.fail(os.EX_DATAERR,
_("Failed to check out release branch."),
_("An unexpected error occurred.")
)
clone_context: Context = create_temp_context(context, result, cloned_repo.dir)
clone_context.config.remote_name = 'origin'
if (context.config.commit_version_property and new_version is not None) \
or (context.config.commit_sequential_version_property and new_sequential_version is not None):
update_result = update_project_property_file(clone_context,
properties_in_selected_commit,
new_version,
new_sequential_version,
commit_info)
result.add_subresult(update_result)
if result.has_errors():
result.fail(os.EX_DATAERR,
_("Property update failed."),
_("An unexpected error occurred.")
)
if new_version is not None:
execute_version_change_actions(clone_context, latest_branch_version, new_version)
if commit_info is not None:
if command_context.selected_commit != command_context.selected_ref.target.obj_name:
result.fail(os.EX_USAGE,
_("Failed to commit version update."),
_("The selected parent commit {commit} does not represent the tip of {branch}.")
.format(commit=command_context.selected_commit,
branch=repr(command_context.selected_ref.name))
)
# commit changes
commit_info.add_parent(command_context.selected_commit)
object_to_tag = create_commit(clone_context, result, commit_info)
new_branch_ref_object = object_to_tag
else:
object_to_tag = command_context.selected_commit
new_branch_ref_object = None
# if command_context.selected_branch not in repotools.git_list_refs(context.repo,
# '--contains', object_to_tag,
# command_context.selected_branch.ref):
# show info and prompt for confirmation
cli.print("ref : " + cli.if_none(command_context.selected_ref.name))
cli.print("ref_" + const.DEFAULT_VERSION_VAR_NAME + " : " + cli.if_none(latest_branch_version))
cli.print("new_tag : " + cli.if_none(tag_name))
cli.print("new_" + const.DEFAULT_VERSION_VAR_NAME + " : " + cli.if_none(new_version))
cli.print("selected object : " + cli.if_none(command_context.selected_commit))
cli.print("tagged object : " + cli.if_none(object_to_tag))
prompt_result = prompt_for_confirmation(
context=context,
fail_title=_("Failed to create release tag based on {branch}.")
.format(branch=repr(command_context.selected_ref.name)),
message=_("The tags are about to be pushed."),
prompt=_("Continue?"),
)
result.add_subresult(prompt_result)
if result.has_errors() or not prompt_result.value:
return result
# push atomically
push_command = ['push', '--atomic']
if context.dry_run:
push_command.append('--dry-run')
if context.verbose:
push_command.append('--verbose')
push_command.append(context.config.remote_name)
# push the release branch commit or its version increment commit
if new_branch_ref_object is not None:
push_command.append(
new_branch_ref_object + ':' + repotools.create_ref_name(const.LOCAL_BRANCH_PREFIX, branch_name))
# check, if preceding tags exist on remote
if preceding_version_tag is not None:
push_command.append('--force-with-lease='
+ preceding_version_tag.name + ':'
+ preceding_version_tag.name)
# push the new version tag or fail if it exists
push_command.extend(['--force-with-lease=' + repotools.create_ref_name(const.LOCAL_TAG_PREFIX, tag_name) + ':',
repotools.ref_target(object_to_tag) + ':' + repotools.create_ref_name(
const.LOCAL_TAG_PREFIX, tag_name)])
returncode, out, err = repotools.git(clone_context.repo, *push_command)
if returncode != os.EX_OK:
result.fail(os.EX_DATAERR,
_("Failed to push."),
_("git push exited with " + str(returncode))
)
if original_current_branch is not None:
if context.verbose:
cli.print(
_('Switching back to {original_branch} ')
.format(original_branch=repr(original_current_branch.name)))
git_or_fail(context.repo, result, ['checkout', original_current_branch.short_name])
return result