mercurial-scm/hg-stable: mercurial/scmutil.py annotate

annotate mercurial/scmutil.py @ 30255:e0ff47999b13 stable

scmutil: ignore EPERM at os.utime, which avoids ambiguity at closing According to POSIX specification, just having group write access to a file causes EPERM at invocation of os.utime() with an explicit time information (e.g. working on the repository shared by group access permission). To ignore EPERM at closing file object in such case, this patch makes checkambigatclosing._checkambig() use filestat.avoidambig() introduced by previous patch. Some functions below imply this code path at truncation of an existing (= might be owned by another user) file. - strip() in repair.py, introduced by e38d85be978f - _playback() in transaction.py, introduced by 599912a62ff6 This is a variant of issue5418.

author	FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
date	Sun, 13 Nov 2016 06:12:22 +0900
parents	bff5ccbe5ead
children	854190becacb

rev	line source
13962 8b252e826c68 add: introduce a warning message for non-portable filenames (issue2756) (BC) Adrian Buehlmann <adrian@cadifra.com> parents: diff changeset	1 # scmutil.py - Mercurial core utility functions
8b252e826c68 add: introduce a warning message for non-portable filenames (issue2756) (BC) Adrian Buehlmann <adrian@cadifra.com> parents: diff changeset	2 #
8b252e826c68 add: introduce a warning message for non-portable filenames (issue2756) (BC) Adrian Buehlmann <adrian@cadifra.com> parents: diff changeset	3 # Copyright Matt Mackall <mpm@selenic.com>
8b252e826c68 add: introduce a warning message for non-portable filenames (issue2756) (BC) Adrian Buehlmann <adrian@cadifra.com> parents: diff changeset	4 #
8b252e826c68 add: introduce a warning message for non-portable filenames (issue2756) (BC) Adrian Buehlmann <adrian@cadifra.com> parents: diff changeset	5 # This software may be used and distributed according to the terms of the
8b252e826c68 add: introduce a warning message for non-portable filenames (issue2756) (BC) Adrian Buehlmann <adrian@cadifra.com> parents: diff changeset	6 # GNU General Public License version 2 or any later version.
8b252e826c68 add: introduce a warning message for non-portable filenames (issue2756) (BC) Adrian Buehlmann <adrian@cadifra.com> parents: diff changeset	7
27482 dde3da2246f1 scmutil: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27093 diff changeset	8 from __future__ import absolute_import
dde3da2246f1 scmutil: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27093 diff changeset	9
27895 2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	10 import contextlib
27482 dde3da2246f1 scmutil: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27093 diff changeset	11 import errno
dde3da2246f1 scmutil: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27093 diff changeset	12 import glob
29341 0d83ad967bf8 cleanup: replace uses of util.(md5\|sha1\|sha256\|sha512) with hashlib.\1 Augie Fackler <raf@durin42.com> parents: 29336 diff changeset	13 import hashlib
27482 dde3da2246f1 scmutil: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27093 diff changeset	14 import os
dde3da2246f1 scmutil: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27093 diff changeset	15 import re
dde3da2246f1 scmutil: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27093 diff changeset	16 import shutil
dde3da2246f1 scmutil: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27093 diff changeset	17 import stat
dde3da2246f1 scmutil: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27093 diff changeset	18 import tempfile
27895 2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	19 import threading
27482 dde3da2246f1 scmutil: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27093 diff changeset	20
dde3da2246f1 scmutil: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27093 diff changeset	21 from .i18n import _
dde3da2246f1 scmutil: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27093 diff changeset	22 from .node import wdirrev
dde3da2246f1 scmutil: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27093 diff changeset	23 from . import (
dde3da2246f1 scmutil: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27093 diff changeset	24 encoding,
dde3da2246f1 scmutil: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27093 diff changeset	25 error,
dde3da2246f1 scmutil: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27093 diff changeset	26 match as matchmod,
dde3da2246f1 scmutil: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27093 diff changeset	27 osutil,
dde3da2246f1 scmutil: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27093 diff changeset	28 pathutil,
dde3da2246f1 scmutil: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27093 diff changeset	29 phases,
dde3da2246f1 scmutil: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27093 diff changeset	30 revset,
dde3da2246f1 scmutil: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27093 diff changeset	31 similar,
dde3da2246f1 scmutil: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27093 diff changeset	32 util,
dde3da2246f1 scmutil: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27093 diff changeset	33 )
18690 4c6f7f0dadab scmutil: split platform-specific bits into their own modules Kevin Bullock <kbullock@ringworld.org> parents: 18678 diff changeset	34
4c6f7f0dadab scmutil: split platform-specific bits into their own modules Kevin Bullock <kbullock@ringworld.org> parents: 18678 diff changeset	35 if os.name == 'nt':
27482 dde3da2246f1 scmutil: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27093 diff changeset	36 from . import scmwindows as scmplatform
18690 4c6f7f0dadab scmutil: split platform-specific bits into their own modules Kevin Bullock <kbullock@ringworld.org> parents: 18678 diff changeset	37 else:
27482 dde3da2246f1 scmutil: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27093 diff changeset	38 from . import scmposix as scmplatform
18690 4c6f7f0dadab scmutil: split platform-specific bits into their own modules Kevin Bullock <kbullock@ringworld.org> parents: 18678 diff changeset	39
4c6f7f0dadab scmutil: split platform-specific bits into their own modules Kevin Bullock <kbullock@ringworld.org> parents: 18678 diff changeset	40 systemrcpath = scmplatform.systemrcpath
4c6f7f0dadab scmutil: split platform-specific bits into their own modules Kevin Bullock <kbullock@ringworld.org> parents: 18678 diff changeset	41 userrcpath = scmplatform.userrcpath
13962 8b252e826c68 add: introduce a warning message for non-portable filenames (issue2756) (BC) Adrian Buehlmann <adrian@cadifra.com> parents: diff changeset	42
22913 cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	43 class status(tuple):
cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	44 '''Named tuple with a list of files per status. The 'deleted', 'unknown'
cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	45 and 'ignored' properties are only relevant to the working copy.
cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	46 '''
cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	47
cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	48 __slots__ = ()
cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	49
cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	50 def __new__(cls, modified, added, removed, deleted, unknown, ignored,
cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	51 clean):
cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	52 return tuple.__new__(cls, (modified, added, removed, deleted, unknown,
cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	53 ignored, clean))
cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	54
cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	55 @property
cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	56 def modified(self):
22915 4d680deb0d9e status: update and move documentation of status types to status class Martin von Zweigbergk <martinvonz@gmail.com> parents: 22913 diff changeset	57 '''files that have been modified'''
22913 cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	58 return self[0]
cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	59
cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	60 @property
cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	61 def added(self):
22915 4d680deb0d9e status: update and move documentation of status types to status class Martin von Zweigbergk <martinvonz@gmail.com> parents: 22913 diff changeset	62 '''files that have been added'''
22913 cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	63 return self[1]
cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	64
cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	65 @property
cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	66 def removed(self):
22915 4d680deb0d9e status: update and move documentation of status types to status class Martin von Zweigbergk <martinvonz@gmail.com> parents: 22913 diff changeset	67 '''files that have been removed'''
22913 cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	68 return self[2]
cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	69
cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	70 @property
cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	71 def deleted(self):
22915 4d680deb0d9e status: update and move documentation of status types to status class Martin von Zweigbergk <martinvonz@gmail.com> parents: 22913 diff changeset	72 '''files that are in the dirstate, but have been deleted from the
4d680deb0d9e status: update and move documentation of status types to status class Martin von Zweigbergk <martinvonz@gmail.com> parents: 22913 diff changeset	73 working copy (aka "missing")
4d680deb0d9e status: update and move documentation of status types to status class Martin von Zweigbergk <martinvonz@gmail.com> parents: 22913 diff changeset	74 '''
22913 cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	75 return self[3]
cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	76
cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	77 @property
cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	78 def unknown(self):
22915 4d680deb0d9e status: update and move documentation of status types to status class Martin von Zweigbergk <martinvonz@gmail.com> parents: 22913 diff changeset	79 '''files not in the dirstate that are not ignored'''
22913 cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	80 return self[4]
cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	81
cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	82 @property
cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	83 def ignored(self):
22915 4d680deb0d9e status: update and move documentation of status types to status class Martin von Zweigbergk <martinvonz@gmail.com> parents: 22913 diff changeset	84 '''files not in the dirstate that are ignored (by _dirignore())'''
22913 cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	85 return self[5]
cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	86
cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	87 @property
cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	88 def clean(self):
22915 4d680deb0d9e status: update and move documentation of status types to status class Martin von Zweigbergk <martinvonz@gmail.com> parents: 22913 diff changeset	89 '''files that have not been modified'''
22913 cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	90 return self[6]
cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	91
cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	92 def __repr__(self, args, *kwargs):
cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	93 return (('<status modified=%r, added=%r, removed=%r, deleted=%r, '
cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	94 'unknown=%r, ignored=%r, clean=%r>') % self)
cb4449921a1d status: create class for status lists Martin von Zweigbergk <martinvonz@gmail.com> parents: 22816 diff changeset	95
20392 d4f804caa0ed itersubrepos: move to scmutil to break a direct import cycle Augie Fackler <raf@durin42.com> parents: 20364 diff changeset	96 def itersubrepos(ctx1, ctx2):
d4f804caa0ed itersubrepos: move to scmutil to break a direct import cycle Augie Fackler <raf@durin42.com> parents: 20364 diff changeset	97 """find subrepos in ctx1 or ctx2"""
d4f804caa0ed itersubrepos: move to scmutil to break a direct import cycle Augie Fackler <raf@durin42.com> parents: 20364 diff changeset	98 # Create a (subpath, ctx) mapping where we prefer subpaths from
d4f804caa0ed itersubrepos: move to scmutil to break a direct import cycle Augie Fackler <raf@durin42.com> parents: 20364 diff changeset	99 # ctx1. The subpaths from ctx2 are important when the .hgsub file
d4f804caa0ed itersubrepos: move to scmutil to break a direct import cycle Augie Fackler <raf@durin42.com> parents: 20364 diff changeset	100 # has been modified (in ctx2) but not yet committed (in ctx1).
d4f804caa0ed itersubrepos: move to scmutil to break a direct import cycle Augie Fackler <raf@durin42.com> parents: 20364 diff changeset	101 subpaths = dict.fromkeys(ctx2.substate, ctx2)
d4f804caa0ed itersubrepos: move to scmutil to break a direct import cycle Augie Fackler <raf@durin42.com> parents: 20364 diff changeset	102 subpaths.update(dict.fromkeys(ctx1.substate, ctx1))
25418 c0995cd8ff6f scmutil: consistently return subrepos relative to ctx1 from itersubrepos() Matt Harbison <matt_harbison@yahoo.com> parents: 25386 diff changeset	103
c0995cd8ff6f scmutil: consistently return subrepos relative to ctx1 from itersubrepos() Matt Harbison <matt_harbison@yahoo.com> parents: 25386 diff changeset	104 missing = set()
c0995cd8ff6f scmutil: consistently return subrepos relative to ctx1 from itersubrepos() Matt Harbison <matt_harbison@yahoo.com> parents: 25386 diff changeset	105
c0995cd8ff6f scmutil: consistently return subrepos relative to ctx1 from itersubrepos() Matt Harbison <matt_harbison@yahoo.com> parents: 25386 diff changeset	106 for subpath in ctx2.substate:
c0995cd8ff6f scmutil: consistently return subrepos relative to ctx1 from itersubrepos() Matt Harbison <matt_harbison@yahoo.com> parents: 25386 diff changeset	107 if subpath not in ctx1.substate:
c0995cd8ff6f scmutil: consistently return subrepos relative to ctx1 from itersubrepos() Matt Harbison <matt_harbison@yahoo.com> parents: 25386 diff changeset	108 del subpaths[subpath]
c0995cd8ff6f scmutil: consistently return subrepos relative to ctx1 from itersubrepos() Matt Harbison <matt_harbison@yahoo.com> parents: 25386 diff changeset	109 missing.add(subpath)
c0995cd8ff6f scmutil: consistently return subrepos relative to ctx1 from itersubrepos() Matt Harbison <matt_harbison@yahoo.com> parents: 25386 diff changeset	110
20392 d4f804caa0ed itersubrepos: move to scmutil to break a direct import cycle Augie Fackler <raf@durin42.com> parents: 20364 diff changeset	111 for subpath, ctx in sorted(subpaths.iteritems()):
d4f804caa0ed itersubrepos: move to scmutil to break a direct import cycle Augie Fackler <raf@durin42.com> parents: 20364 diff changeset	112 yield subpath, ctx.sub(subpath)
d4f804caa0ed itersubrepos: move to scmutil to break a direct import cycle Augie Fackler <raf@durin42.com> parents: 20364 diff changeset	113
25418 c0995cd8ff6f scmutil: consistently return subrepos relative to ctx1 from itersubrepos() Matt Harbison <matt_harbison@yahoo.com> parents: 25386 diff changeset	114 # Yield an empty subrepo based on ctx1 for anything only in ctx2. That way,
c0995cd8ff6f scmutil: consistently return subrepos relative to ctx1 from itersubrepos() Matt Harbison <matt_harbison@yahoo.com> parents: 25386 diff changeset	115 # status and diff will have an accurate result when it does
c0995cd8ff6f scmutil: consistently return subrepos relative to ctx1 from itersubrepos() Matt Harbison <matt_harbison@yahoo.com> parents: 25386 diff changeset	116 # 'sub.{status\|diff}(rev2)'. Otherwise, the ctx2 subrepo is compared
c0995cd8ff6f scmutil: consistently return subrepos relative to ctx1 from itersubrepos() Matt Harbison <matt_harbison@yahoo.com> parents: 25386 diff changeset	117 # against itself.
c0995cd8ff6f scmutil: consistently return subrepos relative to ctx1 from itersubrepos() Matt Harbison <matt_harbison@yahoo.com> parents: 25386 diff changeset	118 for subpath in missing:
c0995cd8ff6f scmutil: consistently return subrepos relative to ctx1 from itersubrepos() Matt Harbison <matt_harbison@yahoo.com> parents: 25386 diff changeset	119 yield subpath, ctx2.nullsub(subpath, ctx1)
c0995cd8ff6f scmutil: consistently return subrepos relative to ctx1 from itersubrepos() Matt Harbison <matt_harbison@yahoo.com> parents: 25386 diff changeset	120
17248 6ffb35b2284c discovery: add extinct changesets to outgoing.excluded Patrick Mezard <patrick@mezard.eu> parents: 17201 diff changeset	121 def nochangesfound(ui, repo, excluded=None):
6ffb35b2284c discovery: add extinct changesets to outgoing.excluded Patrick Mezard <patrick@mezard.eu> parents: 17201 diff changeset	122 '''Report no changes for push/pull, excluded is None or a list of
6ffb35b2284c discovery: add extinct changesets to outgoing.excluded Patrick Mezard <patrick@mezard.eu> parents: 17201 diff changeset	123 nodes excluded from the push/pull.
6ffb35b2284c discovery: add extinct changesets to outgoing.excluded Patrick Mezard <patrick@mezard.eu> parents: 17201 diff changeset	124 '''
6ffb35b2284c discovery: add extinct changesets to outgoing.excluded Patrick Mezard <patrick@mezard.eu> parents: 17201 diff changeset	125 secretlist = []
6ffb35b2284c discovery: add extinct changesets to outgoing.excluded Patrick Mezard <patrick@mezard.eu> parents: 17201 diff changeset	126 if excluded:
6ffb35b2284c discovery: add extinct changesets to outgoing.excluded Patrick Mezard <patrick@mezard.eu> parents: 17201 diff changeset	127 for n in excluded:
18617 227479f61db9 outgoing: fix possible filtering crash in outgoing (issue3814) Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18466 diff changeset	128 if n not in repo:
227479f61db9 outgoing: fix possible filtering crash in outgoing (issue3814) Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18466 diff changeset	129 # discovery should not have included the filtered revision,
227479f61db9 outgoing: fix possible filtering crash in outgoing (issue3814) Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18466 diff changeset	130 # we have to explicitly exclude it until discovery is cleanup.
227479f61db9 outgoing: fix possible filtering crash in outgoing (issue3814) Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18466 diff changeset	131 continue
17248 6ffb35b2284c discovery: add extinct changesets to outgoing.excluded Patrick Mezard <patrick@mezard.eu> parents: 17201 diff changeset	132 ctx = repo[n]
6ffb35b2284c discovery: add extinct changesets to outgoing.excluded Patrick Mezard <patrick@mezard.eu> parents: 17201 diff changeset	133 if ctx.phase() >= phases.secret and not ctx.extinct():
6ffb35b2284c discovery: add extinct changesets to outgoing.excluded Patrick Mezard <patrick@mezard.eu> parents: 17201 diff changeset	134 secretlist.append(n)
6ffb35b2284c discovery: add extinct changesets to outgoing.excluded Patrick Mezard <patrick@mezard.eu> parents: 17201 diff changeset	135
15993 0b05e0bfdc1c scmutil: unify some 'no changes found' messages Matt Mackall <mpm@selenic.com> parents: 15797 diff changeset	136 if secretlist:
0b05e0bfdc1c scmutil: unify some 'no changes found' messages Matt Mackall <mpm@selenic.com> parents: 15797 diff changeset	137 ui.status(_("no changes found (ignored %d secret changesets)\n")
0b05e0bfdc1c scmutil: unify some 'no changes found' messages Matt Mackall <mpm@selenic.com> parents: 15797 diff changeset	138 % len(secretlist))
0b05e0bfdc1c scmutil: unify some 'no changes found' messages Matt Mackall <mpm@selenic.com> parents: 15797 diff changeset	139 else:
0b05e0bfdc1c scmutil: unify some 'no changes found' messages Matt Mackall <mpm@selenic.com> parents: 15797 diff changeset	140 ui.status(_("no changes found\n"))
0b05e0bfdc1c scmutil: unify some 'no changes found' messages Matt Mackall <mpm@selenic.com> parents: 15797 diff changeset	141
17821 361ab1e2086f scmutil: add bad character checking to checknewlabel Kevin Bullock <kbullock@ringworld.org> parents: 17817 diff changeset	142 def checknewlabel(repo, lbl, kind):
19070 290a61833b99 translations: change label integer error to not specify the kind of label Durham Goode <durham@fb.com> parents: 18951 diff changeset	143 # Do not use the "kind" parameter in ui output.
290a61833b99 translations: change label integer error to not specify the kind of label Durham Goode <durham@fb.com> parents: 18951 diff changeset	144 # It makes strings difficult to translate.
17817 b17be267b59c scmutil: add function to validate new branch, tag, and bookmark names Kevin Bullock <kbullock@ringworld.org> parents: 17768 diff changeset	145 if lbl in ['tip', '.', 'null']:
26587 56b2bcea2529 error: get Abort from 'error' instead of 'util' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26491 diff changeset	146 raise error.Abort(_("the name '%s' is reserved") % lbl)
17821 361ab1e2086f scmutil: add bad character checking to checknewlabel Kevin Bullock <kbullock@ringworld.org> parents: 17817 diff changeset	147 for c in (':', '\0', '\n', '\r'):
361ab1e2086f scmutil: add bad character checking to checknewlabel Kevin Bullock <kbullock@ringworld.org> parents: 17817 diff changeset	148 if c in lbl:
26587 56b2bcea2529 error: get Abort from 'error' instead of 'util' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26491 diff changeset	149 raise error.Abort(_("%r cannot be used in a name") % c)
18566 341868ef0cf6 bookmark: don't allow integers as bookmark/branch/tag names Durham Goode <durham@fb.com> parents: 18560 diff changeset	150 try:
341868ef0cf6 bookmark: don't allow integers as bookmark/branch/tag names Durham Goode <durham@fb.com> parents: 18560 diff changeset	151 int(lbl)
26587 56b2bcea2529 error: get Abort from 'error' instead of 'util' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26491 diff changeset	152 raise error.Abort(_("cannot use an integer as a name"))
18566 341868ef0cf6 bookmark: don't allow integers as bookmark/branch/tag names Durham Goode <durham@fb.com> parents: 18560 diff changeset	153 except ValueError:
341868ef0cf6 bookmark: don't allow integers as bookmark/branch/tag names Durham Goode <durham@fb.com> parents: 18560 diff changeset	154 pass
17817 b17be267b59c scmutil: add function to validate new branch, tag, and bookmark names Kevin Bullock <kbullock@ringworld.org> parents: 17768 diff changeset	155
13974 23f2736abce3 move checkfilename from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13973 diff changeset	156 def checkfilename(f):
23f2736abce3 move checkfilename from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13973 diff changeset	157 '''Check that the filename f is an acceptable filename for a tracked file'''
23f2736abce3 move checkfilename from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13973 diff changeset	158 if '\r' in f or '\n' in f:
26587 56b2bcea2529 error: get Abort from 'error' instead of 'util' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26491 diff changeset	159 raise error.Abort(_("'\\n' and '\\r' disallowed in filenames: %r") % f)
13974 23f2736abce3 move checkfilename from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13973 diff changeset	160
13962 8b252e826c68 add: introduce a warning message for non-portable filenames (issue2756) (BC) Adrian Buehlmann <adrian@cadifra.com> parents: diff changeset	161 def checkportable(ui, f):
8b252e826c68 add: introduce a warning message for non-portable filenames (issue2756) (BC) Adrian Buehlmann <adrian@cadifra.com> parents: diff changeset	162 '''Check if filename f is portable and warn or abort depending on config'''
13974 23f2736abce3 move checkfilename from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13973 diff changeset	163 checkfilename(f)
14138 c18204fd35b0 scmutil: introduce casecollisionauditor Adrian Buehlmann <adrian@cadifra.com> parents: 14097 diff changeset	164 abort, warn = checkportabilityalert(ui)
c18204fd35b0 scmutil: introduce casecollisionauditor Adrian Buehlmann <adrian@cadifra.com> parents: 14097 diff changeset	165 if abort or warn:
13962 8b252e826c68 add: introduce a warning message for non-portable filenames (issue2756) (BC) Adrian Buehlmann <adrian@cadifra.com> parents: diff changeset	166 msg = util.checkwinfilename(f)
8b252e826c68 add: introduce a warning message for non-portable filenames (issue2756) (BC) Adrian Buehlmann <adrian@cadifra.com> parents: diff changeset	167 if msg:
14138 c18204fd35b0 scmutil: introduce casecollisionauditor Adrian Buehlmann <adrian@cadifra.com> parents: 14097 diff changeset	168 msg = "%s: %r" % (msg, f)
c18204fd35b0 scmutil: introduce casecollisionauditor Adrian Buehlmann <adrian@cadifra.com> parents: 14097 diff changeset	169 if abort:
26587 56b2bcea2529 error: get Abort from 'error' instead of 'util' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26491 diff changeset	170 raise error.Abort(msg)
14138 c18204fd35b0 scmutil: introduce casecollisionauditor Adrian Buehlmann <adrian@cadifra.com> parents: 14097 diff changeset	171 ui.warn(_("warning: %s\n") % msg)
14068 04ce8fa1015d add: notify when adding a file that would cause a case-folding collision Kevin Gessner <kevin@kevingessner.com> parents: 14067 diff changeset	172
14067 e88a4958a6b7 scmutil: refactor ui.portablefilenames processing Kevin Gessner <kevin@kevingessner.com> parents: 13986 diff changeset	173 def checkportabilityalert(ui):
e88a4958a6b7 scmutil: refactor ui.portablefilenames processing Kevin Gessner <kevin@kevingessner.com> parents: 13986 diff changeset	174 '''check if the user's config requests nothing, a warning, or abort for
e88a4958a6b7 scmutil: refactor ui.portablefilenames processing Kevin Gessner <kevin@kevingessner.com> parents: 13986 diff changeset	175 non-portable filenames'''
e88a4958a6b7 scmutil: refactor ui.portablefilenames processing Kevin Gessner <kevin@kevingessner.com> parents: 13986 diff changeset	176 val = ui.config('ui', 'portablefilenames', 'warn')
e88a4958a6b7 scmutil: refactor ui.portablefilenames processing Kevin Gessner <kevin@kevingessner.com> parents: 13986 diff changeset	177 lval = val.lower()
e88a4958a6b7 scmutil: refactor ui.portablefilenames processing Kevin Gessner <kevin@kevingessner.com> parents: 13986 diff changeset	178 bval = util.parsebool(val)
e88a4958a6b7 scmutil: refactor ui.portablefilenames processing Kevin Gessner <kevin@kevingessner.com> parents: 13986 diff changeset	179 abort = os.name == 'nt' or lval == 'abort'
e88a4958a6b7 scmutil: refactor ui.portablefilenames processing Kevin Gessner <kevin@kevingessner.com> parents: 13986 diff changeset	180 warn = bval or lval == 'warn'
e88a4958a6b7 scmutil: refactor ui.portablefilenames processing Kevin Gessner <kevin@kevingessner.com> parents: 13986 diff changeset	181 if bval is None and not (warn or abort or lval == 'ignore'):
13962 8b252e826c68 add: introduce a warning message for non-portable filenames (issue2756) (BC) Adrian Buehlmann <adrian@cadifra.com> parents: diff changeset	182 raise error.ConfigError(
8b252e826c68 add: introduce a warning message for non-portable filenames (issue2756) (BC) Adrian Buehlmann <adrian@cadifra.com> parents: diff changeset	183 _("ui.portablefilenames value is invalid ('%s')") % val)
14067 e88a4958a6b7 scmutil: refactor ui.portablefilenames processing Kevin Gessner <kevin@kevingessner.com> parents: 13986 diff changeset	184 return abort, warn
e88a4958a6b7 scmutil: refactor ui.portablefilenames processing Kevin Gessner <kevin@kevingessner.com> parents: 13986 diff changeset	185
14138 c18204fd35b0 scmutil: introduce casecollisionauditor Adrian Buehlmann <adrian@cadifra.com> parents: 14097 diff changeset	186 class casecollisionauditor(object):
17201 afd75476939e scmutil: 25% speedup in casecollisionauditor Joshua Redstone <joshua.redstone@fb.com> parents: 17161 diff changeset	187 def __init__(self, ui, abort, dirstate):
14138 c18204fd35b0 scmutil: introduce casecollisionauditor Adrian Buehlmann <adrian@cadifra.com> parents: 14097 diff changeset	188 self._ui = ui
c18204fd35b0 scmutil: introduce casecollisionauditor Adrian Buehlmann <adrian@cadifra.com> parents: 14097 diff changeset	189 self._abort = abort
17201 afd75476939e scmutil: 25% speedup in casecollisionauditor Joshua Redstone <joshua.redstone@fb.com> parents: 17161 diff changeset	190 allfiles = '\0'.join(dirstate._map)
afd75476939e scmutil: 25% speedup in casecollisionauditor Joshua Redstone <joshua.redstone@fb.com> parents: 17161 diff changeset	191 self._loweredfiles = set(encoding.lower(allfiles).split('\0'))
afd75476939e scmutil: 25% speedup in casecollisionauditor Joshua Redstone <joshua.redstone@fb.com> parents: 17161 diff changeset	192 self._dirstate = dirstate
afd75476939e scmutil: 25% speedup in casecollisionauditor Joshua Redstone <joshua.redstone@fb.com> parents: 17161 diff changeset	193 # The purpose of _newfiles is so that we don't complain about
afd75476939e scmutil: 25% speedup in casecollisionauditor Joshua Redstone <joshua.redstone@fb.com> parents: 17161 diff changeset	194 # case collisions if someone were to call this object with the
afd75476939e scmutil: 25% speedup in casecollisionauditor Joshua Redstone <joshua.redstone@fb.com> parents: 17161 diff changeset	195 # same filename twice.
afd75476939e scmutil: 25% speedup in casecollisionauditor Joshua Redstone <joshua.redstone@fb.com> parents: 17161 diff changeset	196 self._newfiles = set()
14067 e88a4958a6b7 scmutil: refactor ui.portablefilenames processing Kevin Gessner <kevin@kevingessner.com> parents: 13986 diff changeset	197
14138 c18204fd35b0 scmutil: introduce casecollisionauditor Adrian Buehlmann <adrian@cadifra.com> parents: 14097 diff changeset	198 def __call__(self, f):
20006 9276014db865 scmutil: skip checks in "casecollisionauditor" if filename is already checked FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 19900 diff changeset	199 if f in self._newfiles:
9276014db865 scmutil: skip checks in "casecollisionauditor" if filename is already checked FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 19900 diff changeset	200 return
14980 28e98a8b173d i18n: use UTF-8 string to lower filename for case collision check FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 14861 diff changeset	201 fl = encoding.lower(f)
20006 9276014db865 scmutil: skip checks in "casecollisionauditor" if filename is already checked FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 19900 diff changeset	202 if fl in self._loweredfiles and f not in self._dirstate:
14138 c18204fd35b0 scmutil: introduce casecollisionauditor Adrian Buehlmann <adrian@cadifra.com> parents: 14097 diff changeset	203 msg = _('possible case-folding collision for %s') % f
c18204fd35b0 scmutil: introduce casecollisionauditor Adrian Buehlmann <adrian@cadifra.com> parents: 14097 diff changeset	204 if self._abort:
26587 56b2bcea2529 error: get Abort from 'error' instead of 'util' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26491 diff changeset	205 raise error.Abort(msg)
14138 c18204fd35b0 scmutil: introduce casecollisionauditor Adrian Buehlmann <adrian@cadifra.com> parents: 14097 diff changeset	206 self._ui.warn(_("warning: %s\n") % msg)
17201 afd75476939e scmutil: 25% speedup in casecollisionauditor Joshua Redstone <joshua.redstone@fb.com> parents: 17161 diff changeset	207 self._loweredfiles.add(fl)
afd75476939e scmutil: 25% speedup in casecollisionauditor Joshua Redstone <joshua.redstone@fb.com> parents: 17161 diff changeset	208 self._newfiles.add(f)
13970 d13913355390 move opener from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13962 diff changeset	209
24723 467a33142425 repoview: move function for computing filtered hash Gregory Szorc <gregory.szorc@gmail.com> parents: 24693 diff changeset	210 def filteredhash(repo, maxrev):
467a33142425 repoview: move function for computing filtered hash Gregory Szorc <gregory.szorc@gmail.com> parents: 24693 diff changeset	211 """build hash of filtered revisions in the current repoview.
467a33142425 repoview: move function for computing filtered hash Gregory Szorc <gregory.szorc@gmail.com> parents: 24693 diff changeset	212
467a33142425 repoview: move function for computing filtered hash Gregory Szorc <gregory.szorc@gmail.com> parents: 24693 diff changeset	213 Multiple caches perform up-to-date validation by checking that the
467a33142425 repoview: move function for computing filtered hash Gregory Szorc <gregory.szorc@gmail.com> parents: 24693 diff changeset	214 tiprev and tipnode stored in the cache file match the current repository.
467a33142425 repoview: move function for computing filtered hash Gregory Szorc <gregory.szorc@gmail.com> parents: 24693 diff changeset	215 However, this is not sufficient for validating repoviews because the set
467a33142425 repoview: move function for computing filtered hash Gregory Szorc <gregory.szorc@gmail.com> parents: 24693 diff changeset	216 of revisions in the view may change without the repository tiprev and
467a33142425 repoview: move function for computing filtered hash Gregory Szorc <gregory.szorc@gmail.com> parents: 24693 diff changeset	217 tipnode changing.
467a33142425 repoview: move function for computing filtered hash Gregory Szorc <gregory.szorc@gmail.com> parents: 24693 diff changeset	218
467a33142425 repoview: move function for computing filtered hash Gregory Szorc <gregory.szorc@gmail.com> parents: 24693 diff changeset	219 This function hashes all the revs filtered from the view and returns
467a33142425 repoview: move function for computing filtered hash Gregory Szorc <gregory.szorc@gmail.com> parents: 24693 diff changeset	220 that SHA-1 digest.
467a33142425 repoview: move function for computing filtered hash Gregory Szorc <gregory.szorc@gmail.com> parents: 24693 diff changeset	221 """
467a33142425 repoview: move function for computing filtered hash Gregory Szorc <gregory.szorc@gmail.com> parents: 24693 diff changeset	222 cl = repo.changelog
467a33142425 repoview: move function for computing filtered hash Gregory Szorc <gregory.szorc@gmail.com> parents: 24693 diff changeset	223 if not cl.filteredrevs:
467a33142425 repoview: move function for computing filtered hash Gregory Szorc <gregory.szorc@gmail.com> parents: 24693 diff changeset	224 return None
467a33142425 repoview: move function for computing filtered hash Gregory Szorc <gregory.szorc@gmail.com> parents: 24693 diff changeset	225 key = None
467a33142425 repoview: move function for computing filtered hash Gregory Szorc <gregory.szorc@gmail.com> parents: 24693 diff changeset	226 revs = sorted(r for r in cl.filteredrevs if r <= maxrev)
467a33142425 repoview: move function for computing filtered hash Gregory Szorc <gregory.szorc@gmail.com> parents: 24693 diff changeset	227 if revs:
29341 0d83ad967bf8 cleanup: replace uses of util.(md5\|sha1\|sha256\|sha512) with hashlib.\1 Augie Fackler <raf@durin42.com> parents: 29336 diff changeset	228 s = hashlib.sha1()
24723 467a33142425 repoview: move function for computing filtered hash Gregory Szorc <gregory.szorc@gmail.com> parents: 24693 diff changeset	229 for rev in revs:
467a33142425 repoview: move function for computing filtered hash Gregory Szorc <gregory.szorc@gmail.com> parents: 24693 diff changeset	230 s.update('%s;' % rev)
467a33142425 repoview: move function for computing filtered hash Gregory Szorc <gregory.szorc@gmail.com> parents: 24693 diff changeset	231 key = s.digest()
467a33142425 repoview: move function for computing filtered hash Gregory Szorc <gregory.szorc@gmail.com> parents: 24693 diff changeset	232 return key
467a33142425 repoview: move function for computing filtered hash Gregory Szorc <gregory.szorc@gmail.com> parents: 24693 diff changeset	233
17649 f65c6a5f256c scmutil: rename classes from "opener" to "vfs" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17561 diff changeset	234 class abstractvfs(object):
14089 d3f7e110c3c0 opener: introduce an abstact superclass of it Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 14068 diff changeset	235 """Abstract base class; cannot be instantiated"""
d3f7e110c3c0 opener: introduce an abstact superclass of it Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 14068 diff changeset	236
d3f7e110c3c0 opener: introduce an abstact superclass of it Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 14068 diff changeset	237 def __init__(self, args, *kwargs):
d3f7e110c3c0 opener: introduce an abstact superclass of it Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 14068 diff changeset	238 '''Prevent instantiation; don't call this from subclasses.'''
d3f7e110c3c0 opener: introduce an abstact superclass of it Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 14068 diff changeset	239 raise NotImplementedError('attempted instantiating ' + str(type(self)))
d3f7e110c3c0 opener: introduce an abstact superclass of it Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 14068 diff changeset	240
16455 154219f3a6a4 opener: introduce tryread helper Matt Mackall <mpm@selenic.com> parents: 16436 diff changeset	241 def tryread(self, path):
16479 fc04698fa778 opener: coding style, use triple quotes for doc string Thomas Arendsen Hein <thomas@intevation.de> parents: 16455 diff changeset	242 '''gracefully return an empty string for missing files'''
16455 154219f3a6a4 opener: introduce tryread helper Matt Mackall <mpm@selenic.com> parents: 16436 diff changeset	243 try:
154219f3a6a4 opener: introduce tryread helper Matt Mackall <mpm@selenic.com> parents: 16436 diff changeset	244 return self.read(path)
25660 328739ea70c3 global: mass rewrite to use modern exception syntax Gregory Szorc <gregory.szorc@gmail.com> parents: 25658 diff changeset	245 except IOError as inst:
16455 154219f3a6a4 opener: introduce tryread helper Matt Mackall <mpm@selenic.com> parents: 16436 diff changeset	246 if inst.errno != errno.ENOENT:
154219f3a6a4 opener: introduce tryread helper Matt Mackall <mpm@selenic.com> parents: 16436 diff changeset	247 raise
154219f3a6a4 opener: introduce tryread helper Matt Mackall <mpm@selenic.com> parents: 16436 diff changeset	248 return ""
154219f3a6a4 opener: introduce tryread helper Matt Mackall <mpm@selenic.com> parents: 16436 diff changeset	249
23368 bf8c3172255c vfs: add "readlines" and "tryreadlines" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23259 diff changeset	250 def tryreadlines(self, path, mode='rb'):
bf8c3172255c vfs: add "readlines" and "tryreadlines" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23259 diff changeset	251 '''gracefully return an empty array for missing files'''
bf8c3172255c vfs: add "readlines" and "tryreadlines" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23259 diff changeset	252 try:
bf8c3172255c vfs: add "readlines" and "tryreadlines" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23259 diff changeset	253 return self.readlines(path, mode=mode)
25660 328739ea70c3 global: mass rewrite to use modern exception syntax Gregory Szorc <gregory.szorc@gmail.com> parents: 25658 diff changeset	254 except IOError as inst:
23368 bf8c3172255c vfs: add "readlines" and "tryreadlines" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23259 diff changeset	255 if inst.errno != errno.ENOENT:
bf8c3172255c vfs: add "readlines" and "tryreadlines" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23259 diff changeset	256 raise
bf8c3172255c vfs: add "readlines" and "tryreadlines" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23259 diff changeset	257 return []
bf8c3172255c vfs: add "readlines" and "tryreadlines" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23259 diff changeset	258
29730 2dd8c225e94c vfs: use propertycache for open Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 29727 diff changeset	259 @util.propertycache
2dd8c225e94c vfs: use propertycache for open Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 29727 diff changeset	260 def open(self):
23370 46265d0f0c7b vfs: add "notindexed" argument to invoke "ensuredir" with it in write mode FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23368 diff changeset	261 '''Open ``path`` file, which is relative to vfs root.
46265d0f0c7b vfs: add "notindexed" argument to invoke "ensuredir" with it in write mode FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23368 diff changeset	262
46265d0f0c7b vfs: add "notindexed" argument to invoke "ensuredir" with it in write mode FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23368 diff changeset	263 Newly created directories are marked as "not to be indexed by
46265d0f0c7b vfs: add "notindexed" argument to invoke "ensuredir" with it in write mode FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23368 diff changeset	264 the content indexing service", if ``notindexed`` is specified
46265d0f0c7b vfs: add "notindexed" argument to invoke "ensuredir" with it in write mode FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23368 diff changeset	265 for "write" mode access.
46265d0f0c7b vfs: add "notindexed" argument to invoke "ensuredir" with it in write mode FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23368 diff changeset	266 '''
29730 2dd8c225e94c vfs: use propertycache for open Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 29727 diff changeset	267 return self.__call__
19897 896a4568def7 vfs: add "open()" for newly added code paths which open files via vfs FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 19896 diff changeset	268
14167 0e4753807c93 util & scmutil: adapt read/write helpers as request by mpm Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 14138 diff changeset	269 def read(self, path):
27706 22e362da27cf scmutil: use context managers for file handles Gregory Szorc <gregory.szorc@gmail.com> parents: 27651 diff changeset	270 with self(path, 'rb') as fp:
14097 ca3376f044f8 opener: add read & write utility methods Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 14090 diff changeset	271 return fp.read()
ca3376f044f8 opener: add read & write utility methods Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 14090 diff changeset	272
23368 bf8c3172255c vfs: add "readlines" and "tryreadlines" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23259 diff changeset	273 def readlines(self, path, mode='rb'):
27706 22e362da27cf scmutil: use context managers for file handles Gregory Szorc <gregory.szorc@gmail.com> parents: 27651 diff changeset	274 with self(path, mode=mode) as fp:
23368 bf8c3172255c vfs: add "readlines" and "tryreadlines" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23259 diff changeset	275 return fp.readlines()
bf8c3172255c vfs: add "readlines" and "tryreadlines" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23259 diff changeset	276
28197 2ada62388bb1 scmutil: support background closing for write() Gregory Szorc <gregory.szorc@gmail.com> parents: 28017 diff changeset	277 def write(self, path, data, backgroundclose=False):
2ada62388bb1 scmutil: support background closing for write() Gregory Szorc <gregory.szorc@gmail.com> parents: 28017 diff changeset	278 with self(path, 'wb', backgroundclose=backgroundclose) as fp:
14167 0e4753807c93 util & scmutil: adapt read/write helpers as request by mpm Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 14138 diff changeset	279 return fp.write(data)
0e4753807c93 util & scmutil: adapt read/write helpers as request by mpm Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 14138 diff changeset	280
23371 1df6519eb3ab vfs: add "writelines" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23370 diff changeset	281 def writelines(self, path, data, mode='wb', notindexed=False):
27706 22e362da27cf scmutil: use context managers for file handles Gregory Szorc <gregory.szorc@gmail.com> parents: 27651 diff changeset	282 with self(path, mode=mode, notindexed=notindexed) as fp:
23371 1df6519eb3ab vfs: add "writelines" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23370 diff changeset	283 return fp.writelines(data)
1df6519eb3ab vfs: add "writelines" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23370 diff changeset	284
14167 0e4753807c93 util & scmutil: adapt read/write helpers as request by mpm Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 14138 diff changeset	285 def append(self, path, data):
27706 22e362da27cf scmutil: use context managers for file handles Gregory Szorc <gregory.szorc@gmail.com> parents: 27651 diff changeset	286 with self(path, 'ab') as fp:
14097 ca3376f044f8 opener: add read & write utility methods Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 14090 diff changeset	287 return fp.write(data)
ca3376f044f8 opener: add read & write utility methods Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 14090 diff changeset	288
25770 39de2e9cc6f4 vfs: add basename FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 25739 diff changeset	289 def basename(self, path):
39de2e9cc6f4 vfs: add basename FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 25739 diff changeset	290 """return base element of a path (as os.path.basename would do)
39de2e9cc6f4 vfs: add basename FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 25739 diff changeset	291
39de2e9cc6f4 vfs: add basename FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 25739 diff changeset	292 This exists to allow handling of strange encoding if needed."""
39de2e9cc6f4 vfs: add basename FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 25739 diff changeset	293 return os.path.basename(path)
39de2e9cc6f4 vfs: add basename FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 25739 diff changeset	294
20086 f3df2612f3c3 vfs: add "chmod()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20085 diff changeset	295 def chmod(self, path, mode):
f3df2612f3c3 vfs: add "chmod()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20085 diff changeset	296 return os.chmod(self.join(path), mode)
f3df2612f3c3 vfs: add "chmod()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20085 diff changeset	297
25772 5471965af5cb vfs: add dirname FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 25770 diff changeset	298 def dirname(self, path):
5471965af5cb vfs: add dirname FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 25770 diff changeset	299 """return dirname element of a path (as os.path.dirname would do)
5471965af5cb vfs: add dirname FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 25770 diff changeset	300
5471965af5cb vfs: add dirname FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 25770 diff changeset	301 This exists to allow handling of strange encoding if needed."""
5471965af5cb vfs: add dirname FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 25770 diff changeset	302 return os.path.dirname(path)
5471965af5cb vfs: add dirname FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 25770 diff changeset	303
17161 be016e96117a localrepo: use file API via vfs while ensuring repository directory FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17157 diff changeset	304 def exists(self, path=None):
be016e96117a localrepo: use file API via vfs while ensuring repository directory FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17157 diff changeset	305 return os.path.exists(self.join(path))
be016e96117a localrepo: use file API via vfs while ensuring repository directory FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17157 diff changeset	306
19899 8c3dcbbfb5de changelog: use "vfs.fstat()" instead of "util.fstat()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 19897 diff changeset	307 def fstat(self, fp):
8c3dcbbfb5de changelog: use "vfs.fstat()" instead of "util.fstat()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 19897 diff changeset	308 return util.fstat(fp)
8c3dcbbfb5de changelog: use "vfs.fstat()" instead of "util.fstat()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 19897 diff changeset	309
17161 be016e96117a localrepo: use file API via vfs while ensuring repository directory FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17157 diff changeset	310 def isdir(self, path=None):
be016e96117a localrepo: use file API via vfs while ensuring repository directory FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17157 diff changeset	311 return os.path.isdir(self.join(path))
be016e96117a localrepo: use file API via vfs while ensuring repository directory FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17157 diff changeset	312
20085 589d6bb5b18d vfs: add "isfile()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20045 diff changeset	313 def isfile(self, path=None):
589d6bb5b18d vfs: add "isfile()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20045 diff changeset	314 return os.path.isfile(self.join(path))
589d6bb5b18d vfs: add "isfile()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20045 diff changeset	315
18949 138978f20180 localrepo: use "vfs.islink()" instead of "os.path.islink()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 18948 diff changeset	316 def islink(self, path=None):
138978f20180 localrepo: use "vfs.islink()" instead of "os.path.islink()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 18948 diff changeset	317 return os.path.islink(self.join(path))
138978f20180 localrepo: use "vfs.islink()" instead of "os.path.islink()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 18948 diff changeset	318
27571 6a6e78f84cc6 merge: while checking for unknown files don't follow symlinks (issue5027) Siddharth Agarwal <sid0@fb.com> parents: 26836 diff changeset	319 def isfileorlink(self, path=None):
6a6e78f84cc6 merge: while checking for unknown files don't follow symlinks (issue5027) Siddharth Agarwal <sid0@fb.com> parents: 26836 diff changeset	320 '''return whether path is a regular file or a symlink
6a6e78f84cc6 merge: while checking for unknown files don't follow symlinks (issue5027) Siddharth Agarwal <sid0@fb.com> parents: 26836 diff changeset	321
6a6e78f84cc6 merge: while checking for unknown files don't follow symlinks (issue5027) Siddharth Agarwal <sid0@fb.com> parents: 26836 diff changeset	322 Unlike isfile, this doesn't follow symlinks.'''
6a6e78f84cc6 merge: while checking for unknown files don't follow symlinks (issue5027) Siddharth Agarwal <sid0@fb.com> parents: 26836 diff changeset	323 try:
6a6e78f84cc6 merge: while checking for unknown files don't follow symlinks (issue5027) Siddharth Agarwal <sid0@fb.com> parents: 26836 diff changeset	324 st = self.lstat(path)
6a6e78f84cc6 merge: while checking for unknown files don't follow symlinks (issue5027) Siddharth Agarwal <sid0@fb.com> parents: 26836 diff changeset	325 except OSError:
6a6e78f84cc6 merge: while checking for unknown files don't follow symlinks (issue5027) Siddharth Agarwal <sid0@fb.com> parents: 26836 diff changeset	326 return False
6a6e78f84cc6 merge: while checking for unknown files don't follow symlinks (issue5027) Siddharth Agarwal <sid0@fb.com> parents: 26836 diff changeset	327 mode = st.st_mode
6a6e78f84cc6 merge: while checking for unknown files don't follow symlinks (issue5027) Siddharth Agarwal <sid0@fb.com> parents: 26836 diff changeset	328 return stat.S_ISREG(mode) or stat.S_ISLNK(mode)
6a6e78f84cc6 merge: while checking for unknown files don't follow symlinks (issue5027) Siddharth Agarwal <sid0@fb.com> parents: 26836 diff changeset	329
23581 aed981c7bebf vfs: add a 'reljoin' function for joining relative paths Pierre-Yves David <pierre-yves.david@fb.com> parents: 23539 diff changeset	330 def reljoin(self, *paths):
aed981c7bebf vfs: add a 'reljoin' function for joining relative paths Pierre-Yves David <pierre-yves.david@fb.com> parents: 23539 diff changeset	331 """join various elements of a path together (as os.path.join would do)
aed981c7bebf vfs: add a 'reljoin' function for joining relative paths Pierre-Yves David <pierre-yves.david@fb.com> parents: 23539 diff changeset	332
aed981c7bebf vfs: add a 'reljoin' function for joining relative paths Pierre-Yves David <pierre-yves.david@fb.com> parents: 23539 diff changeset	333 The vfs base is not injected so that path stay relative. This exists
aed981c7bebf vfs: add a 'reljoin' function for joining relative paths Pierre-Yves David <pierre-yves.david@fb.com> parents: 23539 diff changeset	334 to allow handling of strange encoding if needed."""
aed981c7bebf vfs: add a 'reljoin' function for joining relative paths Pierre-Yves David <pierre-yves.david@fb.com> parents: 23539 diff changeset	335 return os.path.join(*paths)
aed981c7bebf vfs: add a 'reljoin' function for joining relative paths Pierre-Yves David <pierre-yves.david@fb.com> parents: 23539 diff changeset	336
23582 7559dc8c4238 vfs: add a 'split' method Pierre-Yves David <pierre-yves.david@fb.com> parents: 23581 diff changeset	337 def split(self, path):
7559dc8c4238 vfs: add a 'split' method Pierre-Yves David <pierre-yves.david@fb.com> parents: 23581 diff changeset	338 """split top-most element of a path (as os.path.split would do)
7559dc8c4238 vfs: add a 'split' method Pierre-Yves David <pierre-yves.david@fb.com> parents: 23581 diff changeset	339
7559dc8c4238 vfs: add a 'split' method Pierre-Yves David <pierre-yves.david@fb.com> parents: 23581 diff changeset	340 This exists to allow handling of strange encoding if needed."""
7559dc8c4238 vfs: add a 'split' method Pierre-Yves David <pierre-yves.david@fb.com> parents: 23581 diff changeset	341 return os.path.split(path)
7559dc8c4238 vfs: add a 'split' method Pierre-Yves David <pierre-yves.david@fb.com> parents: 23581 diff changeset	342
21563 764b691b8bda vfs: add lexists() in current api Chinmay Joshi <c@chinmayjoshi.com> parents: 21111 diff changeset	343 def lexists(self, path=None):
764b691b8bda vfs: add lexists() in current api Chinmay Joshi <c@chinmayjoshi.com> parents: 21111 diff changeset	344 return os.path.lexists(self.join(path))
764b691b8bda vfs: add lexists() in current api Chinmay Joshi <c@chinmayjoshi.com> parents: 21111 diff changeset	345
19900 7c21e3398931 context: use "vfs.lstat()" instead of "os.lstat()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 19899 diff changeset	346 def lstat(self, path=None):
7c21e3398931 context: use "vfs.lstat()" instead of "os.lstat()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 19899 diff changeset	347 return os.lstat(self.join(path))
7c21e3398931 context: use "vfs.lstat()" instead of "os.lstat()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 19899 diff changeset	348
21799 dfacdd6a111e vfs: add listdir for os.listdir in vfs Chinmay Joshi <c@chinmayjoshi.com> parents: 21716 diff changeset	349 def listdir(self, path=None):
dfacdd6a111e vfs: add listdir for os.listdir in vfs Chinmay Joshi <c@chinmayjoshi.com> parents: 21716 diff changeset	350 return os.listdir(self.join(path))
dfacdd6a111e vfs: add listdir for os.listdir in vfs Chinmay Joshi <c@chinmayjoshi.com> parents: 21716 diff changeset	351
17161 be016e96117a localrepo: use file API via vfs while ensuring repository directory FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17157 diff changeset	352 def makedir(self, path=None, notindexed=True):
be016e96117a localrepo: use file API via vfs while ensuring repository directory FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17157 diff changeset	353 return util.makedir(self.join(path), notindexed)
be016e96117a localrepo: use file API via vfs while ensuring repository directory FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17157 diff changeset	354
be016e96117a localrepo: use file API via vfs while ensuring repository directory FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17157 diff changeset	355 def makedirs(self, path=None, mode=None):
be016e96117a localrepo: use file API via vfs while ensuring repository directory FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17157 diff changeset	356 return util.makedirs(self.join(path), mode)
be016e96117a localrepo: use file API via vfs while ensuring repository directory FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17157 diff changeset	357
20090 88d8e568add1 vfs: add "makelock()" and "readlock()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20086 diff changeset	358 def makelock(self, info, path):
88d8e568add1 vfs: add "makelock()" and "readlock()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20086 diff changeset	359 return util.makelock(info, self.join(path))
88d8e568add1 vfs: add "makelock()" and "readlock()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20086 diff changeset	360
17723 ab23768746fd scmutil: reorder newly added functions for vfs support in dictionary order FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17681 diff changeset	361 def mkdir(self, path=None):
ab23768746fd scmutil: reorder newly added functions for vfs support in dictionary order FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17681 diff changeset	362 return os.mkdir(self.join(path))
ab23768746fd scmutil: reorder newly added functions for vfs support in dictionary order FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17681 diff changeset	363
20980 6fb4c94ae300 vfs: add "mkstemp()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20862 diff changeset	364 def mkstemp(self, suffix='', prefix='tmp', dir=None, text=False):
6fb4c94ae300 vfs: add "mkstemp()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20862 diff changeset	365 fd, name = tempfile.mkstemp(suffix=suffix, prefix=prefix,
6fb4c94ae300 vfs: add "mkstemp()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20862 diff changeset	366 dir=self.join(dir), text=text)
6fb4c94ae300 vfs: add "mkstemp()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20862 diff changeset	367 dname, fname = util.split(name)
6fb4c94ae300 vfs: add "mkstemp()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20862 diff changeset	368 if dir:
6fb4c94ae300 vfs: add "mkstemp()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20862 diff changeset	369 return fd, os.path.join(dir, fname)
6fb4c94ae300 vfs: add "mkstemp()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20862 diff changeset	370 else:
6fb4c94ae300 vfs: add "mkstemp()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20862 diff changeset	371 return fd, fname
6fb4c94ae300 vfs: add "mkstemp()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20862 diff changeset	372
17747 aad3bce98f76 store: invoke "osutil.listdir()" via vfs FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17726 diff changeset	373 def readdir(self, path=None, stat=None, skip=None):
aad3bce98f76 store: invoke "osutil.listdir()" via vfs FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17726 diff changeset	374 return osutil.listdir(self.join(path), stat, skip)
aad3bce98f76 store: invoke "osutil.listdir()" via vfs FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17726 diff changeset	375
20090 88d8e568add1 vfs: add "makelock()" and "readlock()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20086 diff changeset	376 def readlock(self, path):
88d8e568add1 vfs: add "makelock()" and "readlock()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20086 diff changeset	377 return util.readlock(self.join(path))
88d8e568add1 vfs: add "makelock()" and "readlock()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20086 diff changeset	378
29203 731ced087a4b vfs: make rename avoid ambiguity of file stat if needed FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29202 diff changeset	379 def rename(self, src, dst, checkambig=False):
29367 4e6e280e238f doc: describe detail about checkambig optional argument FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29341 diff changeset	380 """Rename from src to dst
4e6e280e238f doc: describe detail about checkambig optional argument FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29341 diff changeset	381
4e6e280e238f doc: describe detail about checkambig optional argument FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29341 diff changeset	382 checkambig argument is used with util.filestat, and is useful
4e6e280e238f doc: describe detail about checkambig optional argument FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29341 diff changeset	383 only if destination file is guarded by any lock
4e6e280e238f doc: describe detail about checkambig optional argument FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29341 diff changeset	384 (e.g. repo.lock or repo.wlock).
4e6e280e238f doc: describe detail about checkambig optional argument FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29341 diff changeset	385 """
29203 731ced087a4b vfs: make rename avoid ambiguity of file stat if needed FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29202 diff changeset	386 dstpath = self.join(dst)
731ced087a4b vfs: make rename avoid ambiguity of file stat if needed FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29202 diff changeset	387 oldstat = checkambig and util.filestat(dstpath)
731ced087a4b vfs: make rename avoid ambiguity of file stat if needed FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29202 diff changeset	388 if oldstat and oldstat.stat:
731ced087a4b vfs: make rename avoid ambiguity of file stat if needed FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29202 diff changeset	389 ret = util.rename(self.join(src), dstpath)
731ced087a4b vfs: make rename avoid ambiguity of file stat if needed FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29202 diff changeset	390 newstat = util.filestat(dstpath)
731ced087a4b vfs: make rename avoid ambiguity of file stat if needed FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29202 diff changeset	391 if newstat.isambig(oldstat):
731ced087a4b vfs: make rename avoid ambiguity of file stat if needed FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29202 diff changeset	392 # stat of renamed file is ambiguous to original one
30254 bff5ccbe5ead vfs: ignore EPERM at os.utime, which avoids ambiguity at renaming (issue5418) FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 30109 diff changeset	393 newstat.avoidambig(dstpath, oldstat)
29203 731ced087a4b vfs: make rename avoid ambiguity of file stat if needed FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29202 diff changeset	394 return ret
731ced087a4b vfs: make rename avoid ambiguity of file stat if needed FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29202 diff changeset	395 return util.rename(self.join(src), dstpath)
18948 2f05fa162316 localrepo: use "vfs.rename()" instead of "util.rename()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 18945 diff changeset	396
18950 647e3b0c8751 localrepo: use "vfs.readlink()" instead of "os.readlink()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 18949 diff changeset	397 def readlink(self, path):
647e3b0c8751 localrepo: use "vfs.readlink()" instead of "os.readlink()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 18949 diff changeset	398 return os.readlink(self.join(path))
647e3b0c8751 localrepo: use "vfs.readlink()" instead of "os.readlink()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 18949 diff changeset	399
24693 0d28b0df77ea vfs: add removedirs FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24689 diff changeset	400 def removedirs(self, path=None):
0d28b0df77ea vfs: add removedirs FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24689 diff changeset	401 """Remove a leaf directory and all empty intermediate ones
0d28b0df77ea vfs: add removedirs FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24689 diff changeset	402 """
0d28b0df77ea vfs: add removedirs FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24689 diff changeset	403 return util.removedirs(self.join(path))
0d28b0df77ea vfs: add removedirs FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24689 diff changeset	404
24689 ca3a90096c95 vfs: add rmtree FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24635 diff changeset	405 def rmtree(self, path=None, ignore_errors=False, forcibly=False):
ca3a90096c95 vfs: add rmtree FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24635 diff changeset	406 """Remove a directory tree recursively
ca3a90096c95 vfs: add rmtree FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24635 diff changeset	407
ca3a90096c95 vfs: add rmtree FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24635 diff changeset	408 If ``forcibly``, this tries to remove READ-ONLY files, too.
ca3a90096c95 vfs: add rmtree FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24635 diff changeset	409 """
ca3a90096c95 vfs: add rmtree FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24635 diff changeset	410 if forcibly:
ca3a90096c95 vfs: add rmtree FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24635 diff changeset	411 def onerror(function, path, excinfo):
ca3a90096c95 vfs: add rmtree FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24635 diff changeset	412 if function is not os.remove:
ca3a90096c95 vfs: add rmtree FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24635 diff changeset	413 raise
ca3a90096c95 vfs: add rmtree FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24635 diff changeset	414 # read-only files cannot be unlinked under Windows
ca3a90096c95 vfs: add rmtree FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24635 diff changeset	415 s = os.stat(path)
ca3a90096c95 vfs: add rmtree FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24635 diff changeset	416 if (s.st_mode & stat.S_IWRITE) != 0:
ca3a90096c95 vfs: add rmtree FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24635 diff changeset	417 raise
ca3a90096c95 vfs: add rmtree FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24635 diff changeset	418 os.chmod(path, stat.S_IMODE(s.st_mode) \| stat.S_IWRITE)
ca3a90096c95 vfs: add rmtree FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24635 diff changeset	419 os.remove(path)
ca3a90096c95 vfs: add rmtree FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24635 diff changeset	420 else:
ca3a90096c95 vfs: add rmtree FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24635 diff changeset	421 onerror = None
ca3a90096c95 vfs: add rmtree FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24635 diff changeset	422 return shutil.rmtree(self.join(path),
ca3a90096c95 vfs: add rmtree FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24635 diff changeset	423 ignore_errors=ignore_errors, onerror=onerror)
ca3a90096c95 vfs: add rmtree FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24635 diff changeset	424
18951 d13916a00b7e localrepo: use "vfs.setflags()" instead of "util.setflags()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 18950 diff changeset	425 def setflags(self, path, l, x):
d13916a00b7e localrepo: use "vfs.setflags()" instead of "util.setflags()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 18950 diff changeset	426 return util.setflags(self.join(path), l, x)
d13916a00b7e localrepo: use "vfs.setflags()" instead of "util.setflags()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 18950 diff changeset	427
17726 7cb7e17c23b2 store: invoke "os.stat()" for "createmode" initialization via vfs FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17725 diff changeset	428 def stat(self, path=None):
7cb7e17c23b2 store: invoke "os.stat()" for "createmode" initialization via vfs FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17725 diff changeset	429 return os.stat(self.join(path))
7cb7e17c23b2 store: invoke "os.stat()" for "createmode" initialization via vfs FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17725 diff changeset	430
19895 37c0d93fb166 bookmarks: use "vfs.unlink()" instead of "util.unlink()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 19655 diff changeset	431 def unlink(self, path=None):
37c0d93fb166 bookmarks: use "vfs.unlink()" instead of "util.unlink()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 19655 diff changeset	432 return util.unlink(self.join(path))
37c0d93fb166 bookmarks: use "vfs.unlink()" instead of "util.unlink()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 19655 diff changeset	433
21716 90f9be5adade vfs: add unlinkpath to vfs Chinmay Joshi <c@chinmayjoshi.com> parents: 21563 diff changeset	434 def unlinkpath(self, path=None, ignoremissing=False):
90f9be5adade vfs: add unlinkpath to vfs Chinmay Joshi <c@chinmayjoshi.com> parents: 21563 diff changeset	435 return util.unlinkpath(self.join(path), ignoremissing)
90f9be5adade vfs: add unlinkpath to vfs Chinmay Joshi <c@chinmayjoshi.com> parents: 21563 diff changeset	436
19896 af03279c766a bookmarks: use "vfs.utime()" instead of "os.utime()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 19895 diff changeset	437 def utime(self, path=None, t=None):
af03279c766a bookmarks: use "vfs.utime()" instead of "os.utime()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 19895 diff changeset	438 return os.utime(self.join(path), t)
af03279c766a bookmarks: use "vfs.utime()" instead of "os.utime()" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 19895 diff changeset	439
24725 ee751d47cf2c vfs: add walk FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24723 diff changeset	440 def walk(self, path=None, onerror=None):
ee751d47cf2c vfs: add walk FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24723 diff changeset	441 """Yield (dirpath, dirs, files) tuple for each directories under path
ee751d47cf2c vfs: add walk FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24723 diff changeset	442
ee751d47cf2c vfs: add walk FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24723 diff changeset	443 ``dirpath`` is relative one from the root of this vfs. This
ee751d47cf2c vfs: add walk FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24723 diff changeset	444 uses ``os.sep`` as path separator, even you specify POSIX
ee751d47cf2c vfs: add walk FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24723 diff changeset	445 style ``path``.
ee751d47cf2c vfs: add walk FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24723 diff changeset	446
ee751d47cf2c vfs: add walk FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24723 diff changeset	447 "The root of this vfs" is represented as empty ``dirpath``.
ee751d47cf2c vfs: add walk FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24723 diff changeset	448 """
ee751d47cf2c vfs: add walk FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24723 diff changeset	449 root = os.path.normpath(self.join(None))
ee751d47cf2c vfs: add walk FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24723 diff changeset	450 # when dirpath == root, dirpath[prefixlen:] becomes empty
ee751d47cf2c vfs: add walk FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24723 diff changeset	451 # because len(dirpath) < prefixlen.
ee751d47cf2c vfs: add walk FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24723 diff changeset	452 prefixlen = len(pathutil.normasprefix(root))
ee751d47cf2c vfs: add walk FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24723 diff changeset	453 for dirpath, dirs, files in os.walk(self.join(path), onerror=onerror):
ee751d47cf2c vfs: add walk FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24723 diff changeset	454 yield (dirpath[prefixlen:], dirs, files)
ee751d47cf2c vfs: add walk FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24723 diff changeset	455
27895 2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	456 @contextlib.contextmanager
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	457 def backgroundclosing(self, ui, expectedcount=-1):
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	458 """Allow files to be closed asynchronously.
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	459
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	460 When this context manager is active, ``backgroundclose`` can be passed
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	461 to ``__call__``/``open`` to result in the file possibly being closed
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	462 asynchronously, on a background thread.
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	463 """
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	464 # This is an arbitrary restriction and could be changed if we ever
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	465 # have a use case.
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	466 vfs = getattr(self, 'vfs', self)
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	467 if getattr(vfs, '_backgroundfilecloser', None):
29389 98e8313dcd9e i18n: translate abort messages liscju <piotr.listkiewicz@gmail.com> parents: 29373 diff changeset	468 raise error.Abort(
98e8313dcd9e i18n: translate abort messages liscju <piotr.listkiewicz@gmail.com> parents: 29373 diff changeset	469 _('can only have 1 active background file closer'))
27895 2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	470
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	471 with backgroundfilecloser(ui, expectedcount=expectedcount) as bfc:
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	472 try:
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	473 vfs._backgroundfilecloser = bfc
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	474 yield bfc
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	475 finally:
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	476 vfs._backgroundfilecloser = None
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	477
17649 f65c6a5f256c scmutil: rename classes from "opener" to "vfs" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17561 diff changeset	478 class vfs(abstractvfs):
f65c6a5f256c scmutil: rename classes from "opener" to "vfs" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17561 diff changeset	479 '''Operate files relative to a base directory
13970 d13913355390 move opener from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13962 diff changeset	480
d13913355390 move opener from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13962 diff changeset	481 This class is used to hide the details of COW semantics and
d13913355390 move opener from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13962 diff changeset	482 remote file access from higher level code.
d13913355390 move opener from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13962 diff changeset	483 '''
18945 e75b72fffdfe vfs: split "expand" into "realpath"/"expandpath" to apply each separately FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 18900 diff changeset	484 def __init__(self, base, audit=True, expandpath=False, realpath=False):
e75b72fffdfe vfs: split "expand" into "realpath"/"expandpath" to apply each separately FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 18900 diff changeset	485 if expandpath:
e75b72fffdfe vfs: split "expand" into "realpath"/"expandpath" to apply each separately FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 18900 diff changeset	486 base = util.expandpath(base)
e75b72fffdfe vfs: split "expand" into "realpath"/"expandpath" to apply each separately FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 18900 diff changeset	487 if realpath:
e75b72fffdfe vfs: split "expand" into "realpath"/"expandpath" to apply each separately FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 18900 diff changeset	488 base = os.path.realpath(base)
13970 d13913355390 move opener from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13962 diff changeset	489 self.base = base
27879 52a4ad62b006 cleanup: use modern @property/@foo.setter property specification Augie Fackler <augie@google.com> parents: 27851 diff changeset	490 self.mustaudit = audit
17554 5450c8ad9d98 scmutil: turn opener._audit into a property, mustaudit Bryan O'Sullivan <bryano@fb.com> parents: 17248 diff changeset	491 self.createmode = None
5450c8ad9d98 scmutil: turn opener._audit into a property, mustaudit Bryan O'Sullivan <bryano@fb.com> parents: 17248 diff changeset	492 self._trustnlink = None
5450c8ad9d98 scmutil: turn opener._audit into a property, mustaudit Bryan O'Sullivan <bryano@fb.com> parents: 17248 diff changeset	493
27879 52a4ad62b006 cleanup: use modern @property/@foo.setter property specification Augie Fackler <augie@google.com> parents: 27851 diff changeset	494 @property
52a4ad62b006 cleanup: use modern @property/@foo.setter property specification Augie Fackler <augie@google.com> parents: 27851 diff changeset	495 def mustaudit(self):
17554 5450c8ad9d98 scmutil: turn opener._audit into a property, mustaudit Bryan O'Sullivan <bryano@fb.com> parents: 17248 diff changeset	496 return self._audit
5450c8ad9d98 scmutil: turn opener._audit into a property, mustaudit Bryan O'Sullivan <bryano@fb.com> parents: 17248 diff changeset	497
27879 52a4ad62b006 cleanup: use modern @property/@foo.setter property specification Augie Fackler <augie@google.com> parents: 27851 diff changeset	498 @mustaudit.setter
52a4ad62b006 cleanup: use modern @property/@foo.setter property specification Augie Fackler <augie@google.com> parents: 27851 diff changeset	499 def mustaudit(self, onoff):
17554 5450c8ad9d98 scmutil: turn opener._audit into a property, mustaudit Bryan O'Sullivan <bryano@fb.com> parents: 17248 diff changeset	500 self._audit = onoff
5450c8ad9d98 scmutil: turn opener._audit into a property, mustaudit Bryan O'Sullivan <bryano@fb.com> parents: 17248 diff changeset	501 if onoff:
20033 f962870712da pathutil: tease out a new library to break an import cycle from canonpath use Augie Fackler <raf@durin42.com> parents: 20006 diff changeset	502 self.audit = pathutil.pathauditor(self.base)
13970 d13913355390 move opener from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13962 diff changeset	503 else:
18327 4aecdb91443c scmutil: simplify vfs.audit - drop wrapped vfs.auditor Mads Kiilerich <mads@kiilerich.com> parents: 18316 diff changeset	504 self.audit = util.always
17554 5450c8ad9d98 scmutil: turn opener._audit into a property, mustaudit Bryan O'Sullivan <bryano@fb.com> parents: 17248 diff changeset	505
13970 d13913355390 move opener from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13962 diff changeset	506 @util.propertycache
14261 e3649bcca3f6 opener: rename _can_symlink to _cansymlink Adrian Buehlmann <adrian@cadifra.com> parents: 14236 diff changeset	507 def _cansymlink(self):
13970 d13913355390 move opener from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13962 diff changeset	508 return util.checklink(self.base)
d13913355390 move opener from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13962 diff changeset	509
18192 f9a89bdd64a6 scmutil: don't try to match modes on filesystems without modes (issue3740) Matt Mackall <mpm@selenic.com> parents: 17850 diff changeset	510 @util.propertycache
f9a89bdd64a6 scmutil: don't try to match modes on filesystems without modes (issue3740) Matt Mackall <mpm@selenic.com> parents: 17850 diff changeset	511 def _chmod(self):
f9a89bdd64a6 scmutil: don't try to match modes on filesystems without modes (issue3740) Matt Mackall <mpm@selenic.com> parents: 17850 diff changeset	512 return util.checkexec(self.base)
f9a89bdd64a6 scmutil: don't try to match modes on filesystems without modes (issue3740) Matt Mackall <mpm@selenic.com> parents: 17850 diff changeset	513
17763 13070de77c86 vfs: backout fchmod change from 76b73ce0ffac Matt Mackall <mpm@selenic.com> parents: 17752 diff changeset	514 def _fixfilemode(self, name):
18192 f9a89bdd64a6 scmutil: don't try to match modes on filesystems without modes (issue3740) Matt Mackall <mpm@selenic.com> parents: 17850 diff changeset	515 if self.createmode is None or not self._chmod:
13970 d13913355390 move opener from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13962 diff changeset	516 return
25658 e93036747902 global: mass rewrite to use modern octal syntax Gregory Szorc <gregory.szorc@gmail.com> parents: 25629 diff changeset	517 os.chmod(name, self.createmode & 0o666)
13970 d13913355390 move opener from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13962 diff changeset	518
23370 46265d0f0c7b vfs: add "notindexed" argument to invoke "ensuredir" with it in write mode FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23368 diff changeset	519 def __call__(self, path, mode="r", text=False, atomictemp=False,
29202 76f1ea360c7e vfs: make atomictempfile avoid ambiguity of file stat if needed FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29119 diff changeset	520 notindexed=False, backgroundclose=False, checkambig=False):
23370 46265d0f0c7b vfs: add "notindexed" argument to invoke "ensuredir" with it in write mode FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23368 diff changeset	521 '''Open ``path`` file, which is relative to vfs root.
46265d0f0c7b vfs: add "notindexed" argument to invoke "ensuredir" with it in write mode FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23368 diff changeset	522
46265d0f0c7b vfs: add "notindexed" argument to invoke "ensuredir" with it in write mode FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23368 diff changeset	523 Newly created directories are marked as "not to be indexed by
46265d0f0c7b vfs: add "notindexed" argument to invoke "ensuredir" with it in write mode FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23368 diff changeset	524 the content indexing service", if ``notindexed`` is specified
46265d0f0c7b vfs: add "notindexed" argument to invoke "ensuredir" with it in write mode FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23368 diff changeset	525 for "write" mode access.
27895 2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	526
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	527 If ``backgroundclose`` is passed, the file may be closed asynchronously.
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	528 It can only be used if the ``self.backgroundclosing()`` context manager
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	529 is active. This should only be specified if the following criteria hold:
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	530
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	531 1. There is a potential for writing thousands of files. Unless you
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	532 are writing thousands of files, the performance benefits of
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	533 asynchronously closing files is not realized.
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	534 2. Files are opened exactly once for the ``backgroundclosing``
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	535 active duration and are therefore free of race conditions between
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	536 closing a file on a background thread and reopening it. (If the
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	537 file were opened multiple times, there could be unflushed data
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	538 because the original file handle hasn't been flushed/closed yet.)
29202 76f1ea360c7e vfs: make atomictempfile avoid ambiguity of file stat if needed FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29119 diff changeset	539
29367 4e6e280e238f doc: describe detail about checkambig optional argument FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29341 diff changeset	540 ``checkambig`` argument is passed to atomictemplfile (valid
4e6e280e238f doc: describe detail about checkambig optional argument FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29341 diff changeset	541 only for writing), and is useful only if target file is
4e6e280e238f doc: describe detail about checkambig optional argument FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29341 diff changeset	542 guarded by any lock (e.g. repo.lock or repo.wlock).
23370 46265d0f0c7b vfs: add "notindexed" argument to invoke "ensuredir" with it in write mode FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23368 diff changeset	543 '''
14720 36283a7b6856 opener: add self._audit (issue2862) Adrian Buehlmann <adrian@cadifra.com> parents: 14672 diff changeset	544 if self._audit:
36283a7b6856 opener: add self._audit (issue2862) Adrian Buehlmann <adrian@cadifra.com> parents: 14672 diff changeset	545 r = util.checkosfilename(path)
36283a7b6856 opener: add self._audit (issue2862) Adrian Buehlmann <adrian@cadifra.com> parents: 14672 diff changeset	546 if r:
26587 56b2bcea2529 error: get Abort from 'error' instead of 'util' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26491 diff changeset	547 raise error.Abort("%s: %r" % (r, path))
18327 4aecdb91443c scmutil: simplify vfs.audit - drop wrapped vfs.auditor Mads Kiilerich <mads@kiilerich.com> parents: 18316 diff changeset	548 self.audit(path)
16199 8181bd808dc5 scmutil: add join method to opener to construct path relative to base Idan Kamara <idankk86@gmail.com> parents: 16198 diff changeset	549 f = self.join(path)
13970 d13913355390 move opener from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13962 diff changeset	550
d13913355390 move opener from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13962 diff changeset	551 if not text and "b" not in mode:
d13913355390 move opener from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13962 diff changeset	552 mode += "b" # for that other OS
d13913355390 move opener from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13962 diff changeset	553
d13913355390 move opener from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13962 diff changeset	554 nlink = -1
17937 3cb032d50447 vfs: optimize __call__ by not calling util.split for reads Adrian Buehlmann <adrian@cadifra.com> parents: 17850 diff changeset	555 if mode not in ('r', 'rb'):
3cb032d50447 vfs: optimize __call__ by not calling util.split for reads Adrian Buehlmann <adrian@cadifra.com> parents: 17850 diff changeset	556 dirname, basename = util.split(f)
3cb032d50447 vfs: optimize __call__ by not calling util.split for reads Adrian Buehlmann <adrian@cadifra.com> parents: 17850 diff changeset	557 # If basename is empty, then the path is malformed because it points
3cb032d50447 vfs: optimize __call__ by not calling util.split for reads Adrian Buehlmann <adrian@cadifra.com> parents: 17850 diff changeset	558 # to a directory. Let the posixfile() call below raise IOError.
3cb032d50447 vfs: optimize __call__ by not calling util.split for reads Adrian Buehlmann <adrian@cadifra.com> parents: 17850 diff changeset	559 if basename:
3cb032d50447 vfs: optimize __call__ by not calling util.split for reads Adrian Buehlmann <adrian@cadifra.com> parents: 17850 diff changeset	560 if atomictemp:
29017 07be86828e79 util: fix race in makedirs() Adam Simpkins <simpkins@fb.com> parents: 28819 diff changeset	561 util.makedirs(dirname, self.createmode, notindexed)
29202 76f1ea360c7e vfs: make atomictempfile avoid ambiguity of file stat if needed FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29119 diff changeset	562 return util.atomictempfile(f, mode, self.createmode,
76f1ea360c7e vfs: make atomictempfile avoid ambiguity of file stat if needed FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29119 diff changeset	563 checkambig=checkambig)
17937 3cb032d50447 vfs: optimize __call__ by not calling util.split for reads Adrian Buehlmann <adrian@cadifra.com> parents: 17850 diff changeset	564 try:
3cb032d50447 vfs: optimize __call__ by not calling util.split for reads Adrian Buehlmann <adrian@cadifra.com> parents: 17850 diff changeset	565 if 'w' in mode:
3cb032d50447 vfs: optimize __call__ by not calling util.split for reads Adrian Buehlmann <adrian@cadifra.com> parents: 17850 diff changeset	566 util.unlink(f)
3cb032d50447 vfs: optimize __call__ by not calling util.split for reads Adrian Buehlmann <adrian@cadifra.com> parents: 17850 diff changeset	567 nlink = 0
3cb032d50447 vfs: optimize __call__ by not calling util.split for reads Adrian Buehlmann <adrian@cadifra.com> parents: 17850 diff changeset	568 else:
3cb032d50447 vfs: optimize __call__ by not calling util.split for reads Adrian Buehlmann <adrian@cadifra.com> parents: 17850 diff changeset	569 # nlinks() may behave differently for files on Windows
3cb032d50447 vfs: optimize __call__ by not calling util.split for reads Adrian Buehlmann <adrian@cadifra.com> parents: 17850 diff changeset	570 # shares if the file is open.
27706 22e362da27cf scmutil: use context managers for file handles Gregory Szorc <gregory.szorc@gmail.com> parents: 27651 diff changeset	571 with util.posixfile(f):
22e362da27cf scmutil: use context managers for file handles Gregory Szorc <gregory.szorc@gmail.com> parents: 27651 diff changeset	572 nlink = util.nlinks(f)
22e362da27cf scmutil: use context managers for file handles Gregory Szorc <gregory.szorc@gmail.com> parents: 27651 diff changeset	573 if nlink < 1:
22e362da27cf scmutil: use context managers for file handles Gregory Szorc <gregory.szorc@gmail.com> parents: 27651 diff changeset	574 nlink = 2 # force mktempcopy (issue1922)
25660 328739ea70c3 global: mass rewrite to use modern exception syntax Gregory Szorc <gregory.szorc@gmail.com> parents: 25658 diff changeset	575 except (OSError, IOError) as e:
17937 3cb032d50447 vfs: optimize __call__ by not calling util.split for reads Adrian Buehlmann <adrian@cadifra.com> parents: 17850 diff changeset	576 if e.errno != errno.ENOENT:
3cb032d50447 vfs: optimize __call__ by not calling util.split for reads Adrian Buehlmann <adrian@cadifra.com> parents: 17850 diff changeset	577 raise
13970 d13913355390 move opener from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13962 diff changeset	578 nlink = 0
29017 07be86828e79 util: fix race in makedirs() Adam Simpkins <simpkins@fb.com> parents: 28819 diff changeset	579 util.makedirs(dirname, self.createmode, notindexed)
17937 3cb032d50447 vfs: optimize __call__ by not calling util.split for reads Adrian Buehlmann <adrian@cadifra.com> parents: 17850 diff changeset	580 if nlink > 0:
3cb032d50447 vfs: optimize __call__ by not calling util.split for reads Adrian Buehlmann <adrian@cadifra.com> parents: 17850 diff changeset	581 if self._trustnlink is None:
3cb032d50447 vfs: optimize __call__ by not calling util.split for reads Adrian Buehlmann <adrian@cadifra.com> parents: 17850 diff changeset	582 self._trustnlink = nlink > 1 or util.checknlink(f)
3cb032d50447 vfs: optimize __call__ by not calling util.split for reads Adrian Buehlmann <adrian@cadifra.com> parents: 17850 diff changeset	583 if nlink > 1 or not self._trustnlink:
3cb032d50447 vfs: optimize __call__ by not calling util.split for reads Adrian Buehlmann <adrian@cadifra.com> parents: 17850 diff changeset	584 util.rename(util.mktempcopy(f), f)
13970 d13913355390 move opener from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13962 diff changeset	585 fp = util.posixfile(f, mode)
d13913355390 move opener from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13962 diff changeset	586 if nlink == 0:
17763 13070de77c86 vfs: backout fchmod change from 76b73ce0ffac Matt Mackall <mpm@selenic.com> parents: 17752 diff changeset	587 self._fixfilemode(f)
27895 2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	588
30000 9766d88c2465 vfs: use checkambigatclosing in checkambig=True but atomictemp=False case FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29999 diff changeset	589 if checkambig:
9766d88c2465 vfs: use checkambigatclosing in checkambig=True but atomictemp=False case FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29999 diff changeset	590 if mode in ('r', 'rb'):
9766d88c2465 vfs: use checkambigatclosing in checkambig=True but atomictemp=False case FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29999 diff changeset	591 raise error.Abort(_('implementation error: mode %s is not'
9766d88c2465 vfs: use checkambigatclosing in checkambig=True but atomictemp=False case FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29999 diff changeset	592 ' valid for checkambig=True') % mode)
9766d88c2465 vfs: use checkambigatclosing in checkambig=True but atomictemp=False case FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29999 diff changeset	593 fp = checkambigatclosing(fp)
9766d88c2465 vfs: use checkambigatclosing in checkambig=True but atomictemp=False case FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29999 diff changeset	594
27895 2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	595 if backgroundclose:
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	596 if not self._backgroundfilecloser:
29389 98e8313dcd9e i18n: translate abort messages liscju <piotr.listkiewicz@gmail.com> parents: 29373 diff changeset	597 raise error.Abort(_('backgroundclose can only be used when a '
27895 2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	598 'backgroundclosing context manager is active')
29389 98e8313dcd9e i18n: translate abort messages liscju <piotr.listkiewicz@gmail.com> parents: 29373 diff changeset	599 )
27895 2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	600
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	601 fp = delayclosedfile(fp, self._backgroundfilecloser)
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	602
13970 d13913355390 move opener from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13962 diff changeset	603 return fp
d13913355390 move opener from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13962 diff changeset	604
d13913355390 move opener from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13962 diff changeset	605 def symlink(self, src, dst):
18327 4aecdb91443c scmutil: simplify vfs.audit - drop wrapped vfs.auditor Mads Kiilerich <mads@kiilerich.com> parents: 18316 diff changeset	606 self.audit(dst)
16199 8181bd808dc5 scmutil: add join method to opener to construct path relative to base Idan Kamara <idankk86@gmail.com> parents: 16198 diff changeset	607 linkname = self.join(dst)
13970 d13913355390 move opener from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13962 diff changeset	608 try:
d13913355390 move opener from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13962 diff changeset	609 os.unlink(linkname)
d13913355390 move opener from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13962 diff changeset	610 except OSError:
d13913355390 move opener from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13962 diff changeset	611 pass
d13913355390 move opener from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13962 diff changeset	612
29017 07be86828e79 util: fix race in makedirs() Adam Simpkins <simpkins@fb.com> parents: 28819 diff changeset	613 util.makedirs(os.path.dirname(linkname), self.createmode)
13970 d13913355390 move opener from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13962 diff changeset	614
14261 e3649bcca3f6 opener: rename _can_symlink to _cansymlink Adrian Buehlmann <adrian@cadifra.com> parents: 14236 diff changeset	615 if self._cansymlink:
13970 d13913355390 move opener from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13962 diff changeset	616 try:
d13913355390 move opener from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13962 diff changeset	617 os.symlink(src, linkname)
25660 328739ea70c3 global: mass rewrite to use modern exception syntax Gregory Szorc <gregory.szorc@gmail.com> parents: 25658 diff changeset	618 except OSError as err:
13970 d13913355390 move opener from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13962 diff changeset	619 raise OSError(err.errno, _('could not symlink to %r: %s') %
d13913355390 move opener from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13962 diff changeset	620 (src, err.strerror), linkname)
d13913355390 move opener from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13962 diff changeset	621 else:
17768 9837cafc25b1 vfs: use self.write to write symlink placeholders Matt Mackall <mpm@selenic.com> parents: 17763 diff changeset	622 self.write(dst, src)
13971 bfeaa88b875d move canonpath from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13970 diff changeset	623
24628 a0b47885a1c5 vfs: make it possible to pass multiple path elements to join Matt Harbison <matt_harbison@yahoo.com> parents: 24582 diff changeset	624 def join(self, path, *insidef):
17161 be016e96117a localrepo: use file API via vfs while ensuring repository directory FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17157 diff changeset	625 if path:
24628 a0b47885a1c5 vfs: make it possible to pass multiple path elements to join Matt Harbison <matt_harbison@yahoo.com> parents: 24582 diff changeset	626 return os.path.join(self.base, path, *insidef)
17681 a41fd730f230 scmutil: backout 83785bb56062 (issue3643) Matt Mackall <mpm@selenic.com> parents: 17675 diff changeset	627 else:
a41fd730f230 scmutil: backout 83785bb56062 (issue3643) Matt Mackall <mpm@selenic.com> parents: 17675 diff changeset	628 return self.base
16199 8181bd808dc5 scmutil: add join method to opener to construct path relative to base Idan Kamara <idankk86@gmail.com> parents: 16198 diff changeset	629
17649 f65c6a5f256c scmutil: rename classes from "opener" to "vfs" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17561 diff changeset	630 opener = vfs
f65c6a5f256c scmutil: rename classes from "opener" to "vfs" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17561 diff changeset	631
17845 408ded42c5ec scmutil: abstract out mustaudit delegation Bryan O'Sullivan <bryano@fb.com> parents: 17821 diff changeset	632 class auditvfs(object):
408ded42c5ec scmutil: abstract out mustaudit delegation Bryan O'Sullivan <bryano@fb.com> parents: 17821 diff changeset	633 def __init__(self, vfs):
408ded42c5ec scmutil: abstract out mustaudit delegation Bryan O'Sullivan <bryano@fb.com> parents: 17821 diff changeset	634 self.vfs = vfs
408ded42c5ec scmutil: abstract out mustaudit delegation Bryan O'Sullivan <bryano@fb.com> parents: 17821 diff changeset	635
27879 52a4ad62b006 cleanup: use modern @property/@foo.setter property specification Augie Fackler <augie@google.com> parents: 27851 diff changeset	636 @property
52a4ad62b006 cleanup: use modern @property/@foo.setter property specification Augie Fackler <augie@google.com> parents: 27851 diff changeset	637 def mustaudit(self):
17845 408ded42c5ec scmutil: abstract out mustaudit delegation Bryan O'Sullivan <bryano@fb.com> parents: 17821 diff changeset	638 return self.vfs.mustaudit
408ded42c5ec scmutil: abstract out mustaudit delegation Bryan O'Sullivan <bryano@fb.com> parents: 17821 diff changeset	639
27879 52a4ad62b006 cleanup: use modern @property/@foo.setter property specification Augie Fackler <augie@google.com> parents: 27851 diff changeset	640 @mustaudit.setter
52a4ad62b006 cleanup: use modern @property/@foo.setter property specification Augie Fackler <augie@google.com> parents: 27851 diff changeset	641 def mustaudit(self, onoff):
17845 408ded42c5ec scmutil: abstract out mustaudit delegation Bryan O'Sullivan <bryano@fb.com> parents: 17821 diff changeset	642 self.vfs.mustaudit = onoff
408ded42c5ec scmutil: abstract out mustaudit delegation Bryan O'Sullivan <bryano@fb.com> parents: 17821 diff changeset	643
29727 69109052d9ac auditvfs: forward options property from nested vfs Augie Fackler <augie@google.com> parents: 29417 diff changeset	644 @property
69109052d9ac auditvfs: forward options property from nested vfs Augie Fackler <augie@google.com> parents: 29417 diff changeset	645 def options(self):
69109052d9ac auditvfs: forward options property from nested vfs Augie Fackler <augie@google.com> parents: 29417 diff changeset	646 return self.vfs.options
69109052d9ac auditvfs: forward options property from nested vfs Augie Fackler <augie@google.com> parents: 29417 diff changeset	647
69109052d9ac auditvfs: forward options property from nested vfs Augie Fackler <augie@google.com> parents: 29417 diff changeset	648 @options.setter
69109052d9ac auditvfs: forward options property from nested vfs Augie Fackler <augie@google.com> parents: 29417 diff changeset	649 def options(self, value):
69109052d9ac auditvfs: forward options property from nested vfs Augie Fackler <augie@google.com> parents: 29417 diff changeset	650 self.vfs.options = value
69109052d9ac auditvfs: forward options property from nested vfs Augie Fackler <augie@google.com> parents: 29417 diff changeset	651
17846 f42cf30873dc scmutil: add mustaudit delegation to filtervfs (issue3673) Bryan O'Sullivan <bryano@fb.com> parents: 17845 diff changeset	652 class filtervfs(abstractvfs, auditvfs):
17649 f65c6a5f256c scmutil: rename classes from "opener" to "vfs" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17561 diff changeset	653 '''Wrapper vfs for filtering filenames with a function.'''
14090 e24b5e3c2f27 add filteropener abstraction for store openers Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 14089 diff changeset	654
17846 f42cf30873dc scmutil: add mustaudit delegation to filtervfs (issue3673) Bryan O'Sullivan <bryano@fb.com> parents: 17845 diff changeset	655 def __init__(self, vfs, filter):
f42cf30873dc scmutil: add mustaudit delegation to filtervfs (issue3673) Bryan O'Sullivan <bryano@fb.com> parents: 17845 diff changeset	656 auditvfs.__init__(self, vfs)
14090 e24b5e3c2f27 add filteropener abstraction for store openers Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 14089 diff changeset	657 self._filter = filter
e24b5e3c2f27 add filteropener abstraction for store openers Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 14089 diff changeset	658
e24b5e3c2f27 add filteropener abstraction for store openers Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 14089 diff changeset	659 def __call__(self, path, args, *kwargs):
17846 f42cf30873dc scmutil: add mustaudit delegation to filtervfs (issue3673) Bryan O'Sullivan <bryano@fb.com> parents: 17845 diff changeset	660 return self.vfs(self._filter(path), args, *kwargs)
14090 e24b5e3c2f27 add filteropener abstraction for store openers Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 14089 diff changeset	661
24628 a0b47885a1c5 vfs: make it possible to pass multiple path elements to join Matt Harbison <matt_harbison@yahoo.com> parents: 24582 diff changeset	662 def join(self, path, *insidef):
17725 ffd589d4b785 vfs: define "join()" in each classes derived from "abstractvfs" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17723 diff changeset	663 if path:
24628 a0b47885a1c5 vfs: make it possible to pass multiple path elements to join Matt Harbison <matt_harbison@yahoo.com> parents: 24582 diff changeset	664 return self.vfs.join(self._filter(self.vfs.reljoin(path, *insidef)))
17725 ffd589d4b785 vfs: define "join()" in each classes derived from "abstractvfs" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17723 diff changeset	665 else:
17846 f42cf30873dc scmutil: add mustaudit delegation to filtervfs (issue3673) Bryan O'Sullivan <bryano@fb.com> parents: 17845 diff changeset	666 return self.vfs.join(path)
17725 ffd589d4b785 vfs: define "join()" in each classes derived from "abstractvfs" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17723 diff changeset	667
17649 f65c6a5f256c scmutil: rename classes from "opener" to "vfs" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17561 diff changeset	668 filteropener = filtervfs
f65c6a5f256c scmutil: rename classes from "opener" to "vfs" FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17561 diff changeset	669
18213 c38a62af000e vfs: add a read only vfs Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18206 diff changeset	670 class readonlyvfs(abstractvfs, auditvfs):
c38a62af000e vfs: add a read only vfs Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18206 diff changeset	671 '''Wrapper vfs preventing any writing.'''
c38a62af000e vfs: add a read only vfs Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18206 diff changeset	672
c38a62af000e vfs: add a read only vfs Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18206 diff changeset	673 def __init__(self, vfs):
c38a62af000e vfs: add a read only vfs Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18206 diff changeset	674 auditvfs.__init__(self, vfs)
c38a62af000e vfs: add a read only vfs Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18206 diff changeset	675
c38a62af000e vfs: add a read only vfs Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18206 diff changeset	676 def __call__(self, path, mode='r', args, *kw):
c38a62af000e vfs: add a read only vfs Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18206 diff changeset	677 if mode not in ('r', 'rb'):
29389 98e8313dcd9e i18n: translate abort messages liscju <piotr.listkiewicz@gmail.com> parents: 29373 diff changeset	678 raise error.Abort(_('this vfs is read only'))
18213 c38a62af000e vfs: add a read only vfs Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18206 diff changeset	679 return self.vfs(path, mode, args, *kw)
c38a62af000e vfs: add a read only vfs Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18206 diff changeset	680
26156 a112fffdb632 scmutil.readonlyvfs: implement join Siddharth Agarwal <sid0@fb.com> parents: 26098 diff changeset	681 def join(self, path, *insidef):
a112fffdb632 scmutil.readonlyvfs: implement join Siddharth Agarwal <sid0@fb.com> parents: 26098 diff changeset	682 return self.vfs.join(path, *insidef)
18213 c38a62af000e vfs: add a read only vfs Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18206 diff changeset	683
13975 938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	684 def walkrepos(path, followsym=False, seen_dirs=None, recurse=False):
17104 5a9acb0b2086 help: improve hgweb help Mads Kiilerich <mads@kiilerich.com> parents: 17037 diff changeset	685 '''yield every hg repository under path, always recursively.
5a9acb0b2086 help: improve hgweb help Mads Kiilerich <mads@kiilerich.com> parents: 17037 diff changeset	686 The recurse flag will only control recursion into repo working dirs'''
13975 938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	687 def errhandler(err):
938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	688 if err.filename == path:
938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	689 raise err
14961 5523529bd1af walkrepos: use getattr instead of hasattr for samestat Augie Fackler <durin42@gmail.com> parents: 14928 diff changeset	690 samestat = getattr(os.path, 'samestat', None)
5523529bd1af walkrepos: use getattr instead of hasattr for samestat Augie Fackler <durin42@gmail.com> parents: 14928 diff changeset	691 if followsym and samestat is not None:
14227 94985b5a8278 scmutil: rename local function _add_dir_if_not_there Adrian Buehlmann <adrian@cadifra.com> parents: 14226 diff changeset	692 def adddir(dirlst, dirname):
13975 938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	693 match = False
938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	694 dirstat = os.stat(dirname)
938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	695 for lstdirstat in dirlst:
938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	696 if samestat(dirstat, lstdirstat):
938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	697 match = True
938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	698 break
938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	699 if not match:
938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	700 dirlst.append(dirstat)
938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	701 return not match
938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	702 else:
938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	703 followsym = False
938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	704
938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	705 if (seen_dirs is None) and followsym:
938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	706 seen_dirs = []
14227 94985b5a8278 scmutil: rename local function _add_dir_if_not_there Adrian Buehlmann <adrian@cadifra.com> parents: 14226 diff changeset	707 adddir(seen_dirs, path)
13975 938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	708 for root, dirs, files in os.walk(path, topdown=True, onerror=errhandler):
938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	709 dirs.sort()
938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	710 if '.hg' in dirs:
938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	711 yield root # found a repository
938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	712 qroot = os.path.join(root, '.hg', 'patches')
938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	713 if os.path.isdir(os.path.join(qroot, '.hg')):
938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	714 yield qroot # we have a patch queue repo here
938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	715 if recurse:
938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	716 # avoid recursing inside the .hg directory
938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	717 dirs.remove('.hg')
938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	718 else:
938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	719 dirs[:] = [] # don't descend further
938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	720 elif followsym:
938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	721 newdirs = []
938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	722 for d in dirs:
938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	723 fname = os.path.join(root, d)
14227 94985b5a8278 scmutil: rename local function _add_dir_if_not_there Adrian Buehlmann <adrian@cadifra.com> parents: 14226 diff changeset	724 if adddir(seen_dirs, fname):
13975 938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	725 if os.path.islink(fname):
938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	726 for hgname in walkrepos(fname, True, seen_dirs):
938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	727 yield hgname
938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	728 else:
938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	729 newdirs.append(d)
938fbeacac84 move walkrepos from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13974 diff changeset	730 dirs[:] = newdirs
13984 af60153b5e3b move rcpath from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13975 diff changeset	731
14224 f4189866c76c rename scmutil.os_rcpath to osrcpath Adrian Buehlmann <adrian@cadifra.com> parents: 14220 diff changeset	732 def osrcpath():
13985 26335a817dd0 move os_rcpath from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13984 diff changeset	733 '''return default os-specific hgrc search path'''
23142 c4ce077588d0 config: introduce "built-in" default configuration settings in default.d Mads Kiilerich <madski@unity3d.com> parents: 22915 diff changeset	734 path = []
c4ce077588d0 config: introduce "built-in" default configuration settings in default.d Mads Kiilerich <madski@unity3d.com> parents: 22915 diff changeset	735 defaultpath = os.path.join(util.datapath, 'default.d')
c4ce077588d0 config: introduce "built-in" default configuration settings in default.d Mads Kiilerich <madski@unity3d.com> parents: 22915 diff changeset	736 if os.path.isdir(defaultpath):
c4ce077588d0 config: introduce "built-in" default configuration settings in default.d Mads Kiilerich <madski@unity3d.com> parents: 22915 diff changeset	737 for f, kind in osutil.listdir(defaultpath):
c4ce077588d0 config: introduce "built-in" default configuration settings in default.d Mads Kiilerich <madski@unity3d.com> parents: 22915 diff changeset	738 if f.endswith('.rc'):
c4ce077588d0 config: introduce "built-in" default configuration settings in default.d Mads Kiilerich <madski@unity3d.com> parents: 22915 diff changeset	739 path.append(os.path.join(defaultpath, f))
c4ce077588d0 config: introduce "built-in" default configuration settings in default.d Mads Kiilerich <madski@unity3d.com> parents: 22915 diff changeset	740 path.extend(systemrcpath())
14226 73cca883370d rename scmutil.user_rcpath to userrcpath Adrian Buehlmann <adrian@cadifra.com> parents: 14225 diff changeset	741 path.extend(userrcpath())
13985 26335a817dd0 move os_rcpath from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13984 diff changeset	742 path = [os.path.normpath(f) for f in path]
26335a817dd0 move os_rcpath from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13984 diff changeset	743 return path
26335a817dd0 move os_rcpath from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13984 diff changeset	744
13984 af60153b5e3b move rcpath from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13975 diff changeset	745 _rcpath = None
af60153b5e3b move rcpath from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13975 diff changeset	746
af60153b5e3b move rcpath from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13975 diff changeset	747 def rcpath():
af60153b5e3b move rcpath from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13975 diff changeset	748 '''return hgrc search path. if env var HGRCPATH is set, use it.
af60153b5e3b move rcpath from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13975 diff changeset	749 for each item in path, if directory, use files ending in .rc,
af60153b5e3b move rcpath from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13975 diff changeset	750 else use item.
af60153b5e3b move rcpath from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13975 diff changeset	751 make HGRCPATH empty to only look in .hg/hgrc of current repo.
af60153b5e3b move rcpath from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13975 diff changeset	752 if no HGRCPATH, use default os-specific path.'''
af60153b5e3b move rcpath from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13975 diff changeset	753 global _rcpath
af60153b5e3b move rcpath from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13975 diff changeset	754 if _rcpath is None:
30109 96a2278ee732 py3: use encoding.environ instead of os.environ Pulkit Goyal <7895pulkit@gmail.com> parents: 30000 diff changeset	755 if 'HGRCPATH' in encoding.environ:
13984 af60153b5e3b move rcpath from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13975 diff changeset	756 _rcpath = []
af60153b5e3b move rcpath from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13975 diff changeset	757 for p in os.environ['HGRCPATH'].split(os.pathsep):
af60153b5e3b move rcpath from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13975 diff changeset	758 if not p:
af60153b5e3b move rcpath from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13975 diff changeset	759 continue
af60153b5e3b move rcpath from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13975 diff changeset	760 p = util.expandpath(p)
af60153b5e3b move rcpath from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13975 diff changeset	761 if os.path.isdir(p):
af60153b5e3b move rcpath from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13975 diff changeset	762 for f, kind in osutil.listdir(p):
af60153b5e3b move rcpath from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13975 diff changeset	763 if f.endswith('.rc'):
af60153b5e3b move rcpath from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13975 diff changeset	764 _rcpath.append(os.path.join(p, f))
af60153b5e3b move rcpath from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13975 diff changeset	765 else:
af60153b5e3b move rcpath from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13975 diff changeset	766 _rcpath.append(p)
af60153b5e3b move rcpath from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13975 diff changeset	767 else:
14224 f4189866c76c rename scmutil.os_rcpath to osrcpath Adrian Buehlmann <adrian@cadifra.com> parents: 14220 diff changeset	768 _rcpath = osrcpath()
13984 af60153b5e3b move rcpath from util to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13975 diff changeset	769 return _rcpath
13986 9c374cf76b7d move system_rcpath and user_rcpath to scmutil Adrian Buehlmann <adrian@cadifra.com> parents: 13985 diff changeset	770
25739 3dabc9b7494a changeset_printer: use node.wdirrev to calculate meaningful parentrevs Yuya Nishihara <yuya@tcha.org> parents: 25660 diff changeset	771 def intrev(rev):
24582 56fff44cce98 scmutil: add function to help handling workingctx in arithmetic operation Yuya Nishihara <yuya@tcha.org> parents: 24447 diff changeset	772 """Return integer for a given revision that can be used in comparison or
56fff44cce98 scmutil: add function to help handling workingctx in arithmetic operation Yuya Nishihara <yuya@tcha.org> parents: 24447 diff changeset	773 arithmetic operation"""
56fff44cce98 scmutil: add function to help handling workingctx in arithmetic operation Yuya Nishihara <yuya@tcha.org> parents: 24447 diff changeset	774 if rev is None:
25739 3dabc9b7494a changeset_printer: use node.wdirrev to calculate meaningful parentrevs Yuya Nishihara <yuya@tcha.org> parents: 25660 diff changeset	775 return wdirrev
24582 56fff44cce98 scmutil: add function to help handling workingctx in arithmetic operation Yuya Nishihara <yuya@tcha.org> parents: 24447 diff changeset	776 return rev
56fff44cce98 scmutil: add function to help handling workingctx in arithmetic operation Yuya Nishihara <yuya@tcha.org> parents: 24447 diff changeset	777
14319 b33f3e35efb0 scmutil: move revsingle/pair/range from cmdutil Matt Mackall <mpm@selenic.com> parents: 14261 diff changeset	778 def revsingle(repo, revspec, default='.'):
19509 8963a706e075 revsingle: fix silly API issue (issue2992) Matt Mackall <mpm@selenic.com> parents: 19154 diff changeset	779 if not revspec and revspec != 0:
14319 b33f3e35efb0 scmutil: move revsingle/pair/range from cmdutil Matt Mackall <mpm@selenic.com> parents: 14261 diff changeset	780 return repo[default]
b33f3e35efb0 scmutil: move revsingle/pair/range from cmdutil Matt Mackall <mpm@selenic.com> parents: 14261 diff changeset	781
b33f3e35efb0 scmutil: move revsingle/pair/range from cmdutil Matt Mackall <mpm@selenic.com> parents: 14261 diff changeset	782 l = revrange(repo, [revspec])
22814 8110405cf8ae revset-limit: use boolean testing instead of `len(revs) < 1` Pierre-Yves David <pierre-yves.david@fb.com> parents: 21799 diff changeset	783 if not l:
26587 56b2bcea2529 error: get Abort from 'error' instead of 'util' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26491 diff changeset	784 raise error.Abort(_('empty revision set'))
22815 4f81470e83bf revsingle: use `last` instead of direct indexing Pierre-Yves David <pierre-yves.david@fb.com> parents: 22814 diff changeset	785 return repo[l.last()]
14319 b33f3e35efb0 scmutil: move revsingle/pair/range from cmdutil Matt Mackall <mpm@selenic.com> parents: 14261 diff changeset	786
26020 cc3a30ff9490 revpair: restrict odd-range handling to top-level x:y expression (issue4774) Yuya Nishihara <yuya@tcha.org> parents: 25928 diff changeset	787 def _pairspec(revspec):
cc3a30ff9490 revpair: restrict odd-range handling to top-level x:y expression (issue4774) Yuya Nishihara <yuya@tcha.org> parents: 25928 diff changeset	788 tree = revset.parse(revspec)
cc3a30ff9490 revpair: restrict odd-range handling to top-level x:y expression (issue4774) Yuya Nishihara <yuya@tcha.org> parents: 25928 diff changeset	789 return tree and tree[0] in ('range', 'rangepre', 'rangepost', 'rangeall')
cc3a30ff9490 revpair: restrict odd-range handling to top-level x:y expression (issue4774) Yuya Nishihara <yuya@tcha.org> parents: 25928 diff changeset	790
14319 b33f3e35efb0 scmutil: move revsingle/pair/range from cmdutil Matt Mackall <mpm@selenic.com> parents: 14261 diff changeset	791 def revpair(repo, revs):
b33f3e35efb0 scmutil: move revsingle/pair/range from cmdutil Matt Mackall <mpm@selenic.com> parents: 14261 diff changeset	792 if not revs:
b33f3e35efb0 scmutil: move revsingle/pair/range from cmdutil Matt Mackall <mpm@selenic.com> parents: 14261 diff changeset	793 return repo.dirstate.p1(), None
b33f3e35efb0 scmutil: move revsingle/pair/range from cmdutil Matt Mackall <mpm@selenic.com> parents: 14261 diff changeset	794
b33f3e35efb0 scmutil: move revsingle/pair/range from cmdutil Matt Mackall <mpm@selenic.com> parents: 14261 diff changeset	795 l = revrange(repo, revs)
b33f3e35efb0 scmutil: move revsingle/pair/range from cmdutil Matt Mackall <mpm@selenic.com> parents: 14261 diff changeset	796
20862 97b2f26dfc43 revpair: smartset compatibility Pierre-Yves David <pierre-yves.david@fb.com> parents: 20820 diff changeset	797 if not l:
97b2f26dfc43 revpair: smartset compatibility Pierre-Yves David <pierre-yves.david@fb.com> parents: 20820 diff changeset	798 first = second = None
97b2f26dfc43 revpair: smartset compatibility Pierre-Yves David <pierre-yves.david@fb.com> parents: 20820 diff changeset	799 elif l.isascending():
97b2f26dfc43 revpair: smartset compatibility Pierre-Yves David <pierre-yves.david@fb.com> parents: 20820 diff changeset	800 first = l.min()
97b2f26dfc43 revpair: smartset compatibility Pierre-Yves David <pierre-yves.david@fb.com> parents: 20820 diff changeset	801 second = l.max()
97b2f26dfc43 revpair: smartset compatibility Pierre-Yves David <pierre-yves.david@fb.com> parents: 20820 diff changeset	802 elif l.isdescending():
97b2f26dfc43 revpair: smartset compatibility Pierre-Yves David <pierre-yves.david@fb.com> parents: 20820 diff changeset	803 first = l.max()
97b2f26dfc43 revpair: smartset compatibility Pierre-Yves David <pierre-yves.david@fb.com> parents: 20820 diff changeset	804 second = l.min()
97b2f26dfc43 revpair: smartset compatibility Pierre-Yves David <pierre-yves.david@fb.com> parents: 20820 diff changeset	805 else:
22816 20d998395ee7 revpair: use `first` and `last` instead of direct indexing Pierre-Yves David <pierre-yves.david@fb.com> parents: 22815 diff changeset	806 first = l.first()
20d998395ee7 revpair: use `first` and `last` instead of direct indexing Pierre-Yves David <pierre-yves.david@fb.com> parents: 22815 diff changeset	807 second = l.last()
20862 97b2f26dfc43 revpair: smartset compatibility Pierre-Yves David <pierre-yves.david@fb.com> parents: 20820 diff changeset	808
97b2f26dfc43 revpair: smartset compatibility Pierre-Yves David <pierre-yves.david@fb.com> parents: 20820 diff changeset	809 if first is None:
26587 56b2bcea2529 error: get Abort from 'error' instead of 'util' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26491 diff changeset	810 raise error.Abort(_('empty revision range'))
26836 88c4e97b9669 scmutil: abort if an empty revision is given to revpair() Matt Harbison <matt_harbison@yahoo.com> parents: 26587 diff changeset	811 if (first == second and len(revs) >= 2
88c4e97b9669 scmutil: abort if an empty revision is given to revpair() Matt Harbison <matt_harbison@yahoo.com> parents: 26587 diff changeset	812 and not all(revrange(repo, [r]) for r in revs)):
88c4e97b9669 scmutil: abort if an empty revision is given to revpair() Matt Harbison <matt_harbison@yahoo.com> parents: 26587 diff changeset	813 raise error.Abort(_('empty revision on one side of range'))
14319 b33f3e35efb0 scmutil: move revsingle/pair/range from cmdutil Matt Mackall <mpm@selenic.com> parents: 14261 diff changeset	814
26020 cc3a30ff9490 revpair: restrict odd-range handling to top-level x:y expression (issue4774) Yuya Nishihara <yuya@tcha.org> parents: 25928 diff changeset	815 # if top-level is range expression, the result must always be a pair
cc3a30ff9490 revpair: restrict odd-range handling to top-level x:y expression (issue4774) Yuya Nishihara <yuya@tcha.org> parents: 25928 diff changeset	816 if first == second and len(revs) == 1 and not _pairspec(revs[0]):
20862 97b2f26dfc43 revpair: smartset compatibility Pierre-Yves David <pierre-yves.david@fb.com> parents: 20820 diff changeset	817 return repo.lookup(first), None
14319 b33f3e35efb0 scmutil: move revsingle/pair/range from cmdutil Matt Mackall <mpm@selenic.com> parents: 14261 diff changeset	818
20862 97b2f26dfc43 revpair: smartset compatibility Pierre-Yves David <pierre-yves.david@fb.com> parents: 20820 diff changeset	819 return repo.lookup(first), repo.lookup(second)
14319 b33f3e35efb0 scmutil: move revsingle/pair/range from cmdutil Matt Mackall <mpm@selenic.com> parents: 14261 diff changeset	820
29417 526b027b0130 scmutil: improve documentation of revset APIs Gregory Szorc <gregory.szorc@gmail.com> parents: 29389 diff changeset	821 def revrange(repo, specs):
526b027b0130 scmutil: improve documentation of revset APIs Gregory Szorc <gregory.szorc@gmail.com> parents: 29389 diff changeset	822 """Execute 1 to many revsets and return the union.
526b027b0130 scmutil: improve documentation of revset APIs Gregory Szorc <gregory.szorc@gmail.com> parents: 29389 diff changeset	823
526b027b0130 scmutil: improve documentation of revset APIs Gregory Szorc <gregory.szorc@gmail.com> parents: 29389 diff changeset	824 This is the preferred mechanism for executing revsets using user-specified
526b027b0130 scmutil: improve documentation of revset APIs Gregory Szorc <gregory.szorc@gmail.com> parents: 29389 diff changeset	825 config options, such as revset aliases.
526b027b0130 scmutil: improve documentation of revset APIs Gregory Szorc <gregory.szorc@gmail.com> parents: 29389 diff changeset	826
526b027b0130 scmutil: improve documentation of revset APIs Gregory Szorc <gregory.szorc@gmail.com> parents: 29389 diff changeset	827 The revsets specified by ``specs`` will be executed via a chained ``OR``
526b027b0130 scmutil: improve documentation of revset APIs Gregory Szorc <gregory.szorc@gmail.com> parents: 29389 diff changeset	828 expression. If ``specs`` is empty, an empty result is returned.
526b027b0130 scmutil: improve documentation of revset APIs Gregory Szorc <gregory.szorc@gmail.com> parents: 29389 diff changeset	829
526b027b0130 scmutil: improve documentation of revset APIs Gregory Szorc <gregory.szorc@gmail.com> parents: 29389 diff changeset	830 ``specs`` can contain integers, in which case they are assumed to be
526b027b0130 scmutil: improve documentation of revset APIs Gregory Szorc <gregory.szorc@gmail.com> parents: 29389 diff changeset	831 revision numbers.
526b027b0130 scmutil: improve documentation of revset APIs Gregory Szorc <gregory.szorc@gmail.com> parents: 29389 diff changeset	832
526b027b0130 scmutil: improve documentation of revset APIs Gregory Szorc <gregory.szorc@gmail.com> parents: 29389 diff changeset	833 It is assumed the revsets are already formatted. If you have arguments
526b027b0130 scmutil: improve documentation of revset APIs Gregory Szorc <gregory.szorc@gmail.com> parents: 29389 diff changeset	834 that need to be expanded in the revset, call ``revset.formatspec()``
526b027b0130 scmutil: improve documentation of revset APIs Gregory Szorc <gregory.szorc@gmail.com> parents: 29389 diff changeset	835 and pass the result as an element of ``specs``.
526b027b0130 scmutil: improve documentation of revset APIs Gregory Szorc <gregory.szorc@gmail.com> parents: 29389 diff changeset	836
526b027b0130 scmutil: improve documentation of revset APIs Gregory Szorc <gregory.szorc@gmail.com> parents: 29389 diff changeset	837 Specifying a single revset is allowed.
526b027b0130 scmutil: improve documentation of revset APIs Gregory Szorc <gregory.szorc@gmail.com> parents: 29389 diff changeset	838
526b027b0130 scmutil: improve documentation of revset APIs Gregory Szorc <gregory.szorc@gmail.com> parents: 29389 diff changeset	839 Returns a ``revset.abstractsmartset`` which is a list-like interface over
526b027b0130 scmutil: improve documentation of revset APIs Gregory Szorc <gregory.szorc@gmail.com> parents: 29389 diff changeset	840 integer revisions.
526b027b0130 scmutil: improve documentation of revset APIs Gregory Szorc <gregory.szorc@gmail.com> parents: 29389 diff changeset	841 """
25928 4ee4f7415095 revrange: evaluate all revset specs at once Yuya Nishihara <yuya@tcha.org> parents: 25904 diff changeset	842 allspecs = []
29417 526b027b0130 scmutil: improve documentation of revset APIs Gregory Szorc <gregory.szorc@gmail.com> parents: 29389 diff changeset	843 for spec in specs:
25904 fbaa2de13cf6 revrange: drop old-style parser in favor of revset (API) Yuya Nishihara <yuya@tcha.org> parents: 25772 diff changeset	844 if isinstance(spec, int):
fbaa2de13cf6 revrange: drop old-style parser in favor of revset (API) Yuya Nishihara <yuya@tcha.org> parents: 25772 diff changeset	845 spec = revset.formatspec('rev(%d)', spec)
25928 4ee4f7415095 revrange: evaluate all revset specs at once Yuya Nishihara <yuya@tcha.org> parents: 25904 diff changeset	846 allspecs.append(spec)
4ee4f7415095 revrange: evaluate all revset specs at once Yuya Nishihara <yuya@tcha.org> parents: 25904 diff changeset	847 m = revset.matchany(repo.ui, allspecs, repo)
4ee4f7415095 revrange: evaluate all revset specs at once Yuya Nishihara <yuya@tcha.org> parents: 25904 diff changeset	848 return m(repo)
14320 3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	849
26433 3ad41638b4b4 changeset_printer: move _meaningful_parentrevs() to scmutil Yuya Nishihara <yuya@tcha.org> parents: 26421 diff changeset	850 def meaningfulparents(repo, ctx):
3ad41638b4b4 changeset_printer: move _meaningful_parentrevs() to scmutil Yuya Nishihara <yuya@tcha.org> parents: 26421 diff changeset	851 """Return list of meaningful (or all if debug) parentrevs for rev.
3ad41638b4b4 changeset_printer: move _meaningful_parentrevs() to scmutil Yuya Nishihara <yuya@tcha.org> parents: 26421 diff changeset	852
3ad41638b4b4 changeset_printer: move _meaningful_parentrevs() to scmutil Yuya Nishihara <yuya@tcha.org> parents: 26421 diff changeset	853 For merges (two non-nullrev revisions) both parents are meaningful.
3ad41638b4b4 changeset_printer: move _meaningful_parentrevs() to scmutil Yuya Nishihara <yuya@tcha.org> parents: 26421 diff changeset	854 Otherwise the first parent revision is considered meaningful if it
3ad41638b4b4 changeset_printer: move _meaningful_parentrevs() to scmutil Yuya Nishihara <yuya@tcha.org> parents: 26421 diff changeset	855 is not the preceding revision.
3ad41638b4b4 changeset_printer: move _meaningful_parentrevs() to scmutil Yuya Nishihara <yuya@tcha.org> parents: 26421 diff changeset	856 """
3ad41638b4b4 changeset_printer: move _meaningful_parentrevs() to scmutil Yuya Nishihara <yuya@tcha.org> parents: 26421 diff changeset	857 parents = ctx.parents()
3ad41638b4b4 changeset_printer: move _meaningful_parentrevs() to scmutil Yuya Nishihara <yuya@tcha.org> parents: 26421 diff changeset	858 if len(parents) > 1:
3ad41638b4b4 changeset_printer: move _meaningful_parentrevs() to scmutil Yuya Nishihara <yuya@tcha.org> parents: 26421 diff changeset	859 return parents
3ad41638b4b4 changeset_printer: move _meaningful_parentrevs() to scmutil Yuya Nishihara <yuya@tcha.org> parents: 26421 diff changeset	860 if repo.ui.debugflag:
3ad41638b4b4 changeset_printer: move _meaningful_parentrevs() to scmutil Yuya Nishihara <yuya@tcha.org> parents: 26421 diff changeset	861 return [parents[0], repo['null']]
3ad41638b4b4 changeset_printer: move _meaningful_parentrevs() to scmutil Yuya Nishihara <yuya@tcha.org> parents: 26421 diff changeset	862 if parents[0].rev() >= intrev(ctx.rev()) - 1:
3ad41638b4b4 changeset_printer: move _meaningful_parentrevs() to scmutil Yuya Nishihara <yuya@tcha.org> parents: 26421 diff changeset	863 return []
3ad41638b4b4 changeset_printer: move _meaningful_parentrevs() to scmutil Yuya Nishihara <yuya@tcha.org> parents: 26421 diff changeset	864 return parents
3ad41638b4b4 changeset_printer: move _meaningful_parentrevs() to scmutil Yuya Nishihara <yuya@tcha.org> parents: 26421 diff changeset	865
14320 3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	866 def expandpats(pats):
21111 9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 20980 diff changeset	867 '''Expand bare globs when running on windows.
9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 20980 diff changeset	868 On posix we assume it already has already been done by sh.'''
14320 3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	869 if not util.expandglobs:
3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	870 return list(pats)
3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	871 ret = []
21111 9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 20980 diff changeset	872 for kindpat in pats:
9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 20980 diff changeset	873 kind, pat = matchmod._patsplit(kindpat, None)
14320 3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	874 if kind is None:
3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	875 try:
21111 9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 20980 diff changeset	876 globbed = glob.glob(pat)
14320 3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	877 except re.error:
21111 9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 20980 diff changeset	878 globbed = [pat]
14320 3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	879 if globbed:
3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	880 ret.extend(globbed)
3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	881 continue
21111 9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 20980 diff changeset	882 ret.append(kindpat)
14320 3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	883 return ret
3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	884
26326 58218b0e6005 match: remove a mutable default argument Pierre-Yves David <pierre-yves.david@fb.com> parents: 26325 diff changeset	885 def matchandpats(ctx, pats=(), opts=None, globbed=False, default='relpath',
25467 f64dbe06f3d0 scmutil: add an optional parameter to matcher factories for a bad() override Matt Harbison <matt_harbison@yahoo.com> parents: 25466 diff changeset	886 badfn=None):
21111 9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 20980 diff changeset	887 '''Return a matcher and the patterns that were used.
25467 f64dbe06f3d0 scmutil: add an optional parameter to matcher factories for a bad() override Matt Harbison <matt_harbison@yahoo.com> parents: 25466 diff changeset	888 The matcher will warn about bad matches, unless an alternate badfn callback
f64dbe06f3d0 scmutil: add an optional parameter to matcher factories for a bad() override Matt Harbison <matt_harbison@yahoo.com> parents: 25466 diff changeset	889 is provided.'''
14320 3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	890 if pats == ("",):
3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	891 pats = []
26326 58218b0e6005 match: remove a mutable default argument Pierre-Yves David <pierre-yves.david@fb.com> parents: 26325 diff changeset	892 if opts is None:
58218b0e6005 match: remove a mutable default argument Pierre-Yves David <pierre-yves.david@fb.com> parents: 26325 diff changeset	893 opts = {}
14320 3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	894 if not globbed and default == 'relpath':
3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	895 pats = expandpats(pats or [])
14670 19197fa4c41c scmutil: match now accepts a context or a repo Matt Mackall <mpm@selenic.com> parents: 14669 diff changeset	896
25467 f64dbe06f3d0 scmutil: add an optional parameter to matcher factories for a bad() override Matt Harbison <matt_harbison@yahoo.com> parents: 25466 diff changeset	897 def bad(f, msg):
24338 ca1365078c86 scmutil: replace 'ctx._repo' with 'ctx.repo()' Matt Harbison <matt_harbison@yahoo.com> parents: 24175 diff changeset	898 ctx.repo().ui.warn("%s: %s\n" % (m.rel(f), msg))
25466 007a1d53f7c3 scmutil: use the optional badfn argument when building a matcher Matt Harbison <matt_harbison@yahoo.com> parents: 25434 diff changeset	899
25467 f64dbe06f3d0 scmutil: add an optional parameter to matcher factories for a bad() override Matt Harbison <matt_harbison@yahoo.com> parents: 25466 diff changeset	900 if badfn is None:
f64dbe06f3d0 scmutil: add an optional parameter to matcher factories for a bad() override Matt Harbison <matt_harbison@yahoo.com> parents: 25466 diff changeset	901 badfn = bad
f64dbe06f3d0 scmutil: add an optional parameter to matcher factories for a bad() override Matt Harbison <matt_harbison@yahoo.com> parents: 25466 diff changeset	902
25466 007a1d53f7c3 scmutil: use the optional badfn argument when building a matcher Matt Harbison <matt_harbison@yahoo.com> parents: 25434 diff changeset	903 m = ctx.match(pats, opts.get('include'), opts.get('exclude'),
007a1d53f7c3 scmutil: use the optional badfn argument when building a matcher Matt Harbison <matt_harbison@yahoo.com> parents: 25434 diff changeset	904 default, listsubrepos=opts.get('subrepos'), badfn=badfn)
007a1d53f7c3 scmutil: use the optional badfn argument when building a matcher Matt Harbison <matt_harbison@yahoo.com> parents: 25434 diff changeset	905
24447 d44d53bc9a1e matcher: make e.g. 'relpath:.' lead to fast paths Martin von Zweigbergk <martinvonz@google.com> parents: 24338 diff changeset	906 if m.always():
d44d53bc9a1e matcher: make e.g. 'relpath:.' lead to fast paths Martin von Zweigbergk <martinvonz@google.com> parents: 24338 diff changeset	907 pats = []
16171 336e61875335 graphlog: restore FILE glob expansion on Windows Patrick Mezard <patrick@mezard.eu> parents: 16167 diff changeset	908 return m, pats
336e61875335 graphlog: restore FILE glob expansion on Windows Patrick Mezard <patrick@mezard.eu> parents: 16167 diff changeset	909
26328 188c1e9506f5 match: remove a mutable default argument Pierre-Yves David <pierre-yves.david@fb.com> parents: 26327 diff changeset	910 def match(ctx, pats=(), opts=None, globbed=False, default='relpath',
188c1e9506f5 match: remove a mutable default argument Pierre-Yves David <pierre-yves.david@fb.com> parents: 26327 diff changeset	911 badfn=None):
21111 9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 20980 diff changeset	912 '''Return a matcher that will warn about bad matches.'''
25467 f64dbe06f3d0 scmutil: add an optional parameter to matcher factories for a bad() override Matt Harbison <matt_harbison@yahoo.com> parents: 25466 diff changeset	913 return matchandpats(ctx, pats, opts, globbed, default, badfn=badfn)[0]
14320 3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	914
3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	915 def matchall(repo):
21111 9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 20980 diff changeset	916 '''Return a matcher that will efficiently match everything.'''
14320 3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	917 return matchmod.always(repo.root, repo.getcwd())
3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	918
25467 f64dbe06f3d0 scmutil: add an optional parameter to matcher factories for a bad() override Matt Harbison <matt_harbison@yahoo.com> parents: 25466 diff changeset	919 def matchfiles(repo, files, badfn=None):
21111 9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 20980 diff changeset	920 '''Return a matcher that will efficiently match exactly these files.'''
25467 f64dbe06f3d0 scmutil: add an optional parameter to matcher factories for a bad() override Matt Harbison <matt_harbison@yahoo.com> parents: 25466 diff changeset	921 return matchmod.exact(repo.root, repo.getcwd(), files, badfn=badfn)
14320 3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	922
27651 07fc2f2134ba origpath: move from cmdutil to scmutil Siddharth Agarwal <sid0@fb.com> parents: 27610 diff changeset	923 def origpath(ui, repo, filepath):
07fc2f2134ba origpath: move from cmdutil to scmutil Siddharth Agarwal <sid0@fb.com> parents: 27610 diff changeset	924 '''customize where .orig files are created
07fc2f2134ba origpath: move from cmdutil to scmutil Siddharth Agarwal <sid0@fb.com> parents: 27610 diff changeset	925
07fc2f2134ba origpath: move from cmdutil to scmutil Siddharth Agarwal <sid0@fb.com> parents: 27610 diff changeset	926 Fetch user defined path from config file: [ui] origbackuppath = <path>
07fc2f2134ba origpath: move from cmdutil to scmutil Siddharth Agarwal <sid0@fb.com> parents: 27610 diff changeset	927 Fall back to default (filepath) if not specified
07fc2f2134ba origpath: move from cmdutil to scmutil Siddharth Agarwal <sid0@fb.com> parents: 27610 diff changeset	928 '''
07fc2f2134ba origpath: move from cmdutil to scmutil Siddharth Agarwal <sid0@fb.com> parents: 27610 diff changeset	929 origbackuppath = ui.config('ui', 'origbackuppath', None)
07fc2f2134ba origpath: move from cmdutil to scmutil Siddharth Agarwal <sid0@fb.com> parents: 27610 diff changeset	930 if origbackuppath is None:
07fc2f2134ba origpath: move from cmdutil to scmutil Siddharth Agarwal <sid0@fb.com> parents: 27610 diff changeset	931 return filepath + ".orig"
07fc2f2134ba origpath: move from cmdutil to scmutil Siddharth Agarwal <sid0@fb.com> parents: 27610 diff changeset	932
07fc2f2134ba origpath: move from cmdutil to scmutil Siddharth Agarwal <sid0@fb.com> parents: 27610 diff changeset	933 filepathfromroot = os.path.relpath(filepath, start=repo.root)
07fc2f2134ba origpath: move from cmdutil to scmutil Siddharth Agarwal <sid0@fb.com> parents: 27610 diff changeset	934 fullorigpath = repo.wjoin(origbackuppath, filepathfromroot)
07fc2f2134ba origpath: move from cmdutil to scmutil Siddharth Agarwal <sid0@fb.com> parents: 27610 diff changeset	935
07fc2f2134ba origpath: move from cmdutil to scmutil Siddharth Agarwal <sid0@fb.com> parents: 27610 diff changeset	936 origbackupdir = repo.vfs.dirname(fullorigpath)
07fc2f2134ba origpath: move from cmdutil to scmutil Siddharth Agarwal <sid0@fb.com> parents: 27610 diff changeset	937 if not repo.vfs.exists(origbackupdir):
07fc2f2134ba origpath: move from cmdutil to scmutil Siddharth Agarwal <sid0@fb.com> parents: 27610 diff changeset	938 ui.note(_('creating directory: %s\n') % origbackupdir)
07fc2f2134ba origpath: move from cmdutil to scmutil Siddharth Agarwal <sid0@fb.com> parents: 27610 diff changeset	939 util.makedirs(origbackupdir)
07fc2f2134ba origpath: move from cmdutil to scmutil Siddharth Agarwal <sid0@fb.com> parents: 27610 diff changeset	940
07fc2f2134ba origpath: move from cmdutil to scmutil Siddharth Agarwal <sid0@fb.com> parents: 27610 diff changeset	941 return fullorigpath + ".orig"
07fc2f2134ba origpath: move from cmdutil to scmutil Siddharth Agarwal <sid0@fb.com> parents: 27610 diff changeset	942
26329 d9537ce64f3a addremove: remove a mutable default argument Pierre-Yves David <pierre-yves.david@fb.com> parents: 26328 diff changeset	943 def addremove(repo, matcher, prefix, opts=None, dry_run=None, similarity=None):
d9537ce64f3a addremove: remove a mutable default argument Pierre-Yves David <pierre-yves.david@fb.com> parents: 26328 diff changeset	944 if opts is None:
d9537ce64f3a addremove: remove a mutable default argument Pierre-Yves David <pierre-yves.david@fb.com> parents: 26328 diff changeset	945 opts = {}
23533 891aaa7c0c70 scmutil: pass a matcher to scmutil.addremove() instead of a list of patterns Matt Harbison <matt_harbison@yahoo.com> parents: 23481 diff changeset	946 m = matcher
14320 3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	947 if dry_run is None:
3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	948 dry_run = opts.get('dry_run')
3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	949 if similarity is None:
3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	950 similarity = float(opts.get('similarity') or 0)
23533 891aaa7c0c70 scmutil: pass a matcher to scmutil.addremove() instead of a list of patterns Matt Harbison <matt_harbison@yahoo.com> parents: 23481 diff changeset	951
23537 f1b06a8aad42 commit: propagate --addremove to subrepos if -S is specified (issue3759) Matt Harbison <matt_harbison@yahoo.com> parents: 23534 diff changeset	952 ret = 0
f1b06a8aad42 commit: propagate --addremove to subrepos if -S is specified (issue3759) Matt Harbison <matt_harbison@yahoo.com> parents: 23534 diff changeset	953 join = lambda f: os.path.join(prefix, f)
f1b06a8aad42 commit: propagate --addremove to subrepos if -S is specified (issue3759) Matt Harbison <matt_harbison@yahoo.com> parents: 23534 diff changeset	954
f1b06a8aad42 commit: propagate --addremove to subrepos if -S is specified (issue3759) Matt Harbison <matt_harbison@yahoo.com> parents: 23534 diff changeset	955 wctx = repo[None]
f1b06a8aad42 commit: propagate --addremove to subrepos if -S is specified (issue3759) Matt Harbison <matt_harbison@yahoo.com> parents: 23534 diff changeset	956 for subpath in sorted(wctx.substate):
29813 35560189677c subrepo: cleanup of subrepo filematcher logic Hannes Oldenburg <hannes.christian.oldenburg@gmail.com> parents: 29782 diff changeset	957 submatch = matchmod.subdirmatcher(subpath, m)
35560189677c subrepo: cleanup of subrepo filematcher logic Hannes Oldenburg <hannes.christian.oldenburg@gmail.com> parents: 29782 diff changeset	958 if opts.get('subrepos') or m.exact(subpath) or any(submatch.files()):
23537 f1b06a8aad42 commit: propagate --addremove to subrepos if -S is specified (issue3759) Matt Harbison <matt_harbison@yahoo.com> parents: 23534 diff changeset	959 sub = wctx.sub(subpath)
f1b06a8aad42 commit: propagate --addremove to subrepos if -S is specified (issue3759) Matt Harbison <matt_harbison@yahoo.com> parents: 23534 diff changeset	960 try:
f1b06a8aad42 commit: propagate --addremove to subrepos if -S is specified (issue3759) Matt Harbison <matt_harbison@yahoo.com> parents: 23534 diff changeset	961 if sub.addremove(submatch, prefix, opts, dry_run, similarity):
f1b06a8aad42 commit: propagate --addremove to subrepos if -S is specified (issue3759) Matt Harbison <matt_harbison@yahoo.com> parents: 23534 diff changeset	962 ret = 1
f1b06a8aad42 commit: propagate --addremove to subrepos if -S is specified (issue3759) Matt Harbison <matt_harbison@yahoo.com> parents: 23534 diff changeset	963 except error.LookupError:
f1b06a8aad42 commit: propagate --addremove to subrepos if -S is specified (issue3759) Matt Harbison <matt_harbison@yahoo.com> parents: 23534 diff changeset	964 repo.ui.status(_("skipping missing subrepository: %s\n")
f1b06a8aad42 commit: propagate --addremove to subrepos if -S is specified (issue3759) Matt Harbison <matt_harbison@yahoo.com> parents: 23534 diff changeset	965 % join(subpath))
f1b06a8aad42 commit: propagate --addremove to subrepos if -S is specified (issue3759) Matt Harbison <matt_harbison@yahoo.com> parents: 23534 diff changeset	966
16167 94a8396c9305 addremove: return 1 if we failed to handle any explicit files Matt Mackall <mpm@selenic.com> parents: 16115 diff changeset	967 rejected = []
23534 83bbedc16b3f addremove: warn when addremove fails to operate on a named path Matt Harbison <matt_harbison@yahoo.com> parents: 23533 diff changeset	968 def badfn(f, msg):
83bbedc16b3f addremove: warn when addremove fails to operate on a named path Matt Harbison <matt_harbison@yahoo.com> parents: 23533 diff changeset	969 if f in m.files():
25434 5984dd42e140 addremove: replace match.bad() monkey patching with match.badmatch() Matt Harbison <matt_harbison@yahoo.com> parents: 25418 diff changeset	970 m.bad(f, msg)
23534 83bbedc16b3f addremove: warn when addremove fails to operate on a named path Matt Harbison <matt_harbison@yahoo.com> parents: 23533 diff changeset	971 rejected.append(f)
16167 94a8396c9305 addremove: return 1 if we failed to handle any explicit files Matt Mackall <mpm@selenic.com> parents: 16115 diff changeset	972
25434 5984dd42e140 addremove: replace match.bad() monkey patching with match.badmatch() Matt Harbison <matt_harbison@yahoo.com> parents: 25418 diff changeset	973 badmatch = matchmod.badmatch(m, badfn)
5984dd42e140 addremove: replace match.bad() monkey patching with match.badmatch() Matt Harbison <matt_harbison@yahoo.com> parents: 25418 diff changeset	974 added, unknown, deleted, removed, forgotten = _interestingfiles(repo,
5984dd42e140 addremove: replace match.bad() monkey patching with match.badmatch() Matt Harbison <matt_harbison@yahoo.com> parents: 25418 diff changeset	975 badmatch)
18863 1b70e5941ad7 scmutil.addremove: pull ui.status printing out of the loop Siddharth Agarwal <sid0@fb.com> parents: 18862 diff changeset	976
23259 9f4778027bc2 addremove: add back forgotten files (BC) Martin von Zweigbergk <martinvonz@google.com> parents: 23142 diff changeset	977 unknownset = set(unknown + forgotten)
18863 1b70e5941ad7 scmutil.addremove: pull ui.status printing out of the loop Siddharth Agarwal <sid0@fb.com> parents: 18862 diff changeset	978 toprint = unknownset.copy()
1b70e5941ad7 scmutil.addremove: pull ui.status printing out of the loop Siddharth Agarwal <sid0@fb.com> parents: 18862 diff changeset	979 toprint.update(deleted)
1b70e5941ad7 scmutil.addremove: pull ui.status printing out of the loop Siddharth Agarwal <sid0@fb.com> parents: 18862 diff changeset	980 for abs in sorted(toprint):
1b70e5941ad7 scmutil.addremove: pull ui.status printing out of the loop Siddharth Agarwal <sid0@fb.com> parents: 18862 diff changeset	981 if repo.ui.verbose or not m.exact(abs):
1b70e5941ad7 scmutil.addremove: pull ui.status printing out of the loop Siddharth Agarwal <sid0@fb.com> parents: 18862 diff changeset	982 if abs in unknownset:
23686 164915e8ef7b narrowmatcher: propagate the rel() method Matt Harbison <matt_harbison@yahoo.com> parents: 23582 diff changeset	983 status = _('adding %s\n') % m.uipath(abs)
18863 1b70e5941ad7 scmutil.addremove: pull ui.status printing out of the loop Siddharth Agarwal <sid0@fb.com> parents: 18862 diff changeset	984 else:
23686 164915e8ef7b narrowmatcher: propagate the rel() method Matt Harbison <matt_harbison@yahoo.com> parents: 23582 diff changeset	985 status = _('removing %s\n') % m.uipath(abs)
18863 1b70e5941ad7 scmutil.addremove: pull ui.status printing out of the loop Siddharth Agarwal <sid0@fb.com> parents: 18862 diff changeset	986 repo.ui.status(status)
1b70e5941ad7 scmutil.addremove: pull ui.status printing out of the loop Siddharth Agarwal <sid0@fb.com> parents: 18862 diff changeset	987
19152 7a1292523db3 scmutil.addremove: factor out code to find renames Siddharth Agarwal <sid0@fb.com> parents: 19151 diff changeset	988 renames = _findrenames(repo, m, added + unknown, removed + deleted,
7a1292523db3 scmutil.addremove: factor out code to find renames Siddharth Agarwal <sid0@fb.com> parents: 19151 diff changeset	989 similarity)
14320 3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	990
3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	991 if not dry_run:
23259 9f4778027bc2 addremove: add back forgotten files (BC) Martin von Zweigbergk <martinvonz@google.com> parents: 23142 diff changeset	992 _markchanges(repo, unknown + forgotten, deleted, renames)
14320 3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	993
16167 94a8396c9305 addremove: return 1 if we failed to handle any explicit files Matt Mackall <mpm@selenic.com> parents: 16115 diff changeset	994 for f in rejected:
94a8396c9305 addremove: return 1 if we failed to handle any explicit files Matt Mackall <mpm@selenic.com> parents: 16115 diff changeset	995 if f in m.files():
94a8396c9305 addremove: return 1 if we failed to handle any explicit files Matt Mackall <mpm@selenic.com> parents: 16115 diff changeset	996 return 1
23537 f1b06a8aad42 commit: propagate --addremove to subrepos if -S is specified (issue3759) Matt Harbison <matt_harbison@yahoo.com> parents: 23534 diff changeset	997 return ret
16167 94a8396c9305 addremove: return 1 if we failed to handle any explicit files Matt Mackall <mpm@selenic.com> parents: 16115 diff changeset	998
19154 0c7cf411b390 scmutil: add a function to mark that files have been operated on Siddharth Agarwal <sid0@fb.com> parents: 19153 diff changeset	999 def marktouched(repo, files, similarity=0.0):
0c7cf411b390 scmutil: add a function to mark that files have been operated on Siddharth Agarwal <sid0@fb.com> parents: 19153 diff changeset	1000 '''Assert that files have somehow been operated upon. files are relative to
0c7cf411b390 scmutil: add a function to mark that files have been operated on Siddharth Agarwal <sid0@fb.com> parents: 19153 diff changeset	1001 the repo root.'''
25467 f64dbe06f3d0 scmutil: add an optional parameter to matcher factories for a bad() override Matt Harbison <matt_harbison@yahoo.com> parents: 25466 diff changeset	1002 m = matchfiles(repo, files, badfn=lambda x, y: rejected.append(x))
19154 0c7cf411b390 scmutil: add a function to mark that files have been operated on Siddharth Agarwal <sid0@fb.com> parents: 19153 diff changeset	1003 rejected = []
0c7cf411b390 scmutil: add a function to mark that files have been operated on Siddharth Agarwal <sid0@fb.com> parents: 19153 diff changeset	1004
23259 9f4778027bc2 addremove: add back forgotten files (BC) Martin von Zweigbergk <martinvonz@google.com> parents: 23142 diff changeset	1005 added, unknown, deleted, removed, forgotten = _interestingfiles(repo, m)
19154 0c7cf411b390 scmutil: add a function to mark that files have been operated on Siddharth Agarwal <sid0@fb.com> parents: 19153 diff changeset	1006
0c7cf411b390 scmutil: add a function to mark that files have been operated on Siddharth Agarwal <sid0@fb.com> parents: 19153 diff changeset	1007 if repo.ui.verbose:
23259 9f4778027bc2 addremove: add back forgotten files (BC) Martin von Zweigbergk <martinvonz@google.com> parents: 23142 diff changeset	1008 unknownset = set(unknown + forgotten)
19154 0c7cf411b390 scmutil: add a function to mark that files have been operated on Siddharth Agarwal <sid0@fb.com> parents: 19153 diff changeset	1009 toprint = unknownset.copy()
0c7cf411b390 scmutil: add a function to mark that files have been operated on Siddharth Agarwal <sid0@fb.com> parents: 19153 diff changeset	1010 toprint.update(deleted)
0c7cf411b390 scmutil: add a function to mark that files have been operated on Siddharth Agarwal <sid0@fb.com> parents: 19153 diff changeset	1011 for abs in sorted(toprint):
0c7cf411b390 scmutil: add a function to mark that files have been operated on Siddharth Agarwal <sid0@fb.com> parents: 19153 diff changeset	1012 if abs in unknownset:
0c7cf411b390 scmutil: add a function to mark that files have been operated on Siddharth Agarwal <sid0@fb.com> parents: 19153 diff changeset	1013 status = _('adding %s\n') % abs
0c7cf411b390 scmutil: add a function to mark that files have been operated on Siddharth Agarwal <sid0@fb.com> parents: 19153 diff changeset	1014 else:
0c7cf411b390 scmutil: add a function to mark that files have been operated on Siddharth Agarwal <sid0@fb.com> parents: 19153 diff changeset	1015 status = _('removing %s\n') % abs
0c7cf411b390 scmutil: add a function to mark that files have been operated on Siddharth Agarwal <sid0@fb.com> parents: 19153 diff changeset	1016 repo.ui.status(status)
0c7cf411b390 scmutil: add a function to mark that files have been operated on Siddharth Agarwal <sid0@fb.com> parents: 19153 diff changeset	1017
0c7cf411b390 scmutil: add a function to mark that files have been operated on Siddharth Agarwal <sid0@fb.com> parents: 19153 diff changeset	1018 renames = _findrenames(repo, m, added + unknown, removed + deleted,
0c7cf411b390 scmutil: add a function to mark that files have been operated on Siddharth Agarwal <sid0@fb.com> parents: 19153 diff changeset	1019 similarity)
0c7cf411b390 scmutil: add a function to mark that files have been operated on Siddharth Agarwal <sid0@fb.com> parents: 19153 diff changeset	1020
23259 9f4778027bc2 addremove: add back forgotten files (BC) Martin von Zweigbergk <martinvonz@google.com> parents: 23142 diff changeset	1021 _markchanges(repo, unknown + forgotten, deleted, renames)
19154 0c7cf411b390 scmutil: add a function to mark that files have been operated on Siddharth Agarwal <sid0@fb.com> parents: 19153 diff changeset	1022
0c7cf411b390 scmutil: add a function to mark that files have been operated on Siddharth Agarwal <sid0@fb.com> parents: 19153 diff changeset	1023 for f in rejected:
0c7cf411b390 scmutil: add a function to mark that files have been operated on Siddharth Agarwal <sid0@fb.com> parents: 19153 diff changeset	1024 if f in m.files():
0c7cf411b390 scmutil: add a function to mark that files have been operated on Siddharth Agarwal <sid0@fb.com> parents: 19153 diff changeset	1025 return 1
0c7cf411b390 scmutil: add a function to mark that files have been operated on Siddharth Agarwal <sid0@fb.com> parents: 19153 diff changeset	1026 return 0
0c7cf411b390 scmutil: add a function to mark that files have been operated on Siddharth Agarwal <sid0@fb.com> parents: 19153 diff changeset	1027
19150 7a4eab2456de scmutil.addremove: factor out dirstate walk into another function Siddharth Agarwal <sid0@fb.com> parents: 19070 diff changeset	1028 def _interestingfiles(repo, matcher):
7a4eab2456de scmutil.addremove: factor out dirstate walk into another function Siddharth Agarwal <sid0@fb.com> parents: 19070 diff changeset	1029 '''Walk dirstate with matcher, looking for files that addremove would care
7a4eab2456de scmutil.addremove: factor out dirstate walk into another function Siddharth Agarwal <sid0@fb.com> parents: 19070 diff changeset	1030 about.
7a4eab2456de scmutil.addremove: factor out dirstate walk into another function Siddharth Agarwal <sid0@fb.com> parents: 19070 diff changeset	1031
7a4eab2456de scmutil.addremove: factor out dirstate walk into another function Siddharth Agarwal <sid0@fb.com> parents: 19070 diff changeset	1032 This is different from dirstate.status because it doesn't care about
7a4eab2456de scmutil.addremove: factor out dirstate walk into another function Siddharth Agarwal <sid0@fb.com> parents: 19070 diff changeset	1033 whether files are modified or clean.'''
23259 9f4778027bc2 addremove: add back forgotten files (BC) Martin von Zweigbergk <martinvonz@google.com> parents: 23142 diff changeset	1034 added, unknown, deleted, removed, forgotten = [], [], [], [], []
20033 f962870712da pathutil: tease out a new library to break an import cycle from canonpath use Augie Fackler <raf@durin42.com> parents: 20006 diff changeset	1035 audit_path = pathutil.pathauditor(repo.root)
19150 7a4eab2456de scmutil.addremove: factor out dirstate walk into another function Siddharth Agarwal <sid0@fb.com> parents: 19070 diff changeset	1036
7a4eab2456de scmutil.addremove: factor out dirstate walk into another function Siddharth Agarwal <sid0@fb.com> parents: 19070 diff changeset	1037 ctx = repo[None]
7a4eab2456de scmutil.addremove: factor out dirstate walk into another function Siddharth Agarwal <sid0@fb.com> parents: 19070 diff changeset	1038 dirstate = repo.dirstate
19655 1d07bf106c2a addremove: don't do full walks Siddharth Agarwal <sid0@fb.com> parents: 19509 diff changeset	1039 walkresults = dirstate.walk(matcher, sorted(ctx.substate), True, False,
1d07bf106c2a addremove: don't do full walks Siddharth Agarwal <sid0@fb.com> parents: 19509 diff changeset	1040 full=False)
19150 7a4eab2456de scmutil.addremove: factor out dirstate walk into another function Siddharth Agarwal <sid0@fb.com> parents: 19070 diff changeset	1041 for abs, st in walkresults.iteritems():
7a4eab2456de scmutil.addremove: factor out dirstate walk into another function Siddharth Agarwal <sid0@fb.com> parents: 19070 diff changeset	1042 dstate = dirstate[abs]
7a4eab2456de scmutil.addremove: factor out dirstate walk into another function Siddharth Agarwal <sid0@fb.com> parents: 19070 diff changeset	1043 if dstate == '?' and audit_path.check(abs):
7a4eab2456de scmutil.addremove: factor out dirstate walk into another function Siddharth Agarwal <sid0@fb.com> parents: 19070 diff changeset	1044 unknown.append(abs)
7a4eab2456de scmutil.addremove: factor out dirstate walk into another function Siddharth Agarwal <sid0@fb.com> parents: 19070 diff changeset	1045 elif dstate != 'r' and not st:
7a4eab2456de scmutil.addremove: factor out dirstate walk into another function Siddharth Agarwal <sid0@fb.com> parents: 19070 diff changeset	1046 deleted.append(abs)
23259 9f4778027bc2 addremove: add back forgotten files (BC) Martin von Zweigbergk <martinvonz@google.com> parents: 23142 diff changeset	1047 elif dstate == 'r' and st:
9f4778027bc2 addremove: add back forgotten files (BC) Martin von Zweigbergk <martinvonz@google.com> parents: 23142 diff changeset	1048 forgotten.append(abs)
19150 7a4eab2456de scmutil.addremove: factor out dirstate walk into another function Siddharth Agarwal <sid0@fb.com> parents: 19070 diff changeset	1049 # for finding renames
23259 9f4778027bc2 addremove: add back forgotten files (BC) Martin von Zweigbergk <martinvonz@google.com> parents: 23142 diff changeset	1050 elif dstate == 'r' and not st:
19150 7a4eab2456de scmutil.addremove: factor out dirstate walk into another function Siddharth Agarwal <sid0@fb.com> parents: 19070 diff changeset	1051 removed.append(abs)
7a4eab2456de scmutil.addremove: factor out dirstate walk into another function Siddharth Agarwal <sid0@fb.com> parents: 19070 diff changeset	1052 elif dstate == 'a':
7a4eab2456de scmutil.addremove: factor out dirstate walk into another function Siddharth Agarwal <sid0@fb.com> parents: 19070 diff changeset	1053 added.append(abs)
7a4eab2456de scmutil.addremove: factor out dirstate walk into another function Siddharth Agarwal <sid0@fb.com> parents: 19070 diff changeset	1054
23259 9f4778027bc2 addremove: add back forgotten files (BC) Martin von Zweigbergk <martinvonz@google.com> parents: 23142 diff changeset	1055 return added, unknown, deleted, removed, forgotten
19150 7a4eab2456de scmutil.addremove: factor out dirstate walk into another function Siddharth Agarwal <sid0@fb.com> parents: 19070 diff changeset	1056
19152 7a1292523db3 scmutil.addremove: factor out code to find renames Siddharth Agarwal <sid0@fb.com> parents: 19151 diff changeset	1057 def _findrenames(repo, matcher, added, removed, similarity):
7a1292523db3 scmutil.addremove: factor out code to find renames Siddharth Agarwal <sid0@fb.com> parents: 19151 diff changeset	1058 '''Find renames from removed files to added ones.'''
7a1292523db3 scmutil.addremove: factor out code to find renames Siddharth Agarwal <sid0@fb.com> parents: 19151 diff changeset	1059 renames = {}
7a1292523db3 scmutil.addremove: factor out code to find renames Siddharth Agarwal <sid0@fb.com> parents: 19151 diff changeset	1060 if similarity > 0:
7a1292523db3 scmutil.addremove: factor out code to find renames Siddharth Agarwal <sid0@fb.com> parents: 19151 diff changeset	1061 for old, new, score in similar.findrenames(repo, added, removed,
7a1292523db3 scmutil.addremove: factor out code to find renames Siddharth Agarwal <sid0@fb.com> parents: 19151 diff changeset	1062 similarity):
7a1292523db3 scmutil.addremove: factor out code to find renames Siddharth Agarwal <sid0@fb.com> parents: 19151 diff changeset	1063 if (repo.ui.verbose or not matcher.exact(old)
7a1292523db3 scmutil.addremove: factor out code to find renames Siddharth Agarwal <sid0@fb.com> parents: 19151 diff changeset	1064 or not matcher.exact(new)):
7a1292523db3 scmutil.addremove: factor out code to find renames Siddharth Agarwal <sid0@fb.com> parents: 19151 diff changeset	1065 repo.ui.status(_('recording removal of %s as rename to %s '
7a1292523db3 scmutil.addremove: factor out code to find renames Siddharth Agarwal <sid0@fb.com> parents: 19151 diff changeset	1066 '(%d%% similar)\n') %
7a1292523db3 scmutil.addremove: factor out code to find renames Siddharth Agarwal <sid0@fb.com> parents: 19151 diff changeset	1067 (matcher.rel(old), matcher.rel(new),
7a1292523db3 scmutil.addremove: factor out code to find renames Siddharth Agarwal <sid0@fb.com> parents: 19151 diff changeset	1068 score * 100))
7a1292523db3 scmutil.addremove: factor out code to find renames Siddharth Agarwal <sid0@fb.com> parents: 19151 diff changeset	1069 renames[new] = old
7a1292523db3 scmutil.addremove: factor out code to find renames Siddharth Agarwal <sid0@fb.com> parents: 19151 diff changeset	1070 return renames
7a1292523db3 scmutil.addremove: factor out code to find renames Siddharth Agarwal <sid0@fb.com> parents: 19151 diff changeset	1071
19153 9a4e219bda89 scmutil.addremove: factor out code to mark added/removed/renames Siddharth Agarwal <sid0@fb.com> parents: 19152 diff changeset	1072 def _markchanges(repo, unknown, deleted, renames):
9a4e219bda89 scmutil.addremove: factor out code to mark added/removed/renames Siddharth Agarwal <sid0@fb.com> parents: 19152 diff changeset	1073 '''Marks the files in unknown as added, the files in deleted as removed,
9a4e219bda89 scmutil.addremove: factor out code to mark added/removed/renames Siddharth Agarwal <sid0@fb.com> parents: 19152 diff changeset	1074 and the files in renames as copied.'''
9a4e219bda89 scmutil.addremove: factor out code to mark added/removed/renames Siddharth Agarwal <sid0@fb.com> parents: 19152 diff changeset	1075 wctx = repo[None]
27851 4133a306606c with: use context manager in _markchanges Bryan O'Sullivan <bryano@fb.com> parents: 27706 diff changeset	1076 with repo.wlock():
19153 9a4e219bda89 scmutil.addremove: factor out code to mark added/removed/renames Siddharth Agarwal <sid0@fb.com> parents: 19152 diff changeset	1077 wctx.forget(deleted)
9a4e219bda89 scmutil.addremove: factor out code to mark added/removed/renames Siddharth Agarwal <sid0@fb.com> parents: 19152 diff changeset	1078 wctx.add(unknown)
9a4e219bda89 scmutil.addremove: factor out code to mark added/removed/renames Siddharth Agarwal <sid0@fb.com> parents: 19152 diff changeset	1079 for new, old in renames.iteritems():
9a4e219bda89 scmutil.addremove: factor out code to mark added/removed/renames Siddharth Agarwal <sid0@fb.com> parents: 19152 diff changeset	1080 wctx.copy(old, new)
9a4e219bda89 scmutil.addremove: factor out code to mark added/removed/renames Siddharth Agarwal <sid0@fb.com> parents: 19152 diff changeset	1081
14320 3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	1082 def dirstatecopy(ui, repo, wctx, src, dst, dryrun=False, cwd=None):
3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	1083 """Update the dirstate to reflect the intent of copying src to dst. For
3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	1084 different reasons it might not end with dst being marked as copied from src.
3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	1085 """
3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	1086 origsrc = repo.dirstate.copied(src) or src
3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	1087 if dst == origsrc: # copying back a copy?
3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	1088 if repo.dirstate[dst] not in 'mn' and not dryrun:
3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	1089 repo.dirstate.normallookup(dst)
3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	1090 else:
3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	1091 if repo.dirstate[origsrc] == 'a' and origsrc == src:
3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	1092 if not ui.quiet:
3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	1093 ui.warn(_("%s has not been committed yet, so no copy "
3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	1094 "data will be stored for %s.\n")
3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	1095 % (repo.pathto(origsrc, cwd), repo.pathto(dst, cwd)))
3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	1096 if repo.dirstate[dst] in '?r' and not dryrun:
3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	1097 wctx.add([dst])
3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	1098 elif not dryrun:
3438417a6657 scmutil: fold in wdutil Matt Mackall <mpm@selenic.com> parents: 14319 diff changeset	1099 wctx.copy(origsrc, dst)
14482 58b36e9ea783 introduce new function scmutil.readrequires Adrian Buehlmann <adrian@cadifra.com> parents: 14435 diff changeset	1100
58b36e9ea783 introduce new function scmutil.readrequires Adrian Buehlmann <adrian@cadifra.com> parents: 14435 diff changeset	1101 def readrequires(opener, supported):
58b36e9ea783 introduce new function scmutil.readrequires Adrian Buehlmann <adrian@cadifra.com> parents: 14435 diff changeset	1102 '''Reads and parses .hg/requires and checks if all entries found
58b36e9ea783 introduce new function scmutil.readrequires Adrian Buehlmann <adrian@cadifra.com> parents: 14435 diff changeset	1103 are in the list of supported features.'''
58b36e9ea783 introduce new function scmutil.readrequires Adrian Buehlmann <adrian@cadifra.com> parents: 14435 diff changeset	1104 requirements = set(opener.read("requires").splitlines())
14746 72e4fcb43227 requirements: show all missing features in the error message. Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 14720 diff changeset	1105 missings = []
14482 58b36e9ea783 introduce new function scmutil.readrequires Adrian Buehlmann <adrian@cadifra.com> parents: 14435 diff changeset	1106 for r in requirements:
58b36e9ea783 introduce new function scmutil.readrequires Adrian Buehlmann <adrian@cadifra.com> parents: 14435 diff changeset	1107 if r not in supported:
14484 4582a4dd1817 requires: note apparent corruption Matt Mackall <mpm@selenic.com> parents: 14483 diff changeset	1108 if not r or not r[0].isalnum():
4582a4dd1817 requires: note apparent corruption Matt Mackall <mpm@selenic.com> parents: 14483 diff changeset	1109 raise error.RequirementError(_(".hg/requires file is corrupt"))
14746 72e4fcb43227 requirements: show all missing features in the error message. Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 14720 diff changeset	1110 missings.append(r)
72e4fcb43227 requirements: show all missing features in the error message. Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 14720 diff changeset	1111 missings.sort()
72e4fcb43227 requirements: show all missing features in the error message. Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 14720 diff changeset	1112 if missings:
16683 525fdb738975 cleanup: eradicate long lines Brodie Rao <brodie@sf.io> parents: 16479 diff changeset	1113 raise error.RequirementError(
20820 f8e531a3a77c repo: rephrase the "missing requirement" error message Mads Kiilerich <madski@unity3d.com> parents: 20819 diff changeset	1114 _("repository requires features unknown to this Mercurial: %s")
f8e531a3a77c repo: rephrase the "missing requirement" error message Mads Kiilerich <madski@unity3d.com> parents: 20819 diff changeset	1115 % " ".join(missings),
26421 4b0fc75f9403 urls: bulk-change primary website URLs Matt Mackall <mpm@selenic.com> parents: 26329 diff changeset	1116 hint=_("see https://mercurial-scm.org/wiki/MissingRequirement"
20820 f8e531a3a77c repo: rephrase the "missing requirement" error message Mads Kiilerich <madski@unity3d.com> parents: 20819 diff changeset	1117 " for more information"))
14482 58b36e9ea783 introduce new function scmutil.readrequires Adrian Buehlmann <adrian@cadifra.com> parents: 14435 diff changeset	1118 return requirements
14928 dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1119
24934 5abd0a76bc8f requires: move requires file writing func from localrepo to scmutil Drew Gottlieb <drgott@google.com> parents: 24755 diff changeset	1120 def writerequires(opener, requirements):
27706 22e362da27cf scmutil: use context managers for file handles Gregory Szorc <gregory.szorc@gmail.com> parents: 27651 diff changeset	1121 with opener('requires', 'w') as fp:
22e362da27cf scmutil: use context managers for file handles Gregory Szorc <gregory.szorc@gmail.com> parents: 27651 diff changeset	1122 for r in sorted(requirements):
22e362da27cf scmutil: use context managers for file handles Gregory Szorc <gregory.szorc@gmail.com> parents: 27651 diff changeset	1123 fp.write("%s\n" % r)
24934 5abd0a76bc8f requires: move requires file writing func from localrepo to scmutil Drew Gottlieb <drgott@google.com> parents: 24755 diff changeset	1124
20043 88bd8df008f2 scmutil: rename filecacheentry to filecachesubentry Siddharth Agarwal <sid0@fb.com> parents: 20042 diff changeset	1125 class filecachesubentry(object):
20042 9a72d3886888 scmutil.filecacheentry: make stat argument to constructor mandatory Siddharth Agarwal <sid0@fb.com> parents: 20033 diff changeset	1126 def __init__(self, path, stat):
14928 dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1127 self.path = path
18315 216230643ae2 filecache: allow filecacheentry to be created without stating in __init__ Idan Kamara <idankk86@gmail.com> parents: 18213 diff changeset	1128 self.cachestat = None
216230643ae2 filecache: allow filecacheentry to be created without stating in __init__ Idan Kamara <idankk86@gmail.com> parents: 18213 diff changeset	1129 self._cacheable = None
14928 dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1130
18315 216230643ae2 filecache: allow filecacheentry to be created without stating in __init__ Idan Kamara <idankk86@gmail.com> parents: 18213 diff changeset	1131 if stat:
20043 88bd8df008f2 scmutil: rename filecacheentry to filecachesubentry Siddharth Agarwal <sid0@fb.com> parents: 20042 diff changeset	1132 self.cachestat = filecachesubentry.stat(self.path)
18315 216230643ae2 filecache: allow filecacheentry to be created without stating in __init__ Idan Kamara <idankk86@gmail.com> parents: 18213 diff changeset	1133
216230643ae2 filecache: allow filecacheentry to be created without stating in __init__ Idan Kamara <idankk86@gmail.com> parents: 18213 diff changeset	1134 if self.cachestat:
216230643ae2 filecache: allow filecacheentry to be created without stating in __init__ Idan Kamara <idankk86@gmail.com> parents: 18213 diff changeset	1135 self._cacheable = self.cachestat.cacheable()
216230643ae2 filecache: allow filecacheentry to be created without stating in __init__ Idan Kamara <idankk86@gmail.com> parents: 18213 diff changeset	1136 else:
216230643ae2 filecache: allow filecacheentry to be created without stating in __init__ Idan Kamara <idankk86@gmail.com> parents: 18213 diff changeset	1137 # None means we don't know yet
216230643ae2 filecache: allow filecacheentry to be created without stating in __init__ Idan Kamara <idankk86@gmail.com> parents: 18213 diff changeset	1138 self._cacheable = None
14928 dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1139
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1140 def refresh(self):
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1141 if self.cacheable():
20043 88bd8df008f2 scmutil: rename filecacheentry to filecachesubentry Siddharth Agarwal <sid0@fb.com> parents: 20042 diff changeset	1142 self.cachestat = filecachesubentry.stat(self.path)
14928 dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1143
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1144 def cacheable(self):
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1145 if self._cacheable is not None:
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1146 return self._cacheable
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1147
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1148 # we don't know yet, assume it is for now
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1149 return True
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1150
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1151 def changed(self):
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1152 # no point in going further if we can't cache it
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1153 if not self.cacheable():
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1154 return True
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1155
20043 88bd8df008f2 scmutil: rename filecacheentry to filecachesubentry Siddharth Agarwal <sid0@fb.com> parents: 20042 diff changeset	1156 newstat = filecachesubentry.stat(self.path)
14928 dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1157
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1158 # we may not know if it's cacheable yet, check again now
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1159 if newstat and self._cacheable is None:
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1160 self._cacheable = newstat.cacheable()
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1161
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1162 # check again
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1163 if not self._cacheable:
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1164 return True
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1165
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1166 if self.cachestat != newstat:
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1167 self.cachestat = newstat
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1168 return True
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1169 else:
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1170 return False
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1171
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1172 @staticmethod
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1173 def stat(path):
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1174 try:
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1175 return util.cachestat(path)
25660 328739ea70c3 global: mass rewrite to use modern exception syntax Gregory Szorc <gregory.szorc@gmail.com> parents: 25658 diff changeset	1176 except OSError as e:
14928 dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1177 if e.errno != errno.ENOENT:
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1178 raise
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1179
20044 d38de18d187a scmutil: introduce a filecacheentry that can watch multiple paths Siddharth Agarwal <sid0@fb.com> parents: 20043 diff changeset	1180 class filecacheentry(object):
d38de18d187a scmutil: introduce a filecacheentry that can watch multiple paths Siddharth Agarwal <sid0@fb.com> parents: 20043 diff changeset	1181 def __init__(self, paths, stat=True):
d38de18d187a scmutil: introduce a filecacheentry that can watch multiple paths Siddharth Agarwal <sid0@fb.com> parents: 20043 diff changeset	1182 self._entries = []
d38de18d187a scmutil: introduce a filecacheentry that can watch multiple paths Siddharth Agarwal <sid0@fb.com> parents: 20043 diff changeset	1183 for path in paths:
d38de18d187a scmutil: introduce a filecacheentry that can watch multiple paths Siddharth Agarwal <sid0@fb.com> parents: 20043 diff changeset	1184 self._entries.append(filecachesubentry(path, stat))
d38de18d187a scmutil: introduce a filecacheentry that can watch multiple paths Siddharth Agarwal <sid0@fb.com> parents: 20043 diff changeset	1185
d38de18d187a scmutil: introduce a filecacheentry that can watch multiple paths Siddharth Agarwal <sid0@fb.com> parents: 20043 diff changeset	1186 def changed(self):
d38de18d187a scmutil: introduce a filecacheentry that can watch multiple paths Siddharth Agarwal <sid0@fb.com> parents: 20043 diff changeset	1187 '''true if any entry has changed'''
d38de18d187a scmutil: introduce a filecacheentry that can watch multiple paths Siddharth Agarwal <sid0@fb.com> parents: 20043 diff changeset	1188 for entry in self._entries:
d38de18d187a scmutil: introduce a filecacheentry that can watch multiple paths Siddharth Agarwal <sid0@fb.com> parents: 20043 diff changeset	1189 if entry.changed():
d38de18d187a scmutil: introduce a filecacheentry that can watch multiple paths Siddharth Agarwal <sid0@fb.com> parents: 20043 diff changeset	1190 return True
d38de18d187a scmutil: introduce a filecacheentry that can watch multiple paths Siddharth Agarwal <sid0@fb.com> parents: 20043 diff changeset	1191 return False
d38de18d187a scmutil: introduce a filecacheentry that can watch multiple paths Siddharth Agarwal <sid0@fb.com> parents: 20043 diff changeset	1192
d38de18d187a scmutil: introduce a filecacheentry that can watch multiple paths Siddharth Agarwal <sid0@fb.com> parents: 20043 diff changeset	1193 def refresh(self):
d38de18d187a scmutil: introduce a filecacheentry that can watch multiple paths Siddharth Agarwal <sid0@fb.com> parents: 20043 diff changeset	1194 for entry in self._entries:
d38de18d187a scmutil: introduce a filecacheentry that can watch multiple paths Siddharth Agarwal <sid0@fb.com> parents: 20043 diff changeset	1195 entry.refresh()
d38de18d187a scmutil: introduce a filecacheentry that can watch multiple paths Siddharth Agarwal <sid0@fb.com> parents: 20043 diff changeset	1196
14928 dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1197 class filecache(object):
20045 b3684fd2ff1a scmutil.filecache: support watching over multiple files Siddharth Agarwal <sid0@fb.com> parents: 20044 diff changeset	1198 '''A property like decorator that tracks files under .hg/ for updates.
14928 dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1199
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1200 Records stat info when called in _filecache.
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1201
20045 b3684fd2ff1a scmutil.filecache: support watching over multiple files Siddharth Agarwal <sid0@fb.com> parents: 20044 diff changeset	1202 On subsequent calls, compares old stat info with new info, and recreates the
b3684fd2ff1a scmutil.filecache: support watching over multiple files Siddharth Agarwal <sid0@fb.com> parents: 20044 diff changeset	1203 object when any of the files changes, updating the new stat info in
b3684fd2ff1a scmutil.filecache: support watching over multiple files Siddharth Agarwal <sid0@fb.com> parents: 20044 diff changeset	1204 _filecache.
14928 dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1205
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1206 Mercurial either atomic renames or appends for files under .hg,
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1207 so to ensure the cache is reliable we need the filesystem to be able
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1208 to tell us if a file has been replaced. If it can't, we fallback to
26098 ce26928cbe41 spelling: behaviour -> behavior timeless@mozdev.org parents: 26020 diff changeset	1209 recreating the object on every call (essentially the same behavior as
20045 b3684fd2ff1a scmutil.filecache: support watching over multiple files Siddharth Agarwal <sid0@fb.com> parents: 20044 diff changeset	1210 propertycache).
b3684fd2ff1a scmutil.filecache: support watching over multiple files Siddharth Agarwal <sid0@fb.com> parents: 20044 diff changeset	1211
b3684fd2ff1a scmutil.filecache: support watching over multiple files Siddharth Agarwal <sid0@fb.com> parents: 20044 diff changeset	1212 '''
b3684fd2ff1a scmutil.filecache: support watching over multiple files Siddharth Agarwal <sid0@fb.com> parents: 20044 diff changeset	1213 def __init__(self, *paths):
b3684fd2ff1a scmutil.filecache: support watching over multiple files Siddharth Agarwal <sid0@fb.com> parents: 20044 diff changeset	1214 self.paths = paths
16198 fa8488565afd filecache: refactor path join logic to a function Idan Kamara <idankk86@gmail.com> parents: 16115 diff changeset	1215
fa8488565afd filecache: refactor path join logic to a function Idan Kamara <idankk86@gmail.com> parents: 16115 diff changeset	1216 def join(self, obj, fname):
20045 b3684fd2ff1a scmutil.filecache: support watching over multiple files Siddharth Agarwal <sid0@fb.com> parents: 20044 diff changeset	1217 """Used to compute the runtime path of a cached file.
16198 fa8488565afd filecache: refactor path join logic to a function Idan Kamara <idankk86@gmail.com> parents: 16115 diff changeset	1218
fa8488565afd filecache: refactor path join logic to a function Idan Kamara <idankk86@gmail.com> parents: 16115 diff changeset	1219 Users should subclass filecache and provide their own version of this
fa8488565afd filecache: refactor path join logic to a function Idan Kamara <idankk86@gmail.com> parents: 16115 diff changeset	1220 function to call the appropriate join function on 'obj' (an instance
fa8488565afd filecache: refactor path join logic to a function Idan Kamara <idankk86@gmail.com> parents: 16115 diff changeset	1221 of the class that its member function was decorated).
fa8488565afd filecache: refactor path join logic to a function Idan Kamara <idankk86@gmail.com> parents: 16115 diff changeset	1222 """
fa8488565afd filecache: refactor path join logic to a function Idan Kamara <idankk86@gmail.com> parents: 16115 diff changeset	1223 return obj.join(fname)
14928 dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1224
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1225 def __call__(self, func):
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1226 self.func = func
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1227 self.name = func.__name__
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1228 return self
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1229
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1230 def __get__(self, obj, type=None):
29373 36fbd72c2f39 scmutil: allow access to filecache descriptor on class Martijn Pieters <mjpieters@fb.com> parents: 29367 diff changeset	1231 # if accessed on the class, return the descriptor itself.
36fbd72c2f39 scmutil: allow access to filecache descriptor on class Martijn Pieters <mjpieters@fb.com> parents: 29367 diff changeset	1232 if obj is None:
36fbd72c2f39 scmutil: allow access to filecache descriptor on class Martijn Pieters <mjpieters@fb.com> parents: 29367 diff changeset	1233 return self
16115 236bb604dc39 scmutil: update cached copy when filecached attribute is assigned (issue3263) Idan Kamara <idankk86@gmail.com> parents: 16068 diff changeset	1234 # do we need to check if the file changed?
236bb604dc39 scmutil: update cached copy when filecached attribute is assigned (issue3263) Idan Kamara <idankk86@gmail.com> parents: 16068 diff changeset	1235 if self.name in obj.__dict__:
18316 f36375576ed5 filecache: create an entry in _filecache when __set__ is called for a missing one Idan Kamara <idankk86@gmail.com> parents: 18315 diff changeset	1236 assert self.name in obj._filecache, self.name
16115 236bb604dc39 scmutil: update cached copy when filecached attribute is assigned (issue3263) Idan Kamara <idankk86@gmail.com> parents: 16068 diff changeset	1237 return obj.__dict__[self.name]
236bb604dc39 scmutil: update cached copy when filecached attribute is assigned (issue3263) Idan Kamara <idankk86@gmail.com> parents: 16068 diff changeset	1238
14928 dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1239 entry = obj._filecache.get(self.name)
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1240
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1241 if entry:
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1242 if entry.changed():
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1243 entry.obj = self.func(obj)
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1244 else:
20045 b3684fd2ff1a scmutil.filecache: support watching over multiple files Siddharth Agarwal <sid0@fb.com> parents: 20044 diff changeset	1245 paths = [self.join(obj, path) for path in self.paths]
14928 dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1246
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1247 # We stat -before- creating the object so our cache doesn't lie if
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1248 # a writer modified between the time we read and stat
20045 b3684fd2ff1a scmutil.filecache: support watching over multiple files Siddharth Agarwal <sid0@fb.com> parents: 20044 diff changeset	1249 entry = filecacheentry(paths, True)
14928 dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1250 entry.obj = self.func(obj)
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1251
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1252 obj._filecache[self.name] = entry
dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1253
16115 236bb604dc39 scmutil: update cached copy when filecached attribute is assigned (issue3263) Idan Kamara <idankk86@gmail.com> parents: 16068 diff changeset	1254 obj.__dict__[self.name] = entry.obj
14928 dca59d5be12d scmutil: introduce filecache Idan Kamara <idankk86@gmail.com> parents: 14861 diff changeset	1255 return entry.obj
16115 236bb604dc39 scmutil: update cached copy when filecached attribute is assigned (issue3263) Idan Kamara <idankk86@gmail.com> parents: 16068 diff changeset	1256
236bb604dc39 scmutil: update cached copy when filecached attribute is assigned (issue3263) Idan Kamara <idankk86@gmail.com> parents: 16068 diff changeset	1257 def __set__(self, obj, value):
18316 f36375576ed5 filecache: create an entry in _filecache when __set__ is called for a missing one Idan Kamara <idankk86@gmail.com> parents: 18315 diff changeset	1258 if self.name not in obj._filecache:
f36375576ed5 filecache: create an entry in _filecache when __set__ is called for a missing one Idan Kamara <idankk86@gmail.com> parents: 18315 diff changeset	1259 # we add an entry for the missing value because X in __dict__
f36375576ed5 filecache: create an entry in _filecache when __set__ is called for a missing one Idan Kamara <idankk86@gmail.com> parents: 18315 diff changeset	1260 # implies X in _filecache
20045 b3684fd2ff1a scmutil.filecache: support watching over multiple files Siddharth Agarwal <sid0@fb.com> parents: 20044 diff changeset	1261 paths = [self.join(obj, path) for path in self.paths]
b3684fd2ff1a scmutil.filecache: support watching over multiple files Siddharth Agarwal <sid0@fb.com> parents: 20044 diff changeset	1262 ce = filecacheentry(paths, False)
18316 f36375576ed5 filecache: create an entry in _filecache when __set__ is called for a missing one Idan Kamara <idankk86@gmail.com> parents: 18315 diff changeset	1263 obj._filecache[self.name] = ce
f36375576ed5 filecache: create an entry in _filecache when __set__ is called for a missing one Idan Kamara <idankk86@gmail.com> parents: 18315 diff changeset	1264 else:
f36375576ed5 filecache: create an entry in _filecache when __set__ is called for a missing one Idan Kamara <idankk86@gmail.com> parents: 18315 diff changeset	1265 ce = obj._filecache[self.name]
f36375576ed5 filecache: create an entry in _filecache when __set__ is called for a missing one Idan Kamara <idankk86@gmail.com> parents: 18315 diff changeset	1266
f36375576ed5 filecache: create an entry in _filecache when __set__ is called for a missing one Idan Kamara <idankk86@gmail.com> parents: 18315 diff changeset	1267 ce.obj = value # update cached copy
16115 236bb604dc39 scmutil: update cached copy when filecached attribute is assigned (issue3263) Idan Kamara <idankk86@gmail.com> parents: 16068 diff changeset	1268 obj.__dict__[self.name] = value # update copy returned by obj.x
236bb604dc39 scmutil: update cached copy when filecached attribute is assigned (issue3263) Idan Kamara <idankk86@gmail.com> parents: 16068 diff changeset	1269
236bb604dc39 scmutil: update cached copy when filecached attribute is assigned (issue3263) Idan Kamara <idankk86@gmail.com> parents: 16068 diff changeset	1270 def __delete__(self, obj):
236bb604dc39 scmutil: update cached copy when filecached attribute is assigned (issue3263) Idan Kamara <idankk86@gmail.com> parents: 16068 diff changeset	1271 try:
236bb604dc39 scmutil: update cached copy when filecached attribute is assigned (issue3263) Idan Kamara <idankk86@gmail.com> parents: 16068 diff changeset	1272 del obj.__dict__[self.name]
236bb604dc39 scmutil: update cached copy when filecached attribute is assigned (issue3263) Idan Kamara <idankk86@gmail.com> parents: 16068 diff changeset	1273 except KeyError:
18177 203b7a759218 scmutil: clean up use of two-argument raise Augie Fackler <raf@durin42.com> parents: 17992 diff changeset	1274 raise AttributeError(self.name)
26490 f0d730efb02f scmutil: add a way for a subprocess to be run with an inheritable lock Siddharth Agarwal <sid0@fb.com> parents: 26433 diff changeset	1275
f0d730efb02f scmutil: add a way for a subprocess to be run with an inheritable lock Siddharth Agarwal <sid0@fb.com> parents: 26433 diff changeset	1276 def _locksub(repo, lock, envvar, cmd, environ=None, args, *kwargs):
f0d730efb02f scmutil: add a way for a subprocess to be run with an inheritable lock Siddharth Agarwal <sid0@fb.com> parents: 26433 diff changeset	1277 if lock is None:
f0d730efb02f scmutil: add a way for a subprocess to be run with an inheritable lock Siddharth Agarwal <sid0@fb.com> parents: 26433 diff changeset	1278 raise error.LockInheritanceContractViolation(
f0d730efb02f scmutil: add a way for a subprocess to be run with an inheritable lock Siddharth Agarwal <sid0@fb.com> parents: 26433 diff changeset	1279 'lock can only be inherited while held')
f0d730efb02f scmutil: add a way for a subprocess to be run with an inheritable lock Siddharth Agarwal <sid0@fb.com> parents: 26433 diff changeset	1280 if environ is None:
f0d730efb02f scmutil: add a way for a subprocess to be run with an inheritable lock Siddharth Agarwal <sid0@fb.com> parents: 26433 diff changeset	1281 environ = {}
f0d730efb02f scmutil: add a way for a subprocess to be run with an inheritable lock Siddharth Agarwal <sid0@fb.com> parents: 26433 diff changeset	1282 with lock.inherit() as locker:
f0d730efb02f scmutil: add a way for a subprocess to be run with an inheritable lock Siddharth Agarwal <sid0@fb.com> parents: 26433 diff changeset	1283 environ[envvar] = locker
f0d730efb02f scmutil: add a way for a subprocess to be run with an inheritable lock Siddharth Agarwal <sid0@fb.com> parents: 26433 diff changeset	1284 return repo.ui.system(cmd, environ=environ, args, *kwargs)
26491 366d489295ca scmutil: add a way for a repo's wlock to be inherited by a subprocess Siddharth Agarwal <sid0@fb.com> parents: 26490 diff changeset	1285
366d489295ca scmutil: add a way for a repo's wlock to be inherited by a subprocess Siddharth Agarwal <sid0@fb.com> parents: 26490 diff changeset	1286 def wlocksub(repo, cmd, args, *kwargs):
366d489295ca scmutil: add a way for a repo's wlock to be inherited by a subprocess Siddharth Agarwal <sid0@fb.com> parents: 26490 diff changeset	1287 """run cmd as a subprocess that allows inheriting repo's wlock
366d489295ca scmutil: add a way for a repo's wlock to be inherited by a subprocess Siddharth Agarwal <sid0@fb.com> parents: 26490 diff changeset	1288
366d489295ca scmutil: add a way for a repo's wlock to be inherited by a subprocess Siddharth Agarwal <sid0@fb.com> parents: 26490 diff changeset	1289 This can only be called while the wlock is held. This takes all the
366d489295ca scmutil: add a way for a repo's wlock to be inherited by a subprocess Siddharth Agarwal <sid0@fb.com> parents: 26490 diff changeset	1290 arguments that ui.system does, and returns the exit code of the
366d489295ca scmutil: add a way for a repo's wlock to be inherited by a subprocess Siddharth Agarwal <sid0@fb.com> parents: 26490 diff changeset	1291 subprocess."""
366d489295ca scmutil: add a way for a repo's wlock to be inherited by a subprocess Siddharth Agarwal <sid0@fb.com> parents: 26490 diff changeset	1292 return _locksub(repo, repo.currentwlock(), 'HG_WLOCK_LOCKER', cmd, *args,
366d489295ca scmutil: add a way for a repo's wlock to be inherited by a subprocess Siddharth Agarwal <sid0@fb.com> parents: 26490 diff changeset	1293 **kwargs)
26906 e40af07e518e scmutil: extract general delta config handling in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 26836 diff changeset	1294
e40af07e518e scmutil: extract general delta config handling in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 26836 diff changeset	1295 def gdinitconfig(ui):
e40af07e518e scmutil: extract general delta config handling in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 26836 diff changeset	1296 """helper function to know if a repo should be created as general delta
26907 dfab6edb98e3 format: introduce 'format.usegeneraldelta` Pierre-Yves David <pierre-yves.david@fb.com> parents: 26906 diff changeset	1297 """
dfab6edb98e3 format: introduce 'format.usegeneraldelta` Pierre-Yves David <pierre-yves.david@fb.com> parents: 26906 diff changeset	1298 # experimental config: format.generaldelta
dfab6edb98e3 format: introduce 'format.usegeneraldelta` Pierre-Yves David <pierre-yves.david@fb.com> parents: 26906 diff changeset	1299 return (ui.configbool('format', 'generaldelta', False)
27093 41d3e307a7c1 format: create new repository as 'generaldelta' by default Pierre-Yves David <pierre-yves.david@fb.com> parents: 26907 diff changeset	1300 or ui.configbool('format', 'usegeneraldelta', True))
26906 e40af07e518e scmutil: extract general delta config handling in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 26836 diff changeset	1301
26907 dfab6edb98e3 format: introduce 'format.usegeneraldelta` Pierre-Yves David <pierre-yves.david@fb.com> parents: 26906 diff changeset	1302 def gddeltaconfig(ui):
dfab6edb98e3 format: introduce 'format.usegeneraldelta` Pierre-Yves David <pierre-yves.david@fb.com> parents: 26906 diff changeset	1303 """helper function to know if incoming delta should be optimised
dfab6edb98e3 format: introduce 'format.usegeneraldelta` Pierre-Yves David <pierre-yves.david@fb.com> parents: 26906 diff changeset	1304 """
26906 e40af07e518e scmutil: extract general delta config handling in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 26836 diff changeset	1305 # experimental config: format.generaldelta
e40af07e518e scmutil: extract general delta config handling in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 26836 diff changeset	1306 return ui.configbool('format', 'generaldelta', False)
27895 2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1307
29998 0c40e64d6154 scmutil: factor out common logic of delayclosedfile to reuse it FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29813 diff changeset	1308 class closewrapbase(object):
0c40e64d6154 scmutil: factor out common logic of delayclosedfile to reuse it FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29813 diff changeset	1309 """Base class of wrapper, which hooks closing
27895 2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1310
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1311 Do not instantiate outside of the vfs layer.
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1312 """
29998 0c40e64d6154 scmutil: factor out common logic of delayclosedfile to reuse it FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29813 diff changeset	1313 def __init__(self, fh):
27895 2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1314 object.__setattr__(self, '_origfh', fh)
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1315
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1316 def __getattr__(self, attr):
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1317 return getattr(self._origfh, attr)
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1318
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1319 def __setattr__(self, attr, value):
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1320 return setattr(self._origfh, attr, value)
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1321
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1322 def __delattr__(self, attr):
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1323 return delattr(self._origfh, attr)
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1324
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1325 def __enter__(self):
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1326 return self._origfh.__enter__()
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1327
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1328 def __exit__(self, exc_type, exc_value, exc_tb):
29998 0c40e64d6154 scmutil: factor out common logic of delayclosedfile to reuse it FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29813 diff changeset	1329 raise NotImplementedError('attempted instantiating ' + str(type(self)))
0c40e64d6154 scmutil: factor out common logic of delayclosedfile to reuse it FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29813 diff changeset	1330
0c40e64d6154 scmutil: factor out common logic of delayclosedfile to reuse it FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29813 diff changeset	1331 def close(self):
0c40e64d6154 scmutil: factor out common logic of delayclosedfile to reuse it FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29813 diff changeset	1332 raise NotImplementedError('attempted instantiating ' + str(type(self)))
0c40e64d6154 scmutil: factor out common logic of delayclosedfile to reuse it FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29813 diff changeset	1333
0c40e64d6154 scmutil: factor out common logic of delayclosedfile to reuse it FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29813 diff changeset	1334 class delayclosedfile(closewrapbase):
0c40e64d6154 scmutil: factor out common logic of delayclosedfile to reuse it FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29813 diff changeset	1335 """Proxy for a file object whose close is delayed.
0c40e64d6154 scmutil: factor out common logic of delayclosedfile to reuse it FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29813 diff changeset	1336
0c40e64d6154 scmutil: factor out common logic of delayclosedfile to reuse it FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29813 diff changeset	1337 Do not instantiate outside of the vfs layer.
0c40e64d6154 scmutil: factor out common logic of delayclosedfile to reuse it FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29813 diff changeset	1338 """
0c40e64d6154 scmutil: factor out common logic of delayclosedfile to reuse it FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29813 diff changeset	1339 def __init__(self, fh, closer):
0c40e64d6154 scmutil: factor out common logic of delayclosedfile to reuse it FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29813 diff changeset	1340 super(delayclosedfile, self).__init__(fh)
0c40e64d6154 scmutil: factor out common logic of delayclosedfile to reuse it FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29813 diff changeset	1341 object.__setattr__(self, '_closer', closer)
0c40e64d6154 scmutil: factor out common logic of delayclosedfile to reuse it FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29813 diff changeset	1342
0c40e64d6154 scmutil: factor out common logic of delayclosedfile to reuse it FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29813 diff changeset	1343 def __exit__(self, exc_type, exc_value, exc_tb):
27895 2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1344 self._closer.close(self._origfh)
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1345
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1346 def close(self):
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1347 self._closer.close(self._origfh)
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1348
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1349 class backgroundfilecloser(object):
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1350 """Coordinates background closing of file handles on multiple threads."""
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1351 def __init__(self, ui, expectedcount=-1):
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1352 self._running = False
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1353 self._entered = False
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1354 self._threads = []
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1355 self._threadexception = None
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1356
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1357 # Only Windows/NTFS has slow file closing. So only enable by default
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1358 # on that platform. But allow to be enabled elsewhere for testing.
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1359 defaultenabled = os.name == 'nt'
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1360 enabled = ui.configbool('worker', 'backgroundclose', defaultenabled)
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1361
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1362 if not enabled:
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1363 return
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1364
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1365 # There is overhead to starting and stopping the background threads.
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1366 # Don't do background processing unless the file count is large enough
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1367 # to justify it.
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1368 minfilecount = ui.configint('worker', 'backgroundcloseminfilecount',
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1369 2048)
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1370 # FUTURE dynamically start background threads after minfilecount closes.
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1371 # (We don't currently have any callers that don't know their file count)
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1372 if expectedcount > 0 and expectedcount < minfilecount:
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1373 return
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1374
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1375 # Windows defaults to a limit of 512 open files. A buffer of 128
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1376 # should give us enough headway.
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1377 maxqueue = ui.configint('worker', 'backgroundclosemaxqueue', 384)
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1378 threadcount = ui.configint('worker', 'backgroundclosethreadcount', 4)
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1379
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1380 ui.debug('starting %d threads for background file closing\n' %
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1381 threadcount)
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1382
28819 826d457df138 scmutil: use util.queue/util.empty for py3 compat timeless <timeless@mozdev.org> parents: 28197 diff changeset	1383 self._queue = util.queue(maxsize=maxqueue)
27895 2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1384 self._running = True
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1385
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1386 for i in range(threadcount):
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1387 t = threading.Thread(target=self._worker, name='backgroundcloser')
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1388 self._threads.append(t)
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1389 t.start()
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1390
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1391 def __enter__(self):
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1392 self._entered = True
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1393 return self
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1394
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1395 def __exit__(self, exc_type, exc_value, exc_tb):
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1396 self._running = False
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1397
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1398 # Wait for threads to finish closing so open files don't linger for
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1399 # longer than lifetime of context manager.
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1400 for t in self._threads:
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1401 t.join()
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1402
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1403 def _worker(self):
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1404 """Main routine for worker thread."""
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1405 while True:
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1406 try:
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1407 fh = self._queue.get(block=True, timeout=0.100)
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1408 # Need to catch or the thread will terminate and
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1409 # we could orphan file descriptors.
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1410 try:
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1411 fh.close()
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1412 except Exception as e:
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1413 # Stash so can re-raise from main thread later.
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1414 self._threadexception = e
28819 826d457df138 scmutil: use util.queue/util.empty for py3 compat timeless <timeless@mozdev.org> parents: 28197 diff changeset	1415 except util.empty:
27895 2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1416 if not self._running:
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1417 break
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1418
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1419 def close(self, fh):
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1420 """Schedule a file for closing."""
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1421 if not self._entered:
29389 98e8313dcd9e i18n: translate abort messages liscju <piotr.listkiewicz@gmail.com> parents: 29373 diff changeset	1422 raise error.Abort(_('can only call close() when context manager '
98e8313dcd9e i18n: translate abort messages liscju <piotr.listkiewicz@gmail.com> parents: 29373 diff changeset	1423 'active'))
27895 2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1424
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1425 # If a background thread encountered an exception, raise now so we fail
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1426 # fast. Otherwise we may potentially go on for minutes until the error
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1427 # is acted on.
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1428 if self._threadexception:
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1429 e = self._threadexception
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1430 self._threadexception = None
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1431 raise e
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1432
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1433 # If we're not actively running, close synchronously.
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1434 if not self._running:
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1435 fh.close()
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1436 return
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1437
2d6a89e79b48 scmutil: support background file closing Gregory Szorc <gregory.szorc@gmail.com> parents: 27879 diff changeset	1438 self._queue.put(fh, block=True, timeout=None)
29999 57830bd0e787 scmutil: add file object wrapper class to check ambiguity at closing FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29998 diff changeset	1439
57830bd0e787 scmutil: add file object wrapper class to check ambiguity at closing FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29998 diff changeset	1440 class checkambigatclosing(closewrapbase):
57830bd0e787 scmutil: add file object wrapper class to check ambiguity at closing FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29998 diff changeset	1441 """Proxy for a file object, to avoid ambiguity of file stat
57830bd0e787 scmutil: add file object wrapper class to check ambiguity at closing FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29998 diff changeset	1442
57830bd0e787 scmutil: add file object wrapper class to check ambiguity at closing FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29998 diff changeset	1443 See also util.filestat for detail about "ambiguity of file stat".
57830bd0e787 scmutil: add file object wrapper class to check ambiguity at closing FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29998 diff changeset	1444
57830bd0e787 scmutil: add file object wrapper class to check ambiguity at closing FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29998 diff changeset	1445 This proxy is useful only if the target file is guarded by any
57830bd0e787 scmutil: add file object wrapper class to check ambiguity at closing FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29998 diff changeset	1446 lock (e.g. repo.lock or repo.wlock)
57830bd0e787 scmutil: add file object wrapper class to check ambiguity at closing FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29998 diff changeset	1447
57830bd0e787 scmutil: add file object wrapper class to check ambiguity at closing FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29998 diff changeset	1448 Do not instantiate outside of the vfs layer.
57830bd0e787 scmutil: add file object wrapper class to check ambiguity at closing FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29998 diff changeset	1449 """
57830bd0e787 scmutil: add file object wrapper class to check ambiguity at closing FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29998 diff changeset	1450 def __init__(self, fh):
57830bd0e787 scmutil: add file object wrapper class to check ambiguity at closing FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29998 diff changeset	1451 super(checkambigatclosing, self).__init__(fh)
57830bd0e787 scmutil: add file object wrapper class to check ambiguity at closing FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29998 diff changeset	1452 object.__setattr__(self, '_oldstat', util.filestat(fh.name))
57830bd0e787 scmutil: add file object wrapper class to check ambiguity at closing FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29998 diff changeset	1453
57830bd0e787 scmutil: add file object wrapper class to check ambiguity at closing FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29998 diff changeset	1454 def _checkambig(self):
57830bd0e787 scmutil: add file object wrapper class to check ambiguity at closing FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29998 diff changeset	1455 oldstat = self._oldstat
57830bd0e787 scmutil: add file object wrapper class to check ambiguity at closing FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29998 diff changeset	1456 if oldstat.stat:
57830bd0e787 scmutil: add file object wrapper class to check ambiguity at closing FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29998 diff changeset	1457 newstat = util.filestat(self._origfh.name)
57830bd0e787 scmutil: add file object wrapper class to check ambiguity at closing FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29998 diff changeset	1458 if newstat.isambig(oldstat):
57830bd0e787 scmutil: add file object wrapper class to check ambiguity at closing FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29998 diff changeset	1459 # stat of changed file is ambiguous to original one
30255 e0ff47999b13 scmutil: ignore EPERM at os.utime, which avoids ambiguity at closing FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 30254 diff changeset	1460 newstat.avoidambig(self._origfh.name, oldstat)
29999 57830bd0e787 scmutil: add file object wrapper class to check ambiguity at closing FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29998 diff changeset	1461
57830bd0e787 scmutil: add file object wrapper class to check ambiguity at closing FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29998 diff changeset	1462 def __exit__(self, exc_type, exc_value, exc_tb):
57830bd0e787 scmutil: add file object wrapper class to check ambiguity at closing FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29998 diff changeset	1463 self._origfh.__exit__(exc_type, exc_value, exc_tb)
57830bd0e787 scmutil: add file object wrapper class to check ambiguity at closing FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29998 diff changeset	1464 self._checkambig()
57830bd0e787 scmutil: add file object wrapper class to check ambiguity at closing FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29998 diff changeset	1465
57830bd0e787 scmutil: add file object wrapper class to check ambiguity at closing FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29998 diff changeset	1466 def close(self):
57830bd0e787 scmutil: add file object wrapper class to check ambiguity at closing FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29998 diff changeset	1467 self._origfh.close()
57830bd0e787 scmutil: add file object wrapper class to check ambiguity at closing FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29998 diff changeset	1468 self._checkambig()

Mercurial > public > mercurial-scm > hg-stable

annotate mercurial/scmutil.py @ 30255:e0ff47999b13 stable