def test_update_version_in_files(create_files):
old_version = "1.2.3"
new_version = "2.0.0"
bump.update_version_in_files(old_version, new_version, create_files)
for filepath in create_files:
with open(filepath, "r") as f:
data = f.read()
assert new_version in data
def test_random_location(random_location_version_file, file_regression):
old_version = "1.2.3"
new_version = "2.0.0"
location = f"{random_location_version_file}:there-i-fixed-it.+\nversion"
bump.update_version_in_files(old_version, new_version, [location])
with open(random_location_version_file, "r") as f:
file_regression.check(f.read(), extension=".lock")
def version_bump_change_string_size(filename, old_version, new_version):
location = f"{filename}:version"
bump.update_version_in_files(old_version, new_version, [location])
with open(filename, "r") as f:
data = f.read()
assert len(re.findall(old_version, data)) == 0
assert len(re.findall(new_version, data)) == 30
def test_partial_update_of_file(version_repeated_file, file_regression):
old_version = "1.2.3"
new_version = "2.0.0"
regex = "version"
location = f"{version_repeated_file}:{regex}"
bump.update_version_in_files(old_version, new_version, [location])
with open(version_repeated_file, "r") as f:
file_regression.check(f.read(), extension=".json")
def test_multiplt_versions_to_bump(multiple_versions_to_update_poetry_lock,
file_regression):
old_version = "1.2.9"
new_version = "1.2.10"
location = f"{multiple_versions_to_update_poetry_lock}:version"
bump.update_version_in_files(old_version, new_version, [location])
with open(multiple_versions_to_update_poetry_lock, "r") as f:
file_regression.check(f.read(), extension=".toml")
def test_version_bump_reduce_string_length(multiple_versions_reduce_string,
file_regression):
old_version = "1.2.10"
new_version = "2.0.0"
location = f"{multiple_versions_reduce_string}:version"
bump.update_version_in_files(old_version, new_version, [location])
with open(multiple_versions_reduce_string, "r") as f:
file_regression.check(f.read(), extension=".txt")
def test_duplicates_are_change_with_no_regex(random_location_version_file,
file_regression):
old_version = "1.2.3"
new_version = "2.0.0"
location = f"{random_location_version_file}:version"
bump.update_version_in_files(old_version, new_version, [location])
with open(random_location_version_file, "r") as f:
file_regression.check(f.read(), extension=".lock")
def test_update_version_in_files(version_files, file_regression):
old_version = "1.2.3"
new_version = "2.0.0"
bump.update_version_in_files(old_version, new_version, version_files)
file_contents = ""
for filepath in version_files:
with open(filepath, "r") as f:
file_contents += f.read()
file_regression.check(file_contents, extension=".txt")
def test_duplicates_are_change_with_no_regex(random_location_version_file):
old_version = "1.2.3"
new_version = "2.0.0"
location = f"{random_location_version_file}:version"
bump.update_version_in_files(old_version, new_version, [location])
with open(random_location_version_file, "r") as f:
data = f.read()
assert len(re.findall(old_version, data)) == 0
assert len(re.findall(new_version, data)) == 3
def test_random_location(random_location_version_file):
old_version = "1.2.3"
new_version = "2.0.0"
location = f"{random_location_version_file}:there-i-fixed-it.+\nversion"
bump.update_version_in_files(old_version, new_version, [location])
with open(random_location_version_file, "r") as f:
data = f.read()
assert len(re.findall(old_version, data)) == 2
assert len(re.findall(new_version, data)) == 1
def test_partial_update_of_file(version_repeated_file):
old_version = "1.2.3"
new_version = "2.0.0"
regex = "version"
location = f"{version_repeated_file}:{regex}"
bump.update_version_in_files(old_version, new_version, [location])
with open(version_repeated_file, "r") as f:
data = f.read()
assert new_version in data
assert old_version in data
def test_partial_update_of_file(create_files):
old_version = "1.2.3"
new_version = "2.0.0"
filepath = "tests/package.json"
regex = "version"
location = f"{filepath}:{regex}"
bump.update_version_in_files(old_version, new_version, [location])
with open(filepath, "r") as f:
data = f.read()
assert new_version in data
assert old_version in data
def test_file_version_inconsistent_error(commitizen_config_file,
inconsistent_python_version_file,
version_repeated_file):
version_files = [
commitizen_config_file,
inconsistent_python_version_file,
version_repeated_file,
]
old_version = "1.2.3"
new_version = "2.0.0"
with pytest.raises(SystemExit) as excinfo:
bump.update_version_in_files(old_version,
new_version,
version_files,
check_consistency=True)
assert excinfo.value.code == CURRENT_VERSION_NOT_FOUND
def test_file_version_inconsistent_error(commitizen_config_file,
inconsistent_python_version_file,
version_repeated_file):
version_files = [
commitizen_config_file,
inconsistent_python_version_file,
version_repeated_file,
]
old_version = "1.2.3"
new_version = "2.0.0"
with pytest.raises(CurrentVersionNotFoundError) as excinfo:
bump.update_version_in_files(old_version,
new_version,
version_files,
check_consistency=True)
expected_msg = (
f"Current version 1.2.3 is not found in {inconsistent_python_version_file}.\n"
"The version defined in commitizen configuration and the ones in "
"version_files are possibly inconsistent.")
assert expected_msg in str(excinfo.value)
def __call__(self): # noqa: C901
"""Steps executed to bump."""
try:
current_version_instance: Version = Version(self.bump_settings["version"])
except TypeError:
raise NoVersionSpecifiedError()
# Initialize values from sources (conf)
current_version: str = self.config.settings["version"]
tag_format: str = self.bump_settings["tag_format"]
bump_commit_message: str = self.bump_settings["bump_message"]
version_files: List[str] = self.bump_settings["version_files"]
dry_run: bool = self.arguments["dry_run"]
is_yes: bool = self.arguments["yes"]
increment: Optional[str] = self.arguments["increment"]
prerelease: str = self.arguments["prerelease"]
is_files_only: Optional[bool] = self.arguments["files_only"]
is_local_version: Optional[bool] = self.arguments["local_version"]
current_tag_version: str = bump.create_tag(
current_version, tag_format=tag_format
)
is_initial = self.is_initial_tag(current_tag_version, is_yes)
if is_initial:
commits = git.get_commits()
else:
commits = git.get_commits(current_tag_version)
# No commits, there is no need to create an empty tag.
# Unless we previously had a prerelease.
if not commits and not current_version_instance.is_prerelease:
raise NoCommitsFoundError("[NO_COMMITS_FOUND]\n" "No new commits found.")
if increment is None:
increment = self.find_increment(commits)
# Increment is removed when current and next version
# are expected to be prereleases.
if prerelease and current_version_instance.is_prerelease:
increment = None
new_version = bump.generate_version(
current_version,
increment,
prerelease=prerelease,
is_local_version=is_local_version,
)
new_tag_version = bump.create_tag(new_version, tag_format=tag_format)
message = bump.create_commit_message(
current_version, new_version, bump_commit_message
)
# Report found information
out.write(
f"{message}\n"
f"tag to create: {new_tag_version}\n"
f"increment detected: {increment}\n"
)
if increment is None and new_tag_version == current_tag_version:
raise NoneIncrementExit()
# Do not perform operations over files or git.
if dry_run:
raise DryRunExit()
bump.update_version_in_files(
current_version,
str(new_version),
version_files,
check_consistency=self.check_consistency,
)
if self.changelog:
changelog_cmd = Changelog(
self.config,
{
"unreleased_version": new_tag_version,
"incremental": True,
"dry_run": dry_run,
},
)
changelog_cmd()
c = cmd.run(f"git add {changelog_cmd.file_name}")
self.config.set_key("version", str(new_version))
if is_files_only:
raise ExpectedExit()
c = git.commit(message, args=self._get_commit_args())
if c.return_code != 0:
raise BumpCommitFailedError(f'git.commit error: "{c.err.strip()}"')
c = git.tag(new_tag_version)
if c.return_code != 0:
raise BumpTagFailedError(c.err)
out.success("Done!")
def __call__(self): # noqa: C901
"""Steps executed to bump."""
try:
current_version_instance: Version = Version(self.bump_settings["version"])
except TypeError:
out.error(
"[NO_VERSION_SPECIFIED]\n"
"Check if current version is specified in config file, like:\n"
"version = 0.4.3\n"
)
raise SystemExit(NO_VERSION_SPECIFIED)
# Initialize values from sources (conf)
current_version: str = self.config.settings["version"]
tag_format: str = self.bump_settings["tag_format"]
bump_commit_message: str = self.bump_settings["bump_message"]
version_files: List[str] = self.bump_settings["version_files"]
dry_run: bool = self.arguments["dry_run"]
is_yes: bool = self.arguments["yes"]
increment: Optional[str] = self.arguments["increment"]
prerelease: str = self.arguments["prerelease"]
is_files_only: Optional[bool] = self.arguments["files_only"]
current_tag_version: str = bump.create_tag(
current_version, tag_format=tag_format
)
is_initial = self.is_initial_tag(current_tag_version, is_yes)
if is_initial:
commits = git.get_commits()
else:
commits = git.get_commits(current_tag_version)
# No commits, there is no need to create an empty tag.
# Unless we previously had a prerelease.
if not commits and not current_version_instance.is_prerelease:
out.error("[NO_COMMITS_FOUND]\n" "No new commits found.")
raise SystemExit(NO_COMMITS_FOUND)
if increment is None:
increment = self.find_increment(commits)
# Increment is removed when current and next version
# are expected to be prereleases.
if prerelease and current_version_instance.is_prerelease:
increment = None
new_version = bump.generate_version(
current_version, increment, prerelease=prerelease
)
new_tag_version = bump.create_tag(new_version, tag_format=tag_format)
message = bump.create_commit_message(
current_version, new_version, bump_commit_message
)
# Report found information
out.write(
f"message\n"
f"tag to create: {new_tag_version}\n"
f"increment detected: {increment}\n"
)
# Do not perform operations over files or git.
if dry_run:
raise SystemExit()
bump.update_version_in_files(
current_version,
new_version.public,
version_files,
check_consistency=self.check_consistency,
)
if is_files_only:
raise SystemExit()
if self.changelog:
changelog = Changelog(
self.config,
{
"unreleased_version": new_tag_version,
"incremental": True,
"dry_run": dry_run,
},
)
changelog()
self.config.set_key("version", new_version.public)
c = git.commit(message, args=self._get_commit_args())
if c.err:
out.error('git.commit error: "{}"'.format(c.err.strip()))
raise SystemExit(COMMIT_FAILED)
c = git.tag(new_tag_version)
if c.err:
out.error(c.err)
raise SystemExit(TAG_FAILED)
out.success("Done!")
def __call__(self): # noqa: C901
"""Steps executed to bump."""
try:
current_version_instance: Version = Version(
self.bump_settings["version"])
except TypeError:
raise NoVersionSpecifiedError()
# Initialize values from sources (conf)
current_version: str = self.config.settings["version"]
tag_format: str = self.bump_settings["tag_format"]
bump_commit_message: str = self.bump_settings["bump_message"]
version_files: List[str] = self.bump_settings["version_files"]
dry_run: bool = self.arguments["dry_run"]
is_yes: bool = self.arguments["yes"]
increment: Optional[str] = self.arguments["increment"]
prerelease: str = self.arguments["prerelease"]
is_files_only: Optional[bool] = self.arguments["files_only"]
is_local_version: Optional[bool] = self.arguments["local_version"]
current_tag_version: str = bump.normalize_tag(current_version,
tag_format=tag_format)
is_initial = self.is_initial_tag(current_tag_version, is_yes)
if is_initial:
commits = git.get_commits()
else:
commits = git.get_commits(current_tag_version)
# If user specified changelog_to_stdout, they probably want the
# changelog to be generated as well, this is the most intuitive solution
if not self.changelog and self.changelog_to_stdout:
self.changelog = True
# No commits, there is no need to create an empty tag.
# Unless we previously had a prerelease.
if not commits and not current_version_instance.is_prerelease:
raise NoCommitsFoundError("[NO_COMMITS_FOUND]\n"
"No new commits found.")
if increment is None:
increment = self.find_increment(commits)
# It may happen that there are commits, but they are not elegible
# for an increment, this generates a problem when using prerelease (#281)
if (prerelease and increment is None
and not current_version_instance.is_prerelease):
raise NoCommitsFoundError(
"[NO_COMMITS_FOUND]\n"
"No commits found to generate a pre-release.\n"
"To avoid this error, manually specify the type of increment with `--increment`"
)
# Increment is removed when current and next version
# are expected to be prereleases.
if prerelease and current_version_instance.is_prerelease:
increment = None
new_version = bump.generate_version(
current_version,
increment,
prerelease=prerelease,
is_local_version=is_local_version,
)
new_tag_version = bump.normalize_tag(new_version,
tag_format=tag_format)
message = bump.create_commit_message(current_version, new_version,
bump_commit_message)
# Report found information
information = (f"{message}\n"
f"tag to create: {new_tag_version}\n"
f"increment detected: {increment}\n")
if self.changelog_to_stdout:
# When the changelog goes to stdout, we want to send
# the bump information to stderr, this way the
# changelog output can be captured
out.diagnostic(information)
else:
out.write(information)
if increment is None and new_tag_version == current_tag_version:
raise NoneIncrementExit(
"[NO_COMMITS_TO_BUMP]\n"
"The commits found are not elegible to be bumped")
# Do not perform operations over files or git.
if dry_run:
raise DryRunExit()
bump.update_version_in_files(
current_version,
str(new_version),
version_files,
check_consistency=self.check_consistency,
)
if self.changelog:
if self.changelog_to_stdout:
changelog_cmd = Changelog(
self.config,
{
"unreleased_version": new_tag_version,
"incremental": True,
"dry_run": True,
},
)
try:
changelog_cmd()
except DryRunExit:
pass
changelog_cmd = Changelog(
self.config,
{
"unreleased_version": new_tag_version,
"incremental": True,
"dry_run": dry_run,
},
)
changelog_cmd()
c = cmd.run(
f"git add {changelog_cmd.file_name} {' '.join(version_files)}")
self.config.set_key("version", str(new_version))
if is_files_only:
raise ExpectedExit()
c = git.commit(message, args=self._get_commit_args())
if self.retry and c.return_code != 0 and self.changelog:
# Maybe pre-commit reformatted some files? Retry once
logger.debug("1st git.commit error: %s", c.err)
logger.info("1st commit attempt failed; retrying once")
cmd.run(
f"git add {changelog_cmd.file_name} {' '.join(version_files)}")
c = git.commit(message, args=self._get_commit_args())
if c.return_code != 0:
raise BumpCommitFailedError(
f'2nd git.commit error: "{c.err.strip()}"')
c = git.tag(
new_tag_version,
annotated=self.bump_settings.get("annotated_tag", False)
or bool(self.config.settings.get("annotated_tag", False)),
)
if c.return_code != 0:
raise BumpTagFailedError(c.err)
# TODO: For v3 output this only as diagnostic and remove this if
if self.changelog_to_stdout:
out.diagnostic("Done!")
else:
out.success("Done!")
def __call__(self):
"""Steps executed to bump."""
try:
current_version_instance: Version = Version(self.parameters["version"])
except TypeError:
out.error("[NO_VERSION_SPECIFIED]")
out.error("Check if current version is specified in config file, like:")
out.error("version = 0.4.3")
raise SystemExit(NO_VERSION_SPECIFIED)
# Initialize values from sources (conf)
current_version: str = self.config["version"]
tag_format: str = self.parameters["tag_format"]
bump_commit_message: str = self.parameters["bump_message"]
current_tag_version: str = bump.create_tag(
current_version, tag_format=tag_format
)
files: list = self.parameters["files"]
dry_run: bool = self.parameters["dry_run"]
is_yes: bool = self.arguments["yes"]
prerelease: str = self.arguments["prerelease"]
increment: Optional[str] = self.arguments["increment"]
is_initial = self.is_initial_tag(current_tag_version, is_yes)
commits = git.get_commits(current_tag_version, from_beginning=is_initial)
# No commits, there is no need to create an empty tag.
# Unless we previously had a prerelease.
if not commits and not current_version_instance.is_prerelease:
out.error("[NO_COMMITS_FOUND]")
out.error("No new commits found.")
raise SystemExit(NO_COMMITS_FOUND)
if increment is None:
bump_pattern = self.cz.bump_pattern
bump_map = self.cz.bump_map
if not bump_map or not bump_pattern:
out.error(f"'{self.config['name']}' rule does not support bump")
raise SystemExit(NO_PATTERN_MAP)
increment = bump.find_increment(
commits, regex=bump_pattern, increments_map=bump_map
)
# Increment is removed when current and next version
# are expected to be prereleases.
if prerelease and current_version_instance.is_prerelease:
increment = None
new_version = bump.generate_version(
current_version, increment, prerelease=prerelease
)
new_tag_version = bump.create_tag(new_version, tag_format=tag_format)
message = bump.create_commit_message(
current_version, new_version, bump_commit_message
)
# Report found information
out.write(message)
out.write(f"tag to create: {new_tag_version}")
out.write(f"increment detected: {increment}")
# Do not perform operations over files or git.
if dry_run:
raise SystemExit()
config.set_key("version", new_version.public)
bump.update_version_in_files(current_version, new_version.public, files)
c = git.commit(message, args="-a")
if c.err:
out.error(c.err)
raise SystemExit(COMMIT_FAILED)
c = git.tag(new_tag_version)
if c.err:
out.error(c.err)
raise SystemExit(TAG_FAILED)
out.success("Done!")
def __call__(
self,
current_version,
version_filepaths=[],
increment=None,
prerelease=None,
dry_run=False,
autoconfirm_initial_tag=True,
tag_format=None,
bump_commit_message=None,
check_consistency=True,
update_files_only=False,
no_verify=False,
):
"""
:param str current_version: Semantic version e.g. '0.1.0'
"""
# THE FOLLOWING CODE DOESN'T HAVE SIDE EFFECTS TO FILESYS OR GIT:
current_version_instance = Version(current_version)
current_tag_version = bump.create_tag(current_version,
tag_format=tag_format)
#
is_initial = self.is_initial_tag(current_tag_version,
autoconfirm_initial_tag)
if is_initial:
commits = git.get_commits()
else:
commits = git.get_commits(current_tag_version)
#
if not commits and not current_version_instance.is_prerelease:
raise NoCommitsFoundError("[NO_COMMITS_FOUND]\n"
"No new commits found.")
#
if increment is None:
increment = self.find_increment(commits)
#
if prerelease is not None and current_version_instance.is_prerelease:
increment = None
#
new_version = bump.generate_version(current_version,
increment,
prerelease=prerelease)
new_tag_version = bump.create_tag(new_version, tag_format=tag_format)
message = bump.create_commit_message(current_version, new_version,
bump_commit_message)
# Report found information
out.write(f"{message}\n"
f"tag to create: {new_tag_version}\n"
f"increment detected: {increment}\n")
#
if increment is None and new_tag_version == current_tag_version:
raise NoneIncrementExit()
#
if dry_run:
raise DryRunExit()
# SIDE EFFECTS TO FILESYSTEM: UPDATE TAG IN VERSION_FILEPATHS
bump.update_version_in_files(
current_version,
new_version.public,
version_filepaths,
check_consistency=check_consistency,
)
if update_files_only:
out.write("[update_files_only=True]: Done updating files " +
f"{version_filepaths}. ")
raise ExpectedExit()
# SIDE EFFECTS TO GIT: TAG AND COMMIT
try:
commit_args = "-a"
if no_verify:
commit_args += " --no-verify"
c = git.commit(message, args=commit_args)
if c.return_code != 0:
raise BumpCommitFailedError(
f'git.commit error: "{c.err.strip()}"')
except Exception as e:
# If commit went bad (e.g. due to pre-commit errors), roll
# back the version updates in filesystem to prevent future
# "inconsistency errors". Swapping seems to do the trick.
bump.update_version_in_files(
new_version.public, # swapped!
current_version, # swapped!
version_filepaths,
check_consistency=check_consistency,
)
out.write(
f"\n[ERROR] Resetting version files to {current_version}")
raise e
# same as git.tag
tag_msg = "" # if changelog_path is None else f" -F {changelog_path}"
c = cmd.run(f"git tag {new_tag_version}" + tag_msg)
if c.return_code != 0:
raise BumpTagFailedError(c.err)
out.success("Done!")
