# 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.

"""

import difflib

import re

from mercurial.i18n import _

from mercurial.pycompat import open

from mercurial.node import hex

from mercurial import (

    cmdutil,

    config,

    error,

    logcmdutil,

    minirst,

    pycompat,

    registrar,

    util,

)

from mercurial.utils import (

    procutil,

    stringutil,

)

cmdtable = {}

command = registrar.command(cmdtable)

try:

    # Silence a warning about python-Levenshtein.

    #

    # We don't need the the performance that much and it get anoying in tests.

    import warnings

    with warnings.catch_warnings():

        warnings.filterwarnings(

            action="ignore",

            message=".*python-Levenshtein.*",

            category=UserWarning,

            module="fuzzywuzzy.fuzz",

        )

        import fuzzywuzzy.fuzz as fuzz

        fuzz.token_set_ratio

except ImportError:

    fuzz = None

# 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.

testedwith = b'ships-with-hg-core'

DEFAULT_SECTIONS = [

    (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')),

]

RE_DIRECTIVE = re.compile(br'^\.\. ([a-zA-Z0-9_]+)::\s*([^$]+)?$')

RE_ISSUE = br'\bissue ?[0-9]{4,6}(?![0-9])\b'

BULLET_SECTION = _(b'Other Changes')

class parsedreleasenotes:

    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.

        """

        if not fuzz:

            ui.warn(

                _(

                    b"module 'fuzzywuzzy' not found, merging of similar "

                    b"releasenotes is disabled\n"

                )

            )

        for section in other:

            existingnotes = converttitled(

                self.titledforsection(section)

            ) + convertnontitled(self.nontitledforsection(section))

            for title, paragraphs in other.titledforsection(section):

                if self.hastitledinsection(section, title):

                    # TODO prompt for resolution if different and running in

                    # interactive mode.

                    ui.write(

                        _(b'%s already exists in %s section; ignoring\n')

                        % (title, section)

                    )

                    continue

                incoming_str = converttitled([(title, paragraphs)])[0]

                if section == b'fix':

                    issue = getissuenum(incoming_str)

                    if issue:

                        if findissue(ui, existingnotes, issue):

                            continue

                if similar(ui, existingnotes, incoming_str):

                    continue

                self.addtitleditem(section, title, paragraphs)

            for paragraphs in other.nontitledforsection(section):

                if paragraphs in self.nontitledforsection(section):

                    continue

                incoming_str = convertnontitled([paragraphs])[0]

                if section == b'fix':

                    issue = getissuenum(incoming_str)

                    if issue:

                        if findissue(ui, existingnotes, issue):

                            continue

                if similar(ui, existingnotes, incoming_str):

                    continue

                self.addnontitleditem(section, paragraphs)

class releasenotessections:

    def __init__(self, ui, repo=None):

        if repo:

            sections = util.sortdict(DEFAULT_SECTIONS)

            custom_sections = getcustomadmonitions(repo)

            if custom_sections:

                sections.update(custom_sections)

            self._sections = list(sections.items())

        else:

            self._sections = list(DEFAULT_SECTIONS)

    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

def converttitled(titledparagraphs):

    """

    Convert titled paragraphs to strings

    """

    string_list = []

    for title, paragraphs in titledparagraphs:

        lines = []

        for para in paragraphs:

            lines.extend(para)

        string_list.append(b' '.join(lines))

    return string_list

def convertnontitled(nontitledparagraphs):

    """

    Convert non-titled bullets to strings

    """

    string_list = []

    for paragraphs in nontitledparagraphs:

        lines = []

        for para in paragraphs:

            lines.extend(para)

        string_list.append(b' '.join(lines))

    return string_list

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

def findissue(ui, existing, issue):

    """

    Returns true if issue number already exists in notes.

    """

    if any(issue in s for s in existing):

        ui.write(_(b'"%s" already exists in notes; ignoring\n') % issue)

        return True

    else:

        return False

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:

            ui.write(

                _(b'"%s" already exists in notes file; ignoring\n')

                % incoming_str

            )

            return True

        else:

            return False

    else:

        return False

def similaritycheck(incoming_str, existingnotes):

    """

    Returns false when note fragment can be merged to existing notes.

    """

    # fuzzywuzzy not present

    if not fuzz:

        return True

    merge = True

    for bullet in existingnotes:

        score = fuzz.token_set_ratio(incoming_str, bullet)

        if score > 75:

            merge = False

            break

    return merge

def getcustomadmonitions(repo):

    ctx = repo[b'.']

    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:

            raise error.Abort(

                _(b".hgreleasenotes file \'%s\' not found") % repo.pathto(f)

            )

    if b'.hgreleasenotes' in ctx:

        read(b'.hgreleasenotes')

    return p.items(b'sections')

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:

                ui.write(

                    _(b"Invalid admonition '%s' present in changeset %s\n")

                    % (admonition.group(1), ctx.hex()[:12])

                )

                sim = lambda x: difflib.SequenceMatcher(

                    None, admonition.group(1), x

                ).ratio()

                similar = [s for s in directives if sim(s) > 0.6]

                if len(similar) == 1:

                    ui.write(_(b"(did you mean %s?)\n") % similar[0])

                elif similar:

                    ss = b", ".join(sorted(similar))

                    ui.write(_(b"(did you mean one of %s?)\n") % ss)

def _getadmonitionlist(ui, sections):

    for section in sections:

        ui.write(b"%s: %s\n" % (section[0], section[1]))

def parsenotesfromrevisions(repo, directives, revs):

    notes = parsedreleasenotes()

    for rev in revs:

        ctx = repo[rev]

        blocks, pruned = minirst.parse(

            ctx.description(), admonitions=directives

        )

        for i, block in enumerate(blocks):

            if block[b'type'] != b'admonition':

                continue

            directive = block[b'admonitiontitle']

            title = block[b'lines'][0].strip() if block[b'lines'] else None

            if i + 1 == len(blocks):

                raise error.Abort(

                    _(

                        b'changeset %s: release notes directive %s '

                        b'lacks content'

                    )

                    % (ctx, directive)

                )

            # 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.

                if pblock[b'type'] == b'margin':

                    continue

                if pblock[b'type'] == b'admonition':

                    break

                if pblock[b'type'] != b'paragraph':

                    repo.ui.warn(

                        _(

                            b'changeset %s: unexpected block in release '

                            b'notes directive %s\n'

                        )

                        % (ctx, directive)

                    )

                if pblock[b'indent'] > 0:

                    paragraphs.append(pblock[b'lines'])

                else:

                    break

            # TODO consider using title as paragraph for more concise notes.

            if not paragraphs:

                repo.ui.warn(

                    _(b"error parsing releasenotes for revision: '%s'\n")

                    % hex(ctx.node())

                )

            if title:

                notes.addtitleditem(directive, title, paragraphs)