comparison mercurial/patch.py @ 14367:468d7d1744b4

patch: set desired mode when patching, not in updatedir()

This patch and the following aim at merging _updatedir() actions into
_applydiff().

14366:992a7e398ddd

        """Return target file lines, or its content as a single line
        for symlinks.
        """
        raise NotImplementedError

    def writelines(self, fname, lines):
        """Write lines to target file."""
        raise NotImplementedError

    def unlink(self, fname):
        """Unlink target file."""
        raise NotImplementedError

        directory.
        """
        raise NotImplementedError

    def exists(self, fname):
        raise NotImplementedError

class fsbackend(abstractbackend):
    def __init__(self, ui, basedir):
        super(fsbackend, self).__init__(ui)

        try:
            return list(fp)
        finally:
            fp.close()

    def writelines(self, fname, lines):
        # Ensure supplied data ends in fname, being a regular file or
        # a symlink. _updatedir will -too magically- take care
        # of setting it to the proper type afterwards.
        st_mode = None
        islink = os.path.islink(self._join(fname))
        if islink:
            fp = cStringIO.StringIO()
        else:
            try:
                st_mode = os.lstat(self._join(fname)).st_mode & 0777
            except OSError, e:
                if e.errno != errno.ENOENT:
                    raise
            fp = self.opener(fname, 'w')
        try:
            fp.writelines(lines)
            if islink:
                self.opener.symlink(fp.getvalue(), fname)
            if st_mode is not None:
                os.chmod(self._join(fname), st_mode)
        finally:
            fp.close()

    def unlink(self, fname):
        os.unlink(self._join(fname))

    def writerej(self, fname, failed, total, lines):

        util.copyfile(abssrc, absdst)

    def exists(self, fname):
        return os.path.lexists(self._join(fname))

# @@ -start,len +start,len @@ or @@ -start +start @@ if len is 1
unidesc = re.compile('@@ -(\d+)(,(\d+))? \+(\d+)(,(\d+))? @@')
contextdesc = re.compile('(---|\*\*\*) (\d+)(,(\d+))? (---|\*\*\*)')
eolmodes = ['strict', 'crlf', 'lf', 'auto']

class patchfile(object):
    def __init__(self, ui, fname, backend, missing=False, eolmode='strict'):
        self.fname = fname
        self.eolmode = eolmode
        self.eol = None
        self.backend = backend
        self.ui = ui
        self.lines = []
        self.exists = False
        self.missing = missing
        if not missing:
            try:
                self.lines = self.backend.readlines(fname)
                if self.lines:
                    # Normalize line endings

        self.rej = []
        self.fileprinted = False
        self.printfile(False)
        self.hunks = 0

    def writelines(self, fname, lines):
        if self.eolmode == 'auto':
            eol = self.eol
        elif self.eolmode == 'crlf':
            eol = '\r\n'
        else:

                if l and l[-1] == '\n':
                    l = l[:-1] + eol
                rawlines.append(l)
            lines = rawlines

        self.backend.writelines(fname, lines)

    def printfile(self, warn):
        if self.fileprinted:
            return
        if warn or self.ui.verbose:

        self.rej.append(horig)
        return -1

    def close(self):
        if self.dirty:
            self.writelines(self.fname, self.lines)
        self.write_rej()
        return len(self.rej)

class hunk(object):
    def __init__(self, desc, num, lr, context, create=False, remove=False):

            remove = bfile == '/dev/null' or gpatch and gpatch.op == 'DELETE'
            h = hunk(x, hunknum + 1, lr, context, create, remove)
            hunknum += 1
            if emitfile:
                emitfile = False
                yield 'file', (afile, bfile, h)
            yield 'hunk', h
        elif state == BFILE and x.startswith('GIT binary patch'):
            h = binhunk(changed[bfile])
            hunknum += 1
            if emitfile:
                emitfile = False
                yield 'file', ('a/' + afile, 'b/' + bfile, h)
            h.extract(lr)
            yield 'hunk', h
        elif x.startswith('diff --git'):
            # check for git diff, scanning the whole patch file if needed
            m = gitre.match(x)

                if ret > 0:
                    err = 1
        elif state == 'file':
            if current_file:
                rejects += current_file.close()
            afile, bfile, first_hunk = values
            try:
                current_file, missing = selectfile(backend, afile, bfile,
                                                   first_hunk, strip)
                current_file = patcher(ui, current_file, backend,
                                       missing=missing, eolmode=eolmode)
            except PatchError, inst:
                ui.warn(str(inst) + '\n')
                current_file = None
                rejects += 1

        else:
            raise util.Abort(_('unsupported parser state: %s') % state)

    if current_file:
        rejects += current_file.close()

    if rejects:
        return -1
    return err

    for src, dst in copies:
        scmutil.dirstatecopy(ui, repo, wctx, src, dst, cwd=cwd)
    if (not similarity) and removes:
        wctx.remove(sorted(removes), True)

    for f in patches:
        gp = patches[f]
        if gp and gp.mode:
            islink, isexec = gp.mode
            dst = repo.wjoin(gp.path)
            # patch won't create empty files
            if gp.op == 'ADD' and not os.path.lexists(dst):
                flags = (isexec and 'x' or '') + (islink and 'l' or '')
                repo.wwrite(gp.path, '', flags)
            util.setflags(dst, islink, isexec)
    scmutil.addremove(repo, cfiles, similarity=similarity)
    files = patches.keys()
    files.extend([r for r in removes if r not in files])
    return sorted(files)

        changed = set()
        for state, values in iterhunks(fp):
            if state == 'hunk':
                continue
            elif state == 'file':
                afile, bfile, first_hunk = values
                current_file, missing = selectfile(backend, afile, bfile,
                                                   first_hunk, strip)
                changed.add(current_file)
            elif state == 'git':
                for gp in values:

14367:468d7d1744b4

        """Return target file lines, or its content as a single line
        for symlinks.
        """
        raise NotImplementedError

    def writelines(self, fname, lines, mode):
        """Write lines to target file. mode is a (islink, isexec)
        tuple, or None if there is no mode information.
        """
        raise NotImplementedError

    def unlink(self, fname):
        """Unlink target file."""
        raise NotImplementedError

        directory.
        """
        raise NotImplementedError

    def exists(self, fname):
        raise NotImplementedError

    def setmode(self, fname, islink, isexec):
        """Change target file mode."""
        raise NotImplementedError

class fsbackend(abstractbackend):
    def __init__(self, ui, basedir):
        super(fsbackend, self).__init__(ui)

        try:
            return list(fp)
        finally:
            fp.close()

    def writelines(self, fname, lines, mode):
        if not mode:
            # Preserve mode information
            isexec, islink = False, False
            try:
                isexec = os.lstat(self._join(fname)).st_mode & 0100 != 0
                islink = os.path.islink(self._join(fname))
            except OSError, e:
                if e.errno != errno.ENOENT:
                    raise
        else:
            islink, isexec = mode
        if islink:
            self.opener.symlink(''.join(lines), fname)
        else:
            self.opener(fname, 'w').writelines(lines)
            if isexec:
                util.setflags(self._join(fname), False, True)

    def unlink(self, fname):
        os.unlink(self._join(fname))

    def writerej(self, fname, failed, total, lines):

        util.copyfile(abssrc, absdst)

    def exists(self, fname):
        return os.path.lexists(self._join(fname))

    def setmode(self, fname, islink, isexec):
        util.setflags(self._join(fname), islink, isexec)

# @@ -start,len +start,len @@ or @@ -start +start @@ if len is 1
unidesc = re.compile('@@ -(\d+)(,(\d+))? \+(\d+)(,(\d+))? @@')
contextdesc = re.compile('(---|\*\*\*) (\d+)(,(\d+))? (---|\*\*\*)')
eolmodes = ['strict', 'crlf', 'lf', 'auto']

class patchfile(object):
    def __init__(self, ui, fname, backend, mode, missing=False,
                 eolmode='strict'):
        self.fname = fname
        self.eolmode = eolmode
        self.eol = None
        self.backend = backend
        self.ui = ui
        self.lines = []
        self.exists = False
        self.missing = missing
        self.mode = mode
        if not missing:
            try:
                self.lines = self.backend.readlines(fname)
                if self.lines:
                    # Normalize line endings

        self.rej = []
        self.fileprinted = False
        self.printfile(False)
        self.hunks = 0

    def writelines(self, fname, lines, mode):
        if self.eolmode == 'auto':
            eol = self.eol
        elif self.eolmode == 'crlf':
            eol = '\r\n'
        else:

                if l and l[-1] == '\n':
                    l = l[:-1] + eol
                rawlines.append(l)
            lines = rawlines

        self.backend.writelines(fname, lines, mode)

    def printfile(self, warn):
        if self.fileprinted:
            return
        if warn or self.ui.verbose:

        self.rej.append(horig)
        return -1

    def close(self):
        if self.dirty:
            self.writelines(self.fname, self.lines, self.mode)
        self.write_rej()
        return len(self.rej)

class hunk(object):
    def __init__(self, desc, num, lr, context, create=False, remove=False):

            remove = bfile == '/dev/null' or gpatch and gpatch.op == 'DELETE'
            h = hunk(x, hunknum + 1, lr, context, create, remove)
            hunknum += 1
            if emitfile:
                emitfile = False
                yield 'file', (afile, bfile, h, gpatch and gpatch.mode or None)
            yield 'hunk', h
        elif state == BFILE and x.startswith('GIT binary patch'):
            gpatch = changed[bfile]
            h = binhunk(gpatch)
            hunknum += 1
            if emitfile:
                emitfile = False
                yield 'file', ('a/' + afile, 'b/' + bfile, h,
                               gpatch and gpatch.mode or None)
            h.extract(lr)
            yield 'hunk', h
        elif x.startswith('diff --git'):
            # check for git diff, scanning the whole patch file if needed
            m = gitre.match(x)

                if ret > 0:
                    err = 1
        elif state == 'file':
            if current_file:
                rejects += current_file.close()
            afile, bfile, first_hunk, mode = values
            try:
                current_file, missing = selectfile(backend, afile, bfile,
                                                   first_hunk, strip)
                current_file = patcher(ui, current_file, backend, mode,
                                       missing=missing, eolmode=eolmode)
            except PatchError, inst:
                ui.warn(str(inst) + '\n')
                current_file = None
                rejects += 1

        else:
            raise util.Abort(_('unsupported parser state: %s') % state)

    if current_file:
        rejects += current_file.close()

    # Handle mode changes without hunk
    for gp in changed.itervalues():
        if not gp or not gp.mode:
            continue
        if gp.op == 'ADD' and not backend.exists(gp.path):
            # Added files without content have no hunk and must be created
            backend.writelines(gp.path, [], gp.mode)
        else:
            backend.setmode(gp.path, gp.mode[0], gp.mode[1])

    if rejects:
        return -1
    return err

    for src, dst in copies:
        scmutil.dirstatecopy(ui, repo, wctx, src, dst, cwd=cwd)
    if (not similarity) and removes:
        wctx.remove(sorted(removes), True)

    scmutil.addremove(repo, cfiles, similarity=similarity)
    files = patches.keys()
    files.extend([r for r in removes if r not in files])
    return sorted(files)

        changed = set()
        for state, values in iterhunks(fp):
            if state == 'hunk':
                continue
            elif state == 'file':
                afile, bfile, first_hunk, mode = values
                current_file, missing = selectfile(backend, afile, bfile,
                                                   first_hunk, strip)
                changed.add(current_file)
            elif state == 'git':
                for gp in values: