releasenotes.py
722 lines
| 21.8 KiB
| text/x-python
|
PythonLexer
/ hgext / releasenotes.py
|
r32778 | # Copyright 2017-present Gregory Szorc <gregory.szorc@gmail.com> | ||
# | ||||
# This software may be used and distributed according to the terms of the | ||||
# GNU General Public License version 2 or any later version. | ||||
"""generate release notes from commit messages (EXPERIMENTAL) | ||||
It is common to maintain files detailing changes in a project between | ||||
releases. Maintaining these files can be difficult and time consuming. | ||||
The :hg:`releasenotes` command provided by this extension makes the | ||||
process simpler by automating it. | ||||
""" | ||||
|
r33883 | import difflib | ||
|
r32778 | import re | ||
from mercurial.i18n import _ | ||||
|
r43355 | from mercurial.pycompat import open | ||
|
r46729 | from mercurial.node import hex | ||
|
r32778 | from mercurial import ( | ||
|
r44350 | cmdutil, | ||
|
r33572 | config, | ||
|
r32778 | error, | ||
|
r48928 | logcmdutil, | ||
|
r32778 | minirst, | ||
|
r35004 | pycompat, | ||
|
r32778 | registrar, | ||
|
r33572 | util, | ||
|
r32778 | ) | ||
|
r45598 | from mercurial.utils import ( | ||
procutil, | ||||
stringutil, | ||||
) | ||||
|
r32778 | |||
cmdtable = {} | ||||
command = registrar.command(cmdtable) | ||||
|
r34813 | try: | ||
r48655 | # Silence a warning about python-Levenshtein. | |||
# | ||||
# We don't need the the performance that much and it get anoying in tests. | ||||
import warnings | ||||
|
r43346 | |||
r48655 | with warnings.catch_warnings(): | |||
warnings.filterwarnings( | ||||
action="ignore", | ||||
message=".*python-Levenshtein.*", | ||||
category=UserWarning, | ||||
module="fuzzywuzzy.fuzz", | ||||
) | ||||
|
r50744 | import fuzzywuzzy.fuzz as fuzz # pytype: disable=import-error | ||
r48655 | ||||
fuzz.token_set_ratio | ||||
|
r34813 | except ImportError: | ||
fuzz = None | ||||
|
r32778 | # Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for | ||
# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should | ||||
# be specifying the version(s) of Mercurial they are tested with, or | ||||
# leave the attribute unspecified. | ||||
|
r43347 | testedwith = b'ships-with-hg-core' | ||
|
r32778 | |||
DEFAULT_SECTIONS = [ | ||||
|
r43347 | (b'feature', _(b'New Features')), | ||
(b'bc', _(b'Backwards Compatibility Changes')), | ||||
(b'fix', _(b'Bug Fixes')), | ||||
(b'perf', _(b'Performance Improvements')), | ||||
(b'api', _(b'API Changes')), | ||||
|
r32778 | ] | ||
|
r50413 | RE_DIRECTIVE = re.compile(br'^\.\. ([a-zA-Z0-9_]+)::\s*([^$]+)?$', re.MULTILINE) | ||
|
r40271 | RE_ISSUE = br'\bissue ?[0-9]{4,6}(?![0-9])\b' | ||
|
r32778 | |||
|
r43347 | BULLET_SECTION = _(b'Other Changes') | ||
|
r32778 | |||
|
r43346 | |||
|
r49801 | class parsedreleasenotes: | ||
|
r32778 | def __init__(self): | ||
self.sections = {} | ||||
def __contains__(self, section): | ||||
return section in self.sections | ||||
def __iter__(self): | ||||
return iter(sorted(self.sections)) | ||||
def addtitleditem(self, section, title, paragraphs): | ||||
"""Add a titled release note entry.""" | ||||
self.sections.setdefault(section, ([], [])) | ||||
self.sections[section][0].append((title, paragraphs)) | ||||
def addnontitleditem(self, section, paragraphs): | ||||
"""Adds a non-titled release note entry. | ||||
Will be rendered as a bullet point. | ||||
""" | ||||
self.sections.setdefault(section, ([], [])) | ||||
self.sections[section][1].append(paragraphs) | ||||
def titledforsection(self, section): | ||||
"""Returns titled entries in a section. | ||||
Returns a list of (title, paragraphs) tuples describing sub-sections. | ||||
""" | ||||
return self.sections.get(section, ([], []))[0] | ||||
def nontitledforsection(self, section): | ||||
"""Returns non-titled, bulleted paragraphs in a section.""" | ||||
return self.sections.get(section, ([], []))[1] | ||||
def hastitledinsection(self, section, title): | ||||
return any(t[0] == title for t in self.titledforsection(section)) | ||||
def merge(self, ui, other): | ||||
"""Merge another instance into this one. | ||||
This is used to combine multiple sources of release notes together. | ||||
""" | ||||
|
r34814 | if not fuzz: | ||
|
r43346 | ui.warn( | ||
_( | ||||
|
r43347 | b"module 'fuzzywuzzy' not found, merging of similar " | ||
b"releasenotes is disabled\n" | ||||
|
r43346 | ) | ||
) | ||||
|
r34814 | |||
|
r32778 | for section in other: | ||
|
r43346 | existingnotes = converttitled( | ||
self.titledforsection(section) | ||||
) + convertnontitled(self.nontitledforsection(section)) | ||||
|
r32778 | for title, paragraphs in other.titledforsection(section): | ||
if self.hastitledinsection(section, title): | ||||
# TODO prompt for resolution if different and running in | ||||
# interactive mode. | ||||
|
r43346 | ui.write( | ||
|
r43347 | _(b'%s already exists in %s section; ignoring\n') | ||
|
r43346 | % (title, section) | ||
) | ||||
|
r32778 | continue | ||
|
r33661 | incoming_str = converttitled([(title, paragraphs)])[0] | ||
|
r43347 | if section == b'fix': | ||
|
r33661 | issue = getissuenum(incoming_str) | ||
if issue: | ||||
if findissue(ui, existingnotes, issue): | ||||
continue | ||||
if similar(ui, existingnotes, incoming_str): | ||||
continue | ||||
|
r32778 | self.addtitleditem(section, title, paragraphs) | ||
for paragraphs in other.nontitledforsection(section): | ||||
if paragraphs in self.nontitledforsection(section): | ||||
continue | ||||
|
r33661 | incoming_str = convertnontitled([paragraphs])[0] | ||
|
r43347 | if section == b'fix': | ||
|
r33661 | issue = getissuenum(incoming_str) | ||
if issue: | ||||
if findissue(ui, existingnotes, issue): | ||||
continue | ||||
if similar(ui, existingnotes, incoming_str): | ||||
continue | ||||
|
r32778 | self.addnontitleditem(section, paragraphs) | ||
|
r43346 | |||
|
r49801 | class releasenotessections: | ||
|
r33572 | def __init__(self, ui, repo=None): | ||
if repo: | ||||
sections = util.sortdict(DEFAULT_SECTIONS) | ||||
custom_sections = getcustomadmonitions(repo) | ||||
if custom_sections: | ||||
sections.update(custom_sections) | ||||
|
r49768 | self._sections = list(sections.items()) | ||
|
r33572 | else: | ||
self._sections = list(DEFAULT_SECTIONS) | ||||
|
r32778 | |||
def __iter__(self): | ||||
return iter(self._sections) | ||||
def names(self): | ||||
return [t[0] for t in self._sections] | ||||
def sectionfromtitle(self, title): | ||||
for name, value in self._sections: | ||||
if value == title: | ||||
return name | ||||
return None | ||||
|
r43346 | |||
|
r33661 | def converttitled(titledparagraphs): | ||
""" | ||||
Convert titled paragraphs to strings | ||||
""" | ||||
string_list = [] | ||||
for title, paragraphs in titledparagraphs: | ||||
lines = [] | ||||
for para in paragraphs: | ||||
lines.extend(para) | ||||
|
r43347 | string_list.append(b' '.join(lines)) | ||
|
r33661 | return string_list | ||
|
r43346 | |||
|
r33661 | def convertnontitled(nontitledparagraphs): | ||
""" | ||||
Convert non-titled bullets to strings | ||||
""" | ||||
string_list = [] | ||||
for paragraphs in nontitledparagraphs: | ||||
lines = [] | ||||
for para in paragraphs: | ||||
lines.extend(para) | ||||
|
r43347 | string_list.append(b' '.join(lines)) | ||
|
r33661 | return string_list | ||
|
r43346 | |||
|
r33661 | def getissuenum(incoming_str): | ||
""" | ||||
Returns issue number from the incoming string if it exists | ||||
""" | ||||
issue = re.search(RE_ISSUE, incoming_str, re.IGNORECASE) | ||||
if issue: | ||||
issue = issue.group() | ||||
return issue | ||||
|
r43346 | |||
|
r33661 | def findissue(ui, existing, issue): | ||
""" | ||||
Returns true if issue number already exists in notes. | ||||
""" | ||||
if any(issue in s for s in existing): | ||||
|
r43347 | ui.write(_(b'"%s" already exists in notes; ignoring\n') % issue) | ||
|
r33661 | return True | ||
else: | ||||
return False | ||||
|
r43346 | |||
|
r33661 | def similar(ui, existing, incoming_str): | ||
""" | ||||
Returns true if similar note found in existing notes. | ||||
""" | ||||
if len(incoming_str.split()) > 10: | ||||
merge = similaritycheck(incoming_str, existing) | ||||
if not merge: | ||||
|
r43346 | ui.write( | ||
|
r43347 | _(b'"%s" already exists in notes file; ignoring\n') | ||
|
r43346 | % incoming_str | ||
) | ||||
|
r33661 | return True | ||
else: | ||||
return False | ||||
else: | ||||
return False | ||||
|
r43346 | |||
|
r33661 | def similaritycheck(incoming_str, existingnotes): | ||
""" | ||||
|
r34781 | Returns false when note fragment can be merged to existing notes. | ||
|
r33661 | """ | ||
|
r34813 | # fuzzywuzzy not present | ||
if not fuzz: | ||||
|
r34811 | return True | ||
|
r33661 | merge = True | ||
for bullet in existingnotes: | ||||
score = fuzz.token_set_ratio(incoming_str, bullet) | ||||
if score > 75: | ||||
merge = False | ||||
break | ||||
return merge | ||||
|
r43346 | |||
|
r33572 | def getcustomadmonitions(repo): | ||
|
r43347 | ctx = repo[b'.'] | ||
|
r33572 | p = config.config() | ||
def read(f, sections=None, remap=None): | ||||
if f in ctx: | ||||
data = ctx[f].data() | ||||
p.parse(f, data, sections, remap, read) | ||||
else: | ||||
|
r43346 | raise error.Abort( | ||
|
r43347 | _(b".hgreleasenotes file \'%s\' not found") % repo.pathto(f) | ||
|
r43346 | ) | ||
|
r33572 | |||
|
r43347 | if b'.hgreleasenotes' in ctx: | ||
read(b'.hgreleasenotes') | ||||
r47384 | return p.items(b'sections') | |||
|
r33572 | |||
|
r43346 | |||
|
r33883 | def checkadmonitions(ui, repo, directives, revs): | ||
""" | ||||
Checks the commit messages for admonitions and their validity. | ||||
.. abcd:: | ||||
First paragraph under this admonition | ||||
For this commit message, using `hg releasenotes -r . --check` | ||||
returns: Invalid admonition 'abcd' present in changeset 3ea92981e103 | ||||
As admonition 'abcd' is neither present in default nor custom admonitions | ||||
""" | ||||
for rev in revs: | ||||
ctx = repo[rev] | ||||
admonition = re.search(RE_DIRECTIVE, ctx.description()) | ||||
if admonition: | ||||
if admonition.group(1) in directives: | ||||
continue | ||||
else: | ||||
|
r43346 | ui.write( | ||
|
r43387 | _(b"Invalid admonition '%s' present in changeset %s\n") | ||
|
r43346 | % (admonition.group(1), ctx.hex()[:12]) | ||
) | ||||
sim = lambda x: difflib.SequenceMatcher( | ||||
None, admonition.group(1), x | ||||
).ratio() | ||||
|
r33883 | |||
similar = [s for s in directives if sim(s) > 0.6] | ||||
if len(similar) == 1: | ||||
|
r43347 | ui.write(_(b"(did you mean %s?)\n") % similar[0]) | ||
|
r33883 | elif similar: | ||
|
r43347 | ss = b", ".join(sorted(similar)) | ||
ui.write(_(b"(did you mean one of %s?)\n") % ss) | ||||
|
r33883 | |||
|
r43346 | |||
|
r33942 | def _getadmonitionlist(ui, sections): | ||
for section in sections: | ||||
|
r43347 | ui.write(b"%s: %s\n" % (section[0], section[1])) | ||
|
r33942 | |||
|
r43346 | |||
|
r32778 | def parsenotesfromrevisions(repo, directives, revs): | ||
notes = parsedreleasenotes() | ||||
for rev in revs: | ||||
ctx = repo[rev] | ||||
|
r43346 | blocks, pruned = minirst.parse( | ||
ctx.description(), admonitions=directives | ||||
) | ||||
|
r32778 | |||
for i, block in enumerate(blocks): | ||||
|
r43347 | if block[b'type'] != b'admonition': | ||
|
r32778 | continue | ||
|
r43347 | directive = block[b'admonitiontitle'] | ||
title = block[b'lines'][0].strip() if block[b'lines'] else None | ||||
|
r32778 | |||
if i + 1 == len(blocks): | ||||
|
r43346 | raise error.Abort( | ||
_( | ||||
|
r43347 | b'changeset %s: release notes directive %s ' | ||
b'lacks content' | ||||
|
r43346 | ) | ||
% (ctx, directive) | ||||
) | ||||
|
r32778 | |||
# Now search ahead and find all paragraphs attached to this | ||||
# admonition. | ||||
paragraphs = [] | ||||
for j in range(i + 1, len(blocks)): | ||||
pblock = blocks[j] | ||||
# Margin blocks may appear between paragraphs. Ignore them. | ||||
|
r43347 | if pblock[b'type'] == b'margin': | ||
|
r32778 | continue | ||
|
r43347 | if pblock[b'type'] == b'admonition': | ||
|
r36788 | break | ||
|
r43347 | if pblock[b'type'] != b'paragraph': | ||
|
r43346 | repo.ui.warn( | ||
_( | ||||
|
r43347 | b'changeset %s: unexpected block in release ' | ||
b'notes directive %s\n' | ||||
|
r43346 | ) | ||
% (ctx, directive) | ||||
) | ||||
|
r32778 | |||
|
r43347 | if pblock[b'indent'] > 0: | ||
paragraphs.append(pblock[b'lines']) | ||||
|
r32778 | else: | ||
break | ||||
# TODO consider using title as paragraph for more concise notes. | ||||
if not paragraphs: | ||||
|
r43346 | repo.ui.warn( | ||
|
r43387 | _(b"error parsing releasenotes for revision: '%s'\n") | ||
|
r46729 | % hex(ctx.node()) | ||
|
r43346 | ) | ||
|
r32778 | if title: | ||
notes.addtitleditem(directive, title, paragraphs) | ||||
else: | ||||
notes.addnontitleditem(directive, paragraphs) | ||||
return notes | ||||
|
r43346 | |||
|
r32778 | def parsereleasenotesfile(sections, text): | ||
"""Parse text content containing generated release notes.""" | ||||
notes = parsedreleasenotes() | ||||
blocks = minirst.parse(text)[0] | ||||
|
r33012 | def gatherparagraphsbullets(offset, title=False): | ||
notefragment = [] | ||||
|
r32778 | |||
for i in range(offset + 1, len(blocks)): | ||||
block = blocks[i] | ||||
|
r43347 | if block[b'type'] == b'margin': | ||
|
r32778 | continue | ||
|
r43347 | elif block[b'type'] == b'section': | ||
|
r32778 | break | ||
|
r43347 | elif block[b'type'] == b'bullet': | ||
if block[b'indent'] != 0: | ||||
raise error.Abort(_(b'indented bullet lists not supported')) | ||||
|
r33012 | if title: | ||
|
r43347 | lines = [l[1:].strip() for l in block[b'lines']] | ||
|
r33012 | notefragment.append(lines) | ||
continue | ||||
else: | ||||
|
r43347 | lines = [[l[1:].strip() for l in block[b'lines']]] | ||
|
r32778 | |||
|
r43346 | for block in blocks[i + 1 :]: | ||
|
r43347 | if block[b'type'] in (b'bullet', b'section'): | ||
|
r33012 | break | ||
|
r43347 | if block[b'type'] == b'paragraph': | ||
lines.append(block[b'lines']) | ||||
|
r33012 | notefragment.append(lines) | ||
continue | ||||
|
r43347 | elif block[b'type'] != b'paragraph': | ||
|
r43346 | raise error.Abort( | ||
|
r43387 | _(b'unexpected block type in release notes: %s') | ||
|
r43347 | % block[b'type'] | ||
|
r43346 | ) | ||
|
r33012 | if title: | ||
|
r43347 | notefragment.append(block[b'lines']) | ||
|
r32778 | |||
|
r33012 | return notefragment | ||
|
r32778 | |||
currentsection = None | ||||
for i, block in enumerate(blocks): | ||||
|
r43347 | if block[b'type'] != b'section': | ||
|
r32778 | continue | ||
|
r43347 | title = block[b'lines'][0] | ||
|
r32778 | |||
# TODO the parsing around paragraphs and bullet points needs some | ||||
# work. | ||||
|
r43347 | if block[b'underline'] == b'=': # main section | ||
|
r32778 | name = sections.sectionfromtitle(title) | ||
if not name: | ||||
|
r43346 | raise error.Abort( | ||
|
r43347 | _(b'unknown release notes section: %s') % title | ||
|
r43346 | ) | ||
|
r32778 | |||
currentsection = name | ||||
|
r33012 | bullet_points = gatherparagraphsbullets(i) | ||
if bullet_points: | ||||
for para in bullet_points: | ||||
notes.addnontitleditem(currentsection, para) | ||||
|
r32778 | |||
|
r43347 | elif block[b'underline'] == b'-': # sub-section | ||
|
r32778 | if title == BULLET_SECTION: | ||
|
r33012 | bullet_points = gatherparagraphsbullets(i) | ||
for para in bullet_points: | ||||
notes.addnontitleditem(currentsection, para) | ||||
|
r32778 | else: | ||
|
r33012 | paragraphs = gatherparagraphsbullets(i, True) | ||
|
r32778 | notes.addtitleditem(currentsection, title, paragraphs) | ||
else: | ||||
|
r43347 | raise error.Abort(_(b'unsupported section type for %s') % title) | ||
|
r32778 | |||
return notes | ||||
|
r43346 | |||
|
r32778 | def serializenotes(sections, notes): | ||
"""Serialize release notes from parsed fragments and notes. | ||||
This function essentially takes the output of ``parsenotesfromrevisions()`` | ||||
and ``parserelnotesfile()`` and produces output combining the 2. | ||||
""" | ||||
lines = [] | ||||
for sectionname, sectiontitle in sections: | ||||
if sectionname not in notes: | ||||
continue | ||||
lines.append(sectiontitle) | ||||
|
r43347 | lines.append(b'=' * len(sectiontitle)) | ||
lines.append(b'') | ||||
|
r32778 | |||
# First pass to emit sub-sections. | ||||
for title, paragraphs in notes.titledforsection(sectionname): | ||||
lines.append(title) | ||||
|
r43347 | lines.append(b'-' * len(title)) | ||
lines.append(b'') | ||||
|
r32778 | |||
for i, para in enumerate(paragraphs): | ||||
if i: | ||||
|
r43347 | lines.append(b'') | ||
|
r43346 | lines.extend( | ||
|
r43347 | stringutil.wrap(b' '.join(para), width=78).splitlines() | ||
|
r43346 | ) | ||
|
r32778 | |||
|
r43347 | lines.append(b'') | ||
|
r32778 | |||
# Second pass to emit bullet list items. | ||||
# If the section has titled and non-titled items, we can't | ||||
# simply emit the bullet list because it would appear to come | ||||
# from the last title/section. So, we emit a new sub-section | ||||
# for the non-titled items. | ||||
nontitled = notes.nontitledforsection(sectionname) | ||||
if notes.titledforsection(sectionname) and nontitled: | ||||
# TODO make configurable. | ||||
lines.append(BULLET_SECTION) | ||||
|
r43347 | lines.append(b'-' * len(BULLET_SECTION)) | ||
lines.append(b'') | ||||
|
r32778 | |||
for paragraphs in nontitled: | ||||
|
r43346 | lines.extend( | ||
stringutil.wrap( | ||||
|
r43347 | b' '.join(paragraphs[0]), | ||
|
r43346 | width=78, | ||
|
r43347 | initindent=b'* ', | ||
hangindent=b' ', | ||||
|
r43346 | ).splitlines() | ||
) | ||||
|
r32778 | |||
for para in paragraphs[1:]: | ||||
|
r43347 | lines.append(b'') | ||
|
r43346 | lines.extend( | ||
stringutil.wrap( | ||||
|
r43347 | b' '.join(para), | ||
|
r43346 | width=78, | ||
|
r43347 | initindent=b' ', | ||
hangindent=b' ', | ||||
|
r43346 | ).splitlines() | ||
) | ||||
|
r32778 | |||
|
r43347 | lines.append(b'') | ||
|
r32778 | |||
|
r33781 | if lines and lines[-1]: | ||
|
r43347 | lines.append(b'') | ||
|
r32778 | |||
|
r43347 | return b'\n'.join(lines) | ||
|
r32778 | |||
|
r43346 | |||
@command( | ||||
|
r43347 | b'releasenotes', | ||
|
r43346 | [ | ||
( | ||||
|
r43347 | b'r', | ||
b'rev', | ||||
b'', | ||||
_(b'revisions to process for release notes'), | ||||
_(b'REV'), | ||||
|
r43346 | ), | ||
( | ||||
|
r43347 | b'c', | ||
b'check', | ||||
|
r43346 | False, | ||
|
r43347 | _(b'checks for validity of admonitions (if any)'), | ||
_(b'REV'), | ||||
), | ||||
( | ||||
b'l', | ||||
b'list', | ||||
False, | ||||
_(b'list the available admonitions with their title'), | ||||
|
r43346 | None, | ||
), | ||||
], | ||||
|
r43347 | _(b'hg releasenotes [-r REV] [-c] FILE'), | ||
|
r43346 | helpcategory=command.CATEGORY_CHANGE_NAVIGATION, | ||
) | ||||
|
r33883 | def releasenotes(ui, repo, file_=None, **opts): | ||
|
r32778 | """parse release notes from commit messages into an output file | ||
Given an output file and set of revisions, this command will parse commit | ||||
messages for release notes then add them to the output file. | ||||
Release notes are defined in commit messages as ReStructuredText | ||||
directives. These have the form:: | ||||
.. directive:: title | ||||
content | ||||
Each ``directive`` maps to an output section in a generated release notes | ||||
file, which itself is ReStructuredText. For example, the ``.. feature::`` | ||||
directive would map to a ``New Features`` section. | ||||
Release note directives can be either short-form or long-form. In short- | ||||
form, ``title`` is omitted and the release note is rendered as a bullet | ||||
list. In long form, a sub-section with the title ``title`` is added to the | ||||
section. | ||||
The ``FILE`` argument controls the output file to write gathered release | ||||
notes to. The format of the file is:: | ||||
Section 1 | ||||
========= | ||||
... | ||||
Section 2 | ||||
========= | ||||
... | ||||
Only sections with defined release notes are emitted. | ||||
If a section only has short-form notes, it will consist of bullet list:: | ||||
Section | ||||
======= | ||||
* Release note 1 | ||||
* Release note 2 | ||||
If a section has long-form notes, sub-sections will be emitted:: | ||||
Section | ||||
======= | ||||
Note 1 Title | ||||
------------ | ||||
Description of the first long-form note. | ||||
Note 2 Title | ||||
------------ | ||||
Description of the second long-form note. | ||||
If the ``FILE`` argument points to an existing file, that file will be | ||||
parsed for release notes having the format that would be generated by this | ||||
command. The notes from the processed commit messages will be *merged* | ||||
into this parsed set. | ||||
During release notes merging: | ||||
* Duplicate items are automatically ignored | ||||
* Items that are different are automatically ignored if the similarity is | ||||
greater than a threshold. | ||||
This means that the release notes file can be updated independently from | ||||
this command and changes should not be lost when running this command on | ||||
that file. A particular use case for this is to tweak the wording of a | ||||
release note after it has been added to the release notes file. | ||||
|
r34342 | |||
The -c/--check option checks the commit message for invalid admonitions. | ||||
The -l/--list option, presents the user with a list of existing available | ||||
admonitions along with their title. This also includes the custom | ||||
admonitions (if any). | ||||
|
r32778 | """ | ||
|
r35004 | |||
opts = pycompat.byteskwargs(opts) | ||||
|
r33572 | sections = releasenotessections(ui, repo) | ||
|
r34341 | |||
|
r44655 | cmdutil.check_incompatible_arguments(opts, b'list', [b'rev', b'check']) | ||
|
r34341 | |||
|
r44350 | if opts.get(b'list'): | ||
|
r33942 | return _getadmonitionlist(ui, sections) | ||
|
r43347 | rev = opts.get(b'rev') | ||
|
r48928 | revs = logcmdutil.revrange(repo, [rev or b'not public()']) | ||
|
r43347 | if opts.get(b'check'): | ||
|
r33883 | return checkadmonitions(ui, repo, sections.names(), revs) | ||
|
r32778 | incoming = parsenotesfromrevisions(repo, sections.names(), revs) | ||
|
r34405 | if file_ is None: | ||
|
r43347 | ui.pager(b'releasenotes') | ||
|
r34405 | return ui.write(serializenotes(sections, incoming)) | ||
|
r32778 | try: | ||
|
r43347 | with open(file_, b'rb') as fh: | ||
|
r32778 | notes = parsereleasenotesfile(sections, fh.read()) | ||
|
r50201 | except FileNotFoundError: | ||
|
r32778 | notes = parsedreleasenotes() | ||
notes.merge(ui, incoming) | ||||
|
r43347 | with open(file_, b'wb') as fh: | ||
|
r32778 | fh.write(serializenotes(sections, notes)) | ||
|
r43346 | |||
|
r43347 | @command(b'debugparsereleasenotes', norepo=True) | ||
|
r33572 | def debugparsereleasenotes(ui, path, repo=None): | ||
|
r32778 | """parse release notes and print resulting data structure""" | ||
|
r43347 | if path == b'-': | ||
|
r45598 | text = procutil.stdin.read() | ||
|
r32778 | else: | ||
|
r43347 | with open(path, b'rb') as fh: | ||
|
r32778 | text = fh.read() | ||
|
r33572 | sections = releasenotessections(ui, repo) | ||
|
r32778 | |||
notes = parsereleasenotesfile(sections, text) | ||||
for section in notes: | ||||
|
r43347 | ui.write(_(b'section: %s\n') % section) | ||
|
r32778 | for title, paragraphs in notes.titledforsection(section): | ||
|
r43347 | ui.write(_(b' subsection: %s\n') % title) | ||
|
r32778 | for para in paragraphs: | ||
|
r43347 | ui.write(_(b' paragraph: %s\n') % b' '.join(para)) | ||
|
r32778 | |||
for paragraphs in notes.nontitledforsection(section): | ||||
|
r43347 | ui.write(_(b' bullet point:\n')) | ||
|
r32778 | for para in paragraphs: | ||
|
r43347 | ui.write(_(b' paragraph: %s\n') % b' '.join(para)) | ||