comparison mercurial/localrepo.py @ 45192:509f5b6c0b7e

commitctx: return "touched" status from _filecommit

Instead of mutating a list passed in argument, we simply return the information
from the `_filecommit` function. This make for a cleaner API and allow for
richer information to be returned. That richer information will be used in the
next commit to avoid duplicated computation.

This is part of a larger refactoring/cleanup of the commitctx code to clarify
and augment the logic gathering metadata useful for copy tracing. The current
code is a tad too long and entangled to make such update easy. We start with
easy and small cleanup.

Differential Revision: https://phab.mercurial-scm.org/D8702

45180:a6fde9d789d9

    def currentwlock(self):
        """Returns the wlock if it's held, or None if it's not."""
        return self._currentlock(self._wlockref)

    def _filecommit(
        self,
        fctx,
        manifest1,
        manifest2,
        linkrev,
        tr,
        changelist,
        includecopymeta,
    ):
        """
        commit an individual file as part of a larger transaction

        input:

            fctx:       a file context with the content we are trying to commit
            manifest1:  manifest of changeset first parent
            manifest2:  manifest of changeset second parent
            linkrev:    revision number of the changeset being created
            tr:         current transation
            changelist: list of file being changed (modified inplace)
            individual: boolean, set to False to skip storing the copy data
                        (only used by the Google specific feature of using
                        changeset extra as copy source of truth).

        output:

            The resulting filenode
        """

        fname = fctx.path()
        fparent1 = manifest1.get(fname, nullid)
        fparent2 = manifest2.get(fname, nullid)
        if isinstance(fctx, context.filectx):
            node = fctx.filenode()
            if node in [fparent1, fparent2]:
                self.ui.debug(b'reusing %s filelog entry\n' % fname)
                if (

                    and manifest1.flags(fname) != fctx.flags()
                ) or (
                    fparent2 != nullid
                    and manifest2.flags(fname) != fctx.flags()
                ):
                    changelist.append(fname)
                return node

        flog = self.file(fname)
        meta = {}
        cfname = fctx.copysource()
        if cfname and cfname != fname:
            # Mark the new revision of this file as a copy of another
            # file.  This copy data will effectively act as a parent
            # of this new revision.  If this is a merge, the first
            # parent will be the nullid (meaning "look up the copy data")

                    fparent1, fparent2 = fparent2, nullid

        # is the file changed?
        text = fctx.data()
        if fparent2 != nullid or meta or flog.cmp(fparent1, text):
            changelist.append(fname)
            return flog.add(text, meta, tr, linkrev, fparent1, fparent2)
        # are just the flags changed during merge?
        elif fname in manifest1 and manifest1.flags(fname) != fctx.flags():
            changelist.append(fname)

        return fparent1

    def checkcommitpatterns(self, wctx, match, status, fail):
        """check for commit arguments that aren't committable"""
        if match.isexact() or match.prefix():
            matched = set(status.modified + status.added + status.removed)

                        fctx = ctx[f]
                        if fctx is None:
                            removed.append(f)
                        else:
                            added.append(f)
                            m[f] = self._filecommit(
                                fctx,
                                m1,
                                m2,
                                linkrev,
                                trp,
                                changed,
                                writefilecopymeta,
                            )
                            m.setflag(f, fctx.flags())
                    except OSError:
                        self.ui.warn(
                            _(b"trouble committing %s!\n") % uipathfn(f)
                        )

45192:509f5b6c0b7e

    def currentwlock(self):
        """Returns the wlock if it's held, or None if it's not."""
        return self._currentlock(self._wlockref)

    def _filecommit(
        self, fctx, manifest1, manifest2, linkrev, tr, includecopymeta,
    ):
        """
        commit an individual file as part of a larger transaction

        input:

            fctx:       a file context with the content we are trying to commit
            manifest1:  manifest of changeset first parent
            manifest2:  manifest of changeset second parent
            linkrev:    revision number of the changeset being created
            tr:         current transation
            individual: boolean, set to False to skip storing the copy data
                        (only used by the Google specific feature of using
                        changeset extra as copy source of truth).

        output: (filenode, touched)

            filenode: the filenode that should be used by this changeset
            touched:  one of: None, 'added' or 'modified'
        """

        fname = fctx.path()
        fparent1 = manifest1.get(fname, nullid)
        fparent2 = manifest2.get(fname, nullid)
        touched = None
        if fparent1 == fparent2 == nullid:
            touched = 'added'

        if isinstance(fctx, context.filectx):
            node = fctx.filenode()
            if node in [fparent1, fparent2]:
                self.ui.debug(b'reusing %s filelog entry\n' % fname)
                if (

                    and manifest1.flags(fname) != fctx.flags()
                ) or (
                    fparent2 != nullid
                    and manifest2.flags(fname) != fctx.flags()
                ):
                    touched = 'modified'
                return node, touched

        flog = self.file(fname)
        meta = {}
        cfname = fctx.copysource()
        fnode = None

        if cfname and cfname != fname:
            # Mark the new revision of this file as a copy of another
            # file.  This copy data will effectively act as a parent
            # of this new revision.  If this is a merge, the first
            # parent will be the nullid (meaning "look up the copy data")

                    fparent1, fparent2 = fparent2, nullid

        # is the file changed?
        text = fctx.data()
        if fparent2 != nullid or meta or flog.cmp(fparent1, text):
            if touched is None:  # do not overwrite added
                touched = 'modified'
            fnode = flog.add(text, meta, tr, linkrev, fparent1, fparent2)
        # are just the flags changed during merge?
        elif fname in manifest1 and manifest1.flags(fname) != fctx.flags():
            touched = 'modified'
            fnode = fparent1
        else:
            fnode = fparent1
        return fnode, touched

    def checkcommitpatterns(self, wctx, match, status, fail):
        """check for commit arguments that aren't committable"""
        if match.isexact() or match.prefix():
            matched = set(status.modified + status.added + status.removed)

                        fctx = ctx[f]
                        if fctx is None:
                            removed.append(f)
                        else:
                            added.append(f)
                            m[f], is_touched = self._filecommit(
                                fctx, m1, m2, linkrev, trp, writefilecopymeta,
                            )
                            if is_touched:
                                changed.append(f)
                            m.setflag(f, fctx.flags())
                    except OSError:
                        self.ui.warn(
                            _(b"trouble committing %s!\n") % uipathfn(f)
                        )