def test_annotated_tag(self):
c1 = self.remote_real.do_commit(
message=b'message',
committer=b'committer <*****@*****.**>',
author=b'author <*****@*****.**>')
c2 = self.remote_real.do_commit(
message=b'another commit',
committer=b'committer <*****@*****.**>',
author=b'author <*****@*****.**>')
porcelain.tag_create(
self.remote_real,
tag=b"blah",
author=b'author <*****@*****.**>',
objectish=c2,
tag_time=int(time.time()),
tag_timezone=0,
annotated=True,
message=b"Annotated tag")
remote = ControlDir.open(self.remote_url)
remote_branch = remote.open_branch()
self.assertEqual({
'blah': default_mapping.revision_id_foreign_to_bzr(c2)},
remote_branch.tags.get_tag_dict())
def test_simple(self):
[c1] = build_commit_graph(self.repo.object_store, [[1]])
self.repo[b"HEAD"] = c1.id
porcelain.tag_create(self.repo, b'foo')
self.assertTrue(b"foo" in porcelain.tag_list(self.repo))
porcelain.tag_delete(self.repo, b'foo')
self.assertFalse(b"foo" in porcelain.tag_list(self.repo))
def test_sprout_with_annotated_tag_unreferenced(self):
c1 = self.remote_real.do_commit(
message=b'message',
committer=b'committer <*****@*****.**>',
author=b'author <*****@*****.**>')
c2 = self.remote_real.do_commit(
message=b'another commit',
committer=b'committer <*****@*****.**>',
author=b'author <*****@*****.**>')
porcelain.tag_create(self.remote_real,
tag=b"blah",
author=b'author <*****@*****.**>',
objectish=c1,
tag_time=int(time.time()),
tag_timezone=0,
annotated=True,
message=b"Annotated tag")
remote = ControlDir.open(self.remote_url)
self.make_controldir('local', format=self._to_format)
local = remote.sprout(
'local',
revision_id=default_mapping.revision_id_foreign_to_bzr(c1))
local_branch = local.open_branch()
self.assertEqual(default_mapping.revision_id_foreign_to_bzr(c1),
local_branch.last_revision())
self.assertEqual(
{'blah': default_mapping.revision_id_foreign_to_bzr(c1)},
local_branch.tags.get_tag_dict())
def test_sign(self):
# Test that dulwich signatures can be verified by CGit
c1, c2, c3 = build_commit_graph(self.repo.object_store,
[[1], [2, 1], [3, 1, 2]])
self.repo.refs[b"HEAD"] = c3.id
cfg = self.repo.get_config()
cfg.set(("user", ), "signingKey", PorcelainGpgTestCase.DEFAULT_KEY_ID)
self.import_default_key()
porcelain.tag_create(
self.repo.path,
b"tryme",
b"foo <*****@*****.**>",
b"bar",
annotated=True,
sign=True,
)
run_git_or_fail(
[
"--git-dir={}".format(self.repo.controldir()), "tag", "-v",
"tryme"
],
env={'GNUPGHOME': os.environ['GNUPGHOME']},
)
def create_release(custom_content_repo):
"""Creates a new release by committing and tagging changes."""
version = determine_version(custom_content_repo)
commit(custom_content_repo, b'Demisto custom content sync.')
tag_create(custom_content_repo,
version,
message=b'Automatic release based on demisto-content update.')
return version
def test_unannotated(self):
c1, c2, c3 = build_commit_graph(self.repo.object_store, [[1], [2, 1], [3, 1, 2]])
self.repo.refs[b"HEAD"] = c3.id
porcelain.tag_create(self.repo.path, b"tryme", annotated=False)
tags = self.repo.refs.as_dict(b"refs/tags")
self.assertEqual(list(tags.keys()), [b"tryme"])
self.repo[b"refs/tags/tryme"]
self.assertEqual(list(tags.values()), [self.repo.head()])
def test_unannotated(self):
c1, c2, c3 = build_commit_graph(self.repo.object_store, [[1], [2, 1],
[3, 1, 2]])
self.repo.refs[b"HEAD"] = c3.id
porcelain.tag_create(self.repo.path, b"tryme", annotated=False)
tags = self.repo.refs.as_dict(b"refs/tags")
self.assertEqual(list(tags.keys()), [b"tryme"])
self.repo[b'refs/tags/tryme']
self.assertEqual(list(tags.values()), [self.repo.head()])
def run(self, args):
parser = optparse.OptionParser()
parser.add_option(
"-a", "--annotated", help="Create an annotated tag.",
action="store_true")
parser.add_option(
"-s", "--sign", help="Sign the annotated tag.",
action="store_true")
options, args = parser.parse_args(args)
porcelain.tag_create(
'.', args[0], annotated=options.annotated,
sign=options.sign)
def test_annotated(self):
c1, c2, c3 = build_commit_graph(self.repo.object_store, [[1], [2, 1], [3, 1, 2]])
self.repo.refs[b"HEAD"] = c3.id
porcelain.tag_create(self.repo.path, b"tryme", b"foo <*****@*****.**>", b"bar", annotated=True)
tags = self.repo.refs.as_dict(b"refs/tags")
self.assertEqual(list(tags.keys()), [b"tryme"])
tag = self.repo[b"refs/tags/tryme"]
self.assertTrue(isinstance(tag, Tag))
self.assertEqual(b"foo <*****@*****.**>", tag.tagger)
self.assertEqual(b"bar", tag.message)
self.assertLess(time.time() - tag.tag_time, 5)
def bump(self, new_version: Version, commit: Optional[bool], message: str):
"""
Bump to the given version.
:param new_version:
:param commit: Whether to commit automatically (:py:obj:`True`) or ask first (:py:obj:`None`).
:param message: The commit message.
.. versionchanged:: 2021.8.11
Now takes a :class:`packaging.version.Version` rather than a
:class:`domdf_python_tools.versions.Version`.
"""
new_version_str = str(new_version)
dulwich_repo = Repo(self.repo.target_repo)
if f"v{new_version_str}".encode("UTF-8") in dulwich_repo.refs.as_dict(b"refs/tags"):
raise abort(f"The tag 'v{new_version_str}' already exists!")
bumpversion_config = self.get_bumpversion_config(str(self.current_version), new_version_str)
changed_files = [self.bumpversion_file.relative_to(self.repo.target_repo).as_posix()]
for filename in bumpversion_config.keys():
if not os.path.isfile(filename):
raise FileNotFoundError(filename)
for filename, config in bumpversion_config.items():
self.bump_version_for_file(filename, config)
changed_files.append(filename)
# Update number in .bumpversion.cfg
bv = ConfigUpdater()
bv.read(self.bumpversion_file)
bv["bumpversion"]["current_version"] = new_version_str
self.bumpversion_file.write_clean(str(bv))
commit_message = message.format(current_version=self.current_version, new_version=new_version)
click.echo(commit_message)
if commit_changed_files(
self.repo.target_repo,
managed_files=changed_files,
commit=commit,
message=commit_message.encode("UTF-8"),
enable_pre_commit=False,
):
tag_create(dulwich_repo, f"v{new_version_str}")
def test_annotated(self):
c1, c2, c3 = build_commit_graph(self.repo.object_store, [[1], [2, 1],
[3, 1, 2]])
self.repo.refs[b"HEAD"] = c3.id
porcelain.tag_create(self.repo.path, b"tryme", b'foo <*****@*****.**>',
b'bar', annotated=True)
tags = self.repo.refs.as_dict(b"refs/tags")
self.assertEqual(list(tags.keys()), [b"tryme"])
tag = self.repo[b'refs/tags/tryme']
self.assertTrue(isinstance(tag, Tag))
self.assertEqual(b"foo <*****@*****.**>", tag.tagger)
self.assertEqual(b"bar", tag.message)
def test_annotated(self):
c1, c2, c3 = build_commit_graph(self.repo.object_store, [[1], [2, 1],
[3, 1, 2]])
self.repo.refs["HEAD"] = c3.id
porcelain.tag_create(self.repo.path, "tryme", 'foo <*****@*****.**>',
'bar', annotated=True)
tags = self.repo.refs.as_dict("refs/tags")
self.assertEqual(tags.keys(), ["tryme"])
tag = self.repo['refs/tags/tryme']
self.assertTrue(isinstance(tag, Tag))
self.assertEqual("foo <*****@*****.**>", tag.tagger)
self.assertEqual("bar", tag.message)
async def main(reactor):
git = Repo(".")
st = status(git)
if any(st.staged.values()) or st.unstaged:
print("unclean checkout; aborting")
raise SystemExit(1)
v = create_new_version(git)
if "--no-tag" in sys.argv:
print(v)
return
print("Existing tags: {}".format(" ".join(existing_tags(git))))
print("New tag will be {}".format(v))
# the "tag time" is seconds from the epoch .. we quantize these to
# the start of the day in question, in UTC.
now = datetime.now()
s = now.utctimetuple()
ts = int(
time.mktime(
time.struct_time(
(s.tm_year, s.tm_mon, s.tm_mday, 0, 0, 0, 0, s.tm_yday, 0))))
tag_create(
repo=git,
tag=v.encode("utf8"),
author=author.encode("utf8"),
message="Release {}".format(v).encode("utf8"),
annotated=True,
objectish=b"HEAD",
sign=author.encode("utf8"),
tag_time=ts,
tag_timezone=0,
)
print("Tag created locally, it is not pushed")
print("To push it run something like:")
print(" git push origin {}".format(v))
def performCommit(localRepo, bookid, bookinfo, bookroot, bookfiles):
has_error = False
staged = []
added = []
ignored = []
# convert url paths to os specific paths
repo_home = pathof(localRepo)
repo_home = repo_home.replace("/", os.sep)
repo_path = os.path.join(repo_home, "epub_" + bookid)
book_home = pathof(bookroot)
book_home = book_home.replace("/", os.sep)
# convert from bookpaths to os relative file paths
filepaths = []
for bkpath in bookfiles:
afile = pathof(bkpath)
afile = afile.replace("/", os.sep)
filepaths.append(afile)
cdir = os.getcwd()
if os.path.exists(repo_path):
# handle updating the staged files and commiting and tagging
# first collect info to determine files to delete form repo
# current tag, etc
os.chdir(repo_path)
# determine the new tag
tags = porcelain.list_tags(repo='.')
tagname = "V%04d" % (len(tags) + 1)
tagmessage = "Tag: " + tagname
message = "updating to " + tagname
# extra parameters must be passed as bytes if annotated is true
tagname = utf8_str(tagname)
message = utf8_str(message)
tagmessage = utf8_str(tagmessage)
# delete files that are no longer needed from staging area
tracked = []
tracked = porcelain.ls_files(repo='.')
files_to_delete = []
for afile in tracked:
afile = pathof(afile)
if afile not in filepaths:
if afile not in ["mimetype", ".gitignore", ".bookinfo"]:
files_to_delete.append(afile)
if len(files_to_delete) > 0:
porcelain.rm(repo='.', paths=files_to_delete)
# copy over current files
copy_book_contents_to_destination(book_home, filepaths, repo_path)
(staged, unstaged, untracked) = porcelain.status(repo='.')
files_to_update = []
for afile in unstaged:
afile = pathof(afile)
files_to_update.append(afile)
for afile in untracked:
afile = pathof(afile)
files_to_update.append(afile)
(added, ignored) = porcelain.add(repo='.', paths=files_to_update)
commit_sha1 = porcelain.commit(repo='.',
message=message,
author=_SIGIL,
committer=_SIGIL)
# create annotated tags so we can get a date history
tag = porcelain.tag_create(repo='.',
tag=tagname,
message=tagmessage,
annotated=True,
author=_SIGIL)
os.chdir(cdir)
add_bookinfo(repo_path, bookinfo, bookid, unicode_str(tagname))
else:
# this will be an initial commit to this repo
tagname = b"V0001"
tagmessage = b'First Tag'
message = b"Initial Commit"
os.makedirs(repo_path)
add_gitignore(repo_path)
add_gitattributes(repo_path)
cdir = os.getcwd()
os.chdir(repo_path)
r = porcelain.init(path='.', bare=False)
staged = copy_book_contents_to_destination(book_home, filepaths,
repo_path)
(added, ignored) = porcelain.add(repo='.', paths=staged)
# it seems author, committer, messages, and tagname only work with bytes if annotated=True
commit_sha1 = porcelain.commit(repo='.',
message=message,
author=_SIGIL,
committer=_SIGIL)
tag = porcelain.tag_create(repo='.',
tag=tagname,
message=tagmessage,
annotated=True,
author=_SIGIL)
os.chdir(cdir)
add_bookinfo(repo_path, bookinfo, bookid, unicode_str(tagname))
result = "\n".join(added)
result = result + "***********" + "\n".join(ignored)
if not has_error:
return result
return ''
