forked from commitizen-tools/commitizen
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathbump.py
More file actions
224 lines (183 loc) · 7.06 KB
/
Copy pathbump.py
File metadata and controls
224 lines (183 loc) · 7.06 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
import re
from collections import OrderedDict
from itertools import zip_longest
from string import Template
from typing import List, Optional, Union
from packaging.version import Version
from commitizen.defaults import (
MAJOR,
MINOR,
PATCH,
bump_map,
bump_message,
bump_pattern,
)
from commitizen.exceptions import CurrentVersionNotFoundError
from commitizen.git import GitCommit
def find_increment(
commits: List[GitCommit],
regex: str = bump_pattern,
increments_map: Union[dict, OrderedDict] = bump_map,
) -> Optional[str]:
if isinstance(increments_map, dict):
increments_map = OrderedDict(increments_map)
# Most important cases are major and minor.
# Everything else will be considered patch.
select_pattern = re.compile(regex)
increment = None
for commit in commits:
for message in commit.message.split("\n"):
result = select_pattern.search(message)
if result:
found_keyword = result.group(0)
new_increment = None
for match_pattern in increments_map.keys():
if re.match(match_pattern, found_keyword):
new_increment = increments_map[match_pattern]
break
if increment == "MAJOR":
continue
elif increment == "MINOR" and new_increment == "MAJOR":
increment = new_increment
elif increment == "PATCH" or increment is None:
increment = new_increment
return increment
def prerelease_generator(current_version: str, prerelease: Optional[str] = None) -> str:
"""Generate prerelease
X.YaN # Alpha release
X.YbN # Beta release
X.YrcN # Release Candidate
X.Y # Final
This function might return something like 'alpha1'
but it will be handled by Version.
"""
if not prerelease:
return ""
version = Version(current_version)
# version.pre is needed for mypy check
if version.is_prerelease and version.pre and prerelease.startswith(version.pre[0]):
prev_prerelease: int = version.pre[1]
new_prerelease_number = prev_prerelease + 1
else:
new_prerelease_number = 0
pre_version = f"{prerelease}{new_prerelease_number}"
return pre_version
def semver_generator(current_version: str, increment: str = None) -> str:
version = Version(current_version)
prev_release = list(version.release)
increments = [MAJOR, MINOR, PATCH]
increments_version = dict(zip_longest(increments, prev_release, fillvalue=0))
# This flag means that current version
# must remove its prerelease tag,
# so it doesn't matter the increment.
# Example: 1.0.0a0 with PATCH/MINOR -> 1.0.0
if not version.is_prerelease:
if increment == MAJOR:
increments_version[MAJOR] += 1
increments_version[MINOR] = 0
increments_version[PATCH] = 0
elif increment == MINOR:
increments_version[MINOR] += 1
increments_version[PATCH] = 0
elif increment == PATCH:
increments_version[PATCH] += 1
return str(
f"{increments_version['MAJOR']}."
f"{increments_version['MINOR']}."
f"{increments_version['PATCH']}"
)
def generate_version(
current_version: str,
increment: str,
prerelease: Optional[str] = None,
is_local_version: bool = False,
) -> Version:
"""Based on the given increment a proper semver will be generated.
For now the rules and versioning scheme is based on
python's PEP 0440.
More info: https://www.python.org/dev/peps/pep-0440/
Example:
PATCH 1.0.0 -> 1.0.1
MINOR 1.0.0 -> 1.1.0
MAJOR 1.0.0 -> 2.0.0
"""
if is_local_version:
version = Version(current_version)
pre_version = prerelease_generator(str(version.local), prerelease=prerelease)
semver = semver_generator(str(version.local), increment=increment)
return Version(f"{version.public}+{semver}{pre_version}")
else:
pre_version = prerelease_generator(current_version, prerelease=prerelease)
semver = semver_generator(current_version, increment=increment)
# TODO: post version
# TODO: dev version
return Version(f"{semver}{pre_version}")
def update_version_in_files(
current_version: str, new_version: str, files: List[str], *, check_consistency=False
):
"""Change old version to the new one in every file given.
Note that this version is not the tag formatted one.
So for example, your tag could look like `v1.0.0` while your version in
the package like `1.0.0`.
"""
# TODO: separate check step and write step
for location in files:
filepath, *regexes = location.split(":", maxsplit=1)
regex = regexes[0] if regexes else None
# Read in the file
file_content = []
current_version_found = False
with open(filepath, "r") as version_file:
for line in version_file:
if regex:
match = re.search(regex, line)
if not match:
file_content.append(line)
continue
# Replace the target string
if current_version in line:
current_version_found = True
file_content.append(line.replace(current_version, new_version))
else:
file_content.append(line)
if check_consistency and not current_version_found:
raise CurrentVersionNotFoundError(
f"Current version {current_version} is not found in {location}.\n"
"The version defined in commitizen configuration and the ones in "
"version_files are possibly inconsistent."
)
# Write the file out again
with open(filepath, "w") as file:
file.write("".join(file_content))
def create_tag(version: Union[Version, str], tag_format: Optional[str] = None):
"""The tag and the software version might be different.
That's why this function exists.
Example:
| tag | version (PEP 0440) |
| --- | ------- |
| v0.9.0 | 0.9.0 |
| ver1.0.0 | 1.0.0 |
| ver1.0.0.a0 | 1.0.0a0 |
"""
if isinstance(version, str):
version = Version(version)
if not tag_format:
return str(version)
major, minor, patch = version.release
prerelease = ""
# version.pre is needed for mypy check
if version.is_prerelease and version.pre:
prerelease = f"{version.pre[0]}{version.pre[1]}"
t = Template(tag_format)
return t.safe_substitute(
version=version, major=major, minor=minor, patch=patch, prerelease=prerelease
)
def create_commit_message(
current_version: Union[Version, str],
new_version: Union[Version, str],
message_template: str = None,
) -> str:
if message_template is None:
message_template = bump_message
t = Template(message_template)
return t.safe_substitute(current_version=current_version, new_version=new_version)