hgext/win32text.py

test-transaction-safety: glog out irrelevant flag

The test is focussing on the inline flag, so we glob out the other to highlight
that fact and prevent noise in the future.

# win32text.py - LF <-> CRLF/CR translation utilities for Windows/Mac users
#
#  Copyright 2005, 2007-2009 Olivia Mackall <[e-mail]> and others
#
# This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version.

'''perform automatic newline conversion (DEPRECATED)

  Deprecation: The win32text extension requires each user to configure
  the extension again and again for each clone since the configuration
  is not copied when cloning.

  We have therefore made the ``eol`` as an alternative. The ``eol``
  uses a version controlled file for its configuration and each clone
  will therefore use the right settings from the start.

To perform automatic newline conversion, use::

  [extensions]
  win32text =
  [encode]
  ** = cleverencode:
  # or ** = macencode:

  [decode]
  ** = cleverdecode:
  # or ** = macdecode:

If not doing conversion, to make sure you do not commit CRLF/CR by accident::

  [hooks]
  pretxncommit.crlf = python:hgext.win32text.forbidcrlf
  # or pretxncommit.cr = python:hgext.win32text.forbidcr

To do the same check on a server to prevent CRLF/CR from being
pushed or pulled::

  [hooks]
  pretxnchangegroup.crlf = python:hgext.win32text.forbidcrlf
  # or pretxnchangegroup.cr = python:hgext.win32text.forbidcr
'''


import re
from mercurial.i18n import _
from mercurial.node import short
from mercurial import (
    cmdutil,
    extensions,
    registrar,
)
from mercurial.utils import stringutil

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

configtable = {}
configitem = registrar.configitem(configtable)

configitem(
    b'win32text',
    b'warn',
    default=True,
)

# regexp for single LF without CR preceding.
re_single_lf = re.compile(b'(^|[^\r])\n', re.MULTILINE)

newlinestr = {b'\r\n': b'CRLF', b'\r': b'CR'}
filterstr = {b'\r\n': b'clever', b'\r': b'mac'}


def checknewline(s, newline, ui=None, repo=None, filename=None):
    # warn if already has 'newline' in repository.
    # it might cause unexpected eol conversion.
    # see issue 302:
    #   https://bz.mercurial-scm.org/302
    if newline in s and ui and filename and repo:
        ui.warn(
            _(
                b'WARNING: %s already has %s line endings\n'
                b'and does not need EOL conversion by the win32text plugin.\n'
                b'Before your next commit, please reconsider your '
                b'encode/decode settings in \nMercurial.ini or %s.\n'
            )
            % (filename, newlinestr[newline], repo.vfs.join(b'hgrc'))
        )


def dumbdecode(s, cmd, **kwargs):
    checknewline(s, b'\r\n', **kwargs)
    # replace single LF to CRLF
    return re_single_lf.sub(b'\\1\r\n', s)


def dumbencode(s, cmd):
    return s.replace(b'\r\n', b'\n')


def macdumbdecode(s, cmd, **kwargs):
    checknewline(s, b'\r', **kwargs)
    return s.replace(b'\n', b'\r')


def macdumbencode(s, cmd):
    return s.replace(b'\r', b'\n')


def cleverdecode(s, cmd, **kwargs):
    if not stringutil.binary(s):
        return dumbdecode(s, cmd, **kwargs)
    return s


def cleverencode(s, cmd):
    if not stringutil.binary(s):
        return dumbencode(s, cmd)
    return s


def macdecode(s, cmd, **kwargs):
    if not stringutil.binary(s):
        return macdumbdecode(s, cmd, **kwargs)
    return s


def macencode(s, cmd):
    if not stringutil.binary(s):
        return macdumbencode(s, cmd)
    return s


_filters = {
    b'dumbdecode:': dumbdecode,
    b'dumbencode:': dumbencode,
    b'cleverdecode:': cleverdecode,
    b'cleverencode:': cleverencode,
    b'macdumbdecode:': macdumbdecode,
    b'macdumbencode:': macdumbencode,
    b'macdecode:': macdecode,
    b'macencode:': macencode,
}


def forbidnewline(ui, repo, hooktype, node, newline, **kwargs):
    halt = False
    seen = set()
    # we try to walk changesets in reverse order from newest to
    # oldest, so that if we see a file multiple times, we take the
    # newest version as canonical. this prevents us from blocking a
    # changegroup that contains an unacceptable commit followed later
    # by a commit that fixes the problem.
    tip = repo[b'tip']
    for rev in range(repo.changelog.tiprev(), repo[node].rev() - 1, -1):
        c = repo[rev]
        for f in c.files():
            if f in seen or f not in tip or f not in c:
                continue
            seen.add(f)
            data = c[f].data()
            if not stringutil.binary(data) and newline in data:
                if not halt:
                    ui.warn(
                        _(
                            b'attempt to commit or push text file(s) '
                            b'using %s line endings\n'
                        )
                        % newlinestr[newline]
                    )
                ui.warn(_(b'in %s: %s\n') % (short(c.node()), f))
                halt = True
    if halt and hooktype == b'pretxnchangegroup':
        crlf = newlinestr[newline].lower()
        filter = filterstr[newline]
        ui.warn(
            _(
                b'\nTo prevent this mistake in your local repository,\n'
                b'add to Mercurial.ini or .hg/hgrc:\n'
                b'\n'
                b'[hooks]\n'
                b'pretxncommit.%s = python:hgext.win32text.forbid%s\n'
                b'\n'
                b'and also consider adding:\n'
                b'\n'
                b'[extensions]\n'
                b'win32text =\n'
                b'[encode]\n'
                b'** = %sencode:\n'
                b'[decode]\n'
                b'** = %sdecode:\n'
            )
            % (crlf, crlf, filter, filter)
        )
    return halt


def forbidcrlf(ui, repo, hooktype, node, **kwargs):
    return forbidnewline(ui, repo, hooktype, node, b'\r\n', **kwargs)


def forbidcr(ui, repo, hooktype, node, **kwargs):
    return forbidnewline(ui, repo, hooktype, node, b'\r', **kwargs)


def reposetup(ui, repo):
    if not repo.local():
        return
    for name, fn in _filters.items():
        repo.adddatafilter(name, fn)


def wrap_revert(orig, repo, ctx, names, uipathfn, actions, *args, **kwargs):
    # reset dirstate cache for file we touch
    ds = repo.dirstate
    for filename in actions[b'revert'][0]:
        entry = ds.get_entry(filename)
        if entry is not None:
            if entry.p1_tracked:
                # If we revert the file, it is possibly dirty. However,
                # this extension meddle with the file content and therefore
                # its size. As a result, we cannot simply call
                # `dirstate.set_possibly_dirty` as it will not affet the
                # expected size of the file.
                #
                # At least, now, the quirk is properly documented.
                ds.hacky_extension_update_file(
                    filename,
                    entry.tracked,
                    p1_tracked=entry.p1_tracked,
                    p2_info=entry.p2_info,
                )
    return orig(repo, ctx, names, uipathfn, actions, *args, **kwargs)


def extsetup(ui):
    # deprecated config: win32text.warn
    if ui.configbool(b'win32text', b'warn'):
        ui.warn(
            _(
                b"win32text is deprecated: "
                b"https://mercurial-scm.org/wiki/Win32TextExtension\n"
            )
        )
    extensions.wrapfunction(cmdutil, '_performrevert', wrap_revert)