import atexit, os, re, sys, stat, termios

sys.path.insert(1, os.path.join(os.path.dirname(__file__), "..", "..", "..",

"python%d.%d" % sys.version_info[:2]))

sys.path.insert(2, os.path.join(os.path.dirname(__file__), "..", ".."))

from onbld.Scm import Version

from mercurial import util

try:

Version.check_version()

except Version.VersionMismatch, badversion:

raise util.Abort("Version Mismatch:\n %s\n" % badversion)

from mercurial import cmdutil, ignore, node, patch

from onbld.Scm.WorkSpace import WorkSpace, WorkList

from onbld.Scm.Backup import CdmBackup

from onbld.Checks import Cddl, Comments, Copyright, CStyle, HdrChk

from onbld.Checks import JStyle, Keywords, ManLint, Mapfile

def yes_no(ui, msg, default):

if default:

prompt = ' [Y/n]:'

defanswer = 'y'

else:

prompt = ' [y/N]:'

defanswer = 'n'

if Version.at_least("1.4"):

index = ui.promptchoice(msg + prompt, ['&yes', '&no'],

default=['y', 'n'].index(defanswer))

resp = ('y', 'n')[index]

else:

resp = ui.prompt(msg + prompt, ['&yes', '&no'], default=defanswer)

return resp[0] in ('Y', 'y')

def buildfilelist(ws, parent, files):

'''Build a list of files in which we're interested.

if files:

return [(path, None) for path in sorted(files)]

else:

active = ws.active(parent=parent)

return [(ws.filepath(e.name), e) for e in sorted(active)]

buildfilelist = util.cachefunc(buildfilelist)

def not_check(repo, cmd):

'''return a function which returns boolean indicating whether a file

#

# The ignore routines need a canonical path to the file (relative to the

# repo root), whereas the check commands get paths relative to the cwd.

#

# Wrap our argument such that the path is canonified before it is checked.

#

def canonified_check(ignfunc):

def f(path):

cpath = util.canonpath(repo.root, repo.getcwd(), path)

return ignfunc(cpath)

return f

ignorefiles = []

for f in [repo.join('cdm/%s.NOT' % cmd),

repo.wjoin('exception_lists/%s' % cmd)]:

if os.path.exists(f):

ignorefiles.append(f)

if ignorefiles:

ign = ignore.ignore(repo.root, ignorefiles, repo.ui.warn)

return canonified_check(ign)

else:

return util.never

def abort_if_dirty(ws):

'''Abort if the workspace has uncommitted changes, merges,

if ws.modified():

raise util.Abort('workspace has uncommitted changes')

if ws.merged():

raise util.Abort('workspace contains uncommitted merge')

if ws.branched():

raise util.Abort('workspace contains uncommitted branch')

if ws.mq_applied():

raise util.Abort('workspace has Mq patches applied')

wslist = {}

def reposetup(ui, repo):

if repo.local() and repo not in wslist:

wslist[repo] = WorkSpace(repo)

if ui.interactive() and sys.stdin.isatty():

ui.setconfig('hooks', 'preoutgoing.cdm_pbconfirm',

'python:hgext_cdm.pbconfirm')

def pbconfirm(ui, repo, hooktype, source):

def wrapper(settings=None):

termios.tcsetattr(sys.stdin.fileno(), termios.TCSANOW, settings)

if source == 'push':

if not yes_no(ui, "Are you sure you wish to push?", False):

return 1

else:

settings = termios.tcgetattr(sys.stdin.fileno())

orig = list(settings)

atexit.register(wrapper, orig)

settings[3] = settings[3] & (~termios.ISIG) # c_lflag

termios.tcsetattr(sys.stdin.fileno(), termios.TCSANOW, settings)

def cdm_pdiffs(ui, repo, *pats, **opts):

'''diff workspace against its parent

act = wslist[repo].active(opts.get('parent'))

if not act.revs:

return

#

# If no patterns were specified, either explicitly or via -I or -X

# use the active list files to avoid a workspace walk.

#

if pats or opts.get('include') or opts.get('exclude'):

matchfunc = wslist[repo].matcher(pats=pats, opts=opts)

else:

matchfunc = wslist[repo].matcher(files=act.files())

opts = patch.diffopts(ui, opts)

diffs = wslist[repo].diff(act.parenttip.node(), act.localtip.node(),

match=matchfunc, opts=opts)

if diffs:

ui.write(diffs)

def cdm_list(ui, repo, **opts):

'''list active files (those changed in this workspace)

act = wslist[repo].active(opts['parent'])

wanted = set(x for x in ('added', 'modified', 'removed') if opts[x])

changes = {}

for entry in act:

if wanted and (entry.change not in wanted):

continue

if entry.change not in changes:

changes[entry.change] = []

changes[entry.change].append(entry)

for change in sorted(changes.keys()):

ui.write(change + ':\n')

for entry in sorted(changes[change]):

if entry.is_renamed():

ui.write('\t%s (renamed from %s)\n' % (entry.name,

entry.parentname))

elif entry.is_copied():

ui.write('\t%s (copied from %s)\n' % (entry.name,

entry.parentname))

else:

ui.write('\t%s\n' % entry.name)

def cdm_bugs(ui, repo, parent=None):

'''show all bug IDs referenced in changeset comments'''

act = wslist[repo].active(parent)

for elt in set(filter(Comments.isBug, act.comments())):

ui.write(elt + '\n')

def cdm_comments(ui, repo, parent=None):

'''show changeset commentary for all active changesets'''

act = wslist[repo].active(parent)

for elt in act.comments():

ui.write(elt + '\n')

def cdm_renamed(ui, repo, parent=None):

'''show renamed active files

act = wslist[repo].active(parent)

for entry in sorted(filter(lambda x: x.is_renamed(), act)):

ui.write('%s %s\n' % (entry.name, entry.parentname))

def cdm_comchk(ui, repo, **opts):

'''check active changeset comment formatting

active = wslist[repo].active(opts.get('parent'))

ui.write('Comments check:\n')

check_db = not opts.get('nocheck')

return Comments.comchk(active.comments(), check_db=check_db, output=ui)

def cdm_cddlchk(ui, repo, *args, **opts):

'''check for a valid CDDL header comment in all active files.

filelist = buildfilelist(wslist[repo], opts.get('parent'), args)

exclude = not_check(repo, 'cddlchk')

lenient = True

ret = 0

ui.write('CDDL block check:\n')

for f, e in filelist:

if e and e.is_removed():

continue

elif (e or opts.get('honour_nots')) and exclude(f):

ui.status('Skipping %s...\n' % f)

continue

elif e and e.is_added():

lenient = False

else:

lenient = True

fh = open(f, 'r')

ret |= Cddl.cddlchk(fh, lenient=lenient, output=ui)

fh.close()

return ret

def cdm_manlintchk(ui, repo, *args, **opts):

'''check for mandoc lint

filelist = buildfilelist(wslist[repo], opts.get('parent'), args)

exclude = not_check(repo, 'manlint')

ret = 0

# Man pages are identified as having a suffix starting with a digit.

ManfileRE = re.compile(r'.*\.[0-9][a-z]*$', re.IGNORECASE)

ui.write('Man format check:\n')

for f, e in filelist:

if e and e.is_removed():

continue

elif (not ManfileRE.match(f)):

continue

elif (e or opts.get('honour_nots')) and exclude(f):

ui.status('Skipping %s...\n' % f)

continue

fh = open(f, 'r')

ret |= ManLint.manlint(fh, output=ui, picky=True)

fh.close()

return ret

def cdm_mapfilechk(ui, repo, *args, **opts):

'''check for a valid mapfile header block in active files

filelist = buildfilelist(wslist[repo], opts.get('parent'), args)

exclude = not_check(repo, 'mapfilechk')

ret = 0

# We are interested in examining any file that has the following

# in its final path segment:

# - Contains the word 'mapfile'

# - Begins with 'map.'

# - Ends with '.map'

# We don't want to match unless these things occur in final path segment

# because directory names with these strings don't indicate a mapfile.

# We also ignore files with suffixes that tell us that the files

# are not mapfiles.

MapfileRE = re.compile(r'.*((mapfile[^/]*)|(/map\.+[^/]*)|(\.map))$',

re.IGNORECASE)

NotMapSuffixRE = re.compile(r'.*\.[ch]$', re.IGNORECASE)

ui.write('Mapfile comment check:\n')

for f, e in filelist:

if e and e.is_removed():

continue

elif (not MapfileRE.match(f)) or NotMapSuffixRE.match(f):

continue

elif (e or opts.get('honour_nots')) and exclude(f):

ui.status('Skipping %s...\n' % f)

continue

fh = open(f, 'r')

ret |= Mapfile.mapfilechk(fh, output=ui)

fh.close()

return ret

def cdm_copyright(ui, repo, *args, **opts):

'''check each active file for a current and correct copyright notice

filelist = buildfilelist(wslist[repo], opts.get('parent'), args)

exclude = not_check(repo, 'copyright')

ret = 0

ui.write('Copyright check:\n')

for f, e in filelist:

if e and e.is_removed():

continue

elif (e or opts.get('honour_nots')) and exclude(f):

ui.status('Skipping %s...\n' % f)

continue

fh = open(f, 'r')

ret |= Copyright.copyright(fh, output=ui)

fh.close()

return ret

def cdm_hdrchk(ui, repo, *args, **opts):

'''check active C header files conform to the O/N header rules

filelist = buildfilelist(wslist[repo], opts.get('parent'), args)

exclude = not_check(repo, 'hdrchk')

ret = 0

ui.write('Header format check:\n')

for f, e in filelist:

if e and e.is_removed():

continue

elif not f.endswith('.h'):

continue

elif (e or opts.get('honour_nots')) and exclude(f):

ui.status('Skipping %s...\n' % f)

continue

fh = open(f, 'r')

ret |= HdrChk.hdrchk(fh, lenient=True, output=ui)

fh.close()

return ret

def cdm_cstyle(ui, repo, *args, **opts):

'''check active C source files conform to the C Style Guide

filelist = buildfilelist(wslist[repo], opts.get('parent'), args)

exclude = not_check(repo, 'cstyle')

ret = 0

ui.write('C style check:\n')

for f, e in filelist:

if e and e.is_removed():

continue

elif not (f.endswith('.c') or f.endswith('.h')):

continue

elif (e or opts.get('honour_nots')) and exclude(f):

ui.status('Skipping %s...\n' % f)

continue

fh = open(f, 'r')

ret |= CStyle.cstyle(fh, output=ui,

picky=True, check_posix_types=True,

check_continuation=True)

fh.close()

return ret

def cdm_jstyle(ui, repo, *args, **opts):

'''check active Java source files for common stylistic errors

filelist = buildfilelist(wslist[repo], opts.get('parent'), args)

exclude = not_check(repo, 'jstyle')

ret = 0

ui.write('Java style check:\n')

for f, e in filelist:

if e and e.is_removed():

continue

elif not f.endswith('.java'):

continue

elif (e or opts.get('honour_nots')) and exclude(f):

ui.status('Skipping %s...\n' % f)

continue

fh = open(f, 'r')

ret |= JStyle.jstyle(fh, output=ui, picky=True)

fh.close()

return ret

def cdm_permchk(ui, repo, *args, **opts):

'''check the permissions of each active file

filelist = buildfilelist(wslist[repo], opts.get('parent'), args)

exclude = not_check(repo, 'permchk')

exeFiles = []

ui.write('File permission check:\n')

for f, e in filelist:

if e and e.is_removed():

continue

elif (e or opts.get('honour_nots')) and exclude(f):

ui.status('Skipping %s...\n' % f)

continue

mode = stat.S_IMODE(os.stat(f)[stat.ST_MODE])

if mode & stat.S_IEXEC:

exeFiles.append(f)

if len(exeFiles) > 0:

ui.write('Warning: the following active file(s) have executable mode '

'(+x) permission set,\nremove unless intentional:\n')

for fname in exeFiles:

ui.write(" %s\n" % fname)

return len(exeFiles) > 0

def cdm_tagchk(ui, repo, **opts):

'''check modification of workspace tags

active = wslist[repo].active(opts.get('parent'))

ui.write('Checking for new tags:\n')

if ".hgtags" in active:

tfile = wslist[repo].filepath('.hgtags')

ptip = active.parenttip.rev()

ui.write('Warning: Workspace contains new non-local tags.\n'

'Only gatekeepers should add or modify such tags.\n'

'Use the following commands to revert these changes:\n'

' hg revert -r%d %s\n'

' hg commit %s\n'

'You should also recommit before integration\n' %

(ptip, tfile, tfile))

return 1

return 0

def cdm_branchchk(ui, repo, **opts):

'''check for changes in number or name of branches

ui.write('Checking for multiple heads (or branches):\n')

heads = set(repo.heads())

parents = set([x.node() for x in wslist[repo].workingctx().parents()])

#

# We care if there's more than one head, and those heads aren't

# identical to the dirstate parents (if they are identical, it's

# an uncommitted merge which mergechk will catch, no need to

# complain twice).

#

if len(heads) > 1 and heads != parents:

ui.write('Workspace has multiple heads (or branches):\n')

for head in [repo.changectx(head) for head in heads]:

ui.write(" %d:%s\t%s\n" %

(head.rev(), str(head), head.description().splitlines()[0]))

ui.write('You must merge and recommit.\n')

return 1

ui.write('\nChecking for branch changes:\n')

if repo.dirstate.branch() != 'default':

ui.write("Warning: Workspace tip has named branch: '%s'\n"

"Only gatekeepers should push new branches.\n"

"Use the following commands to restore the branch name:\n"

" hg branch [-f] default\n"

" hg commit\n"

"You should also recommit before integration\n" %

(repo.dirstate.branch()))

return 1

branches = repo.branchtags().keys()

if len(branches) > 1:

ui.write('Warning: Workspace has named branches:\n')

for t in branches:

if t == 'default':

continue

ui.write("\t%s\n" % t)

ui.write("Only gatekeepers should push new branches.\n"

"Use the following commands to remove extraneous branches.\n"

" hg branch [-f] default\n"

" hg commit"

"You should also recommit before integration\n")

return 1

return 0

def cdm_keywords(ui, repo, *args, **opts):

'''check active files for SCCS keywords

filelist = buildfilelist(wslist[repo], opts.get('parent'), args)

exclude = not_check(repo, 'keywords')

ret = 0

ui.write('Keywords check:\n')

for f, e in filelist:

if e and e.is_removed():

continue

elif (e or opts.get('honour_nots')) and exclude(f):

ui.status('Skipping %s...\n' % f)

continue

fh = open(f, 'r')

ret |= Keywords.keywords(fh, output=ui)

fh.close()

return ret

def cdm_outchk(ui, repo, **opts):

'''Warn the user if they have uncommitted changes'''

ui.write('Checking for uncommitted changes:\n')

st = wslist[repo].modified()

if st:

ui.write('Warning: the following files have uncommitted changes:\n')

for elt in st:

ui.write(' %s\n' % elt)

return 1

return 0

def cdm_mergechk(ui, repo, **opts):

'''Warn the user if their workspace contains merges'''

active = wslist[repo].active(opts.get('parent'))

ui.write('Checking for merges:\n')

merges = filter(lambda x: len(x.parents()) == 2 and x.parents()[1],

active.revs)

if merges:

ui.write('Workspace contains the following merges:\n')

for rev in merges:

desc = rev.description().splitlines()

ui.write(' %s:%s\t%s\n' %

(rev.rev() or "working", str(rev),

desc and desc[0] or "*** uncommitted change ***"))

return 1

return 0

def run_checks(ws, cmds, *args, **opts):

'''Run CMDS (with OPTS) over active files in WS'''

ret = 0

for cmd in cmds:

name = cmd.func_name.split('_')[1]

if not ws.ui.configbool('cdm', name, True):

ws.ui.status('Skipping %s check...\n' % name)

else:

ws.ui.pushbuffer()

result = cmd(ws.ui, ws.repo, honour_nots=True, *args, **opts)

output = ws.ui.popbuffer()

ret |= result

if not ws.ui.quiet or result != 0:

ws.ui.write(output, '\n')

return ret

def cdm_nits(ui, repo, *args, **opts):

'''check for stylistic nits in active files

cmds = [cdm_copyright,

cdm_cstyle,

cdm_hdrchk,

cdm_jstyle,

cmd_manlintchk,

cdm_mapfilechk,

cdm_permchk,

cdm_keywords]

return run_checks(wslist[repo], cmds, *args, **opts)

def cdm_pbchk(ui, repo, **opts):

'''run pre-integration checks on this workspace

#

# The current ordering of these is that the commands from cdm_nits

# run first in the same order as they would in cdm_nits, then the

# pbchk specifics are run.

#

cmds = [cdm_copyright,

cdm_cstyle,

cdm_hdrchk,

cdm_jstyle,

cdm_manlintchk,

cdm_mapfilechk,

cdm_permchk,

cdm_keywords,

cdm_comchk,

cdm_tagchk,

cdm_branchchk,

cdm_outchk,

cdm_mergechk]

return run_checks(wslist[repo], cmds, **opts)

def cdm_recommit(ui, repo, **opts):

'''replace outgoing changesets with a single equivalent changeset

ws = wslist[repo]

if not os.getcwd().startswith(repo.root):

raise util.Abort('recommit is not safe to run with -R')

abort_if_dirty(ws)

wlock = repo.wlock()

lock = repo.lock()

try:

parent = ws.parent(opts['parent'])

between = repo.changelog.nodesbetween(ws.findoutgoing(parent))[2]

heads = set(between) & set(repo.heads())

if len(heads) > 1:

ui.warn('Workspace has multiple outgoing heads (or branches):\n')

for head in sorted(map(repo.changelog.rev, heads), reverse=True):

ui.warn('\t%d\n' % head)

raise util.Abort('you must merge before recommitting')

#

# We can safely use the worklist here, as we know (from the

# abort_if_dirty() check above) that the working copy has not been

# modified.

#

active = ws.active(parent)

if filter(lambda b: len(b.parents()) > 1, active.bases()):

raise util.Abort('Cannot recommit a merge of two non-outgoing '

'changesets')

if len(active.revs) <= 0:

raise util.Abort("no changes to recommit")

if len(active.files()) <= 0:

ui.warn("Recommitting %d active changesets, but no active files\n" %

len(active.revs))

#

# During the course of a recommit, any file bearing a name

# matching the source name of any renamed file will be

# clobbered by the operation.

#

# As such, we ask the user before proceeding.

#

bogosity = [f.parentname for f in active if f.is_renamed() and

os.path.exists(repo.wjoin(f.parentname))]

if bogosity:

ui.warn("The following file names are the original name of a "

"rename and also present\n"

"in the working directory:\n")

for fname in bogosity:

ui.warn(" %s\n" % fname)

if not yes_no(ui, "These files will be removed by recommit."

" Continue?",

False):

raise util.Abort("recommit would clobber files")

user = opts['user'] or ui.username()

comments = '\n'.join(active.comments())

message = cmdutil.logmessage(opts) or ui.edit(comments, user)

if not message:

raise util.Abort('empty commit message')

bk = CdmBackup(ui, ws, backup_name(repo.root))

if bk.need_backup():

if yes_no(ui, 'Do you want to backup files first?', True):

bk.backup()

oldtags = repo.tags()

clearedtags = [(name, nd, repo.changelog.rev(nd), local)

for name, nd, local in active.tags()]

ws.squishdeltas(active, message, user=user)

finally:

lock.release()

wlock.release()

if clearedtags:

ui.write("Removed tags:\n")

for name, nd, rev, local in sorted(clearedtags,

key=lambda x: x[0].lower()):

ui.write(" %5s:%s:\t%s%s\n" % (rev, node.short(nd),

name, (local and ' (local)' or '')))

for ntag, nnode in sorted(repo.tags().items(),

key=lambda x: x[0].lower()):

if ntag in oldtags and ntag != "tip":

if oldtags[ntag] != nnode:

ui.write("tag '%s' now refers to revision %d:%s\n" %

(ntag, repo.changelog.rev(nnode),

node.short(nnode)))

def do_eval(cmd, files, root, changedir=True):

if not changedir:

os.chdir(root)

for path in sorted(files):

dirn, base = os.path.split(path)

if changedir:

os.chdir(os.path.join(root, dirn))

os.putenv('workspace', root)

os.putenv('filepath', path)

os.putenv('dir', dirn)

os.putenv('file', base)

os.system(cmd)

def cdm_eval(ui, repo, *command, **opts):

'''run specified command for each active file

act = wslist[repo].active(opts['parent'])

cmd = ' '.join(command)

files = [x.name for x in act if not x.is_removed()]

do_eval(cmd, files, repo.root, not opts['remain'])

def cdm_apply(ui, repo, *command, **opts):

'''apply specified command to all active files

act = wslist[repo].active(opts['parent'])

if opts['remain']:

appnd = ' $filepath'

else:

appnd = ' $file'

cmd = ' '.join(command) + appnd

files = [x.name for x in act if not x.is_removed()]

do_eval(cmd, files, repo.root, not opts['remain'])

def cdm_reparent(ui, repo, parent):

'''reparent your workspace

def append_new_parent(parent):

fp = None

try:

fp = repo.opener('hgrc', 'a', atomictemp=True)

if fp.tell() != 0:

fp.write('\n')

fp.write('[paths]\n'

'default = %s\n\n' % parent)

fp.rename()

finally:

if fp and not fp.closed:

fp.close()

def update_parent(path, line, parent):

line = line - 1 # The line number we're passed will be 1-based

fp = None

try:

fp = open(path)

data = fp.readlines()

finally:

if fp and not fp.closed:

fp.close()

#

# line will be the last line of any continued block, go back

# to the first removing the continuation as we go.

#

while data[line][0].isspace():

data.pop(line)

line -= 1

assert data[line].startswith('default')

data[line] = "default = %s\n" % parent

if data[-1] != '\n':

data.append('\n')

try:

fp = util.atomictempfile(path, 'w', 0644)

fp.writelines(data)

fp.rename()

finally:

if fp and not fp.closed:

fp.close()

from mercurial import config

parent = ui.expandpath(parent)

if not os.path.exists(repo.join('hgrc')):

append_new_parent(parent)

return

cfg = config.config()

cfg.read(repo.join('hgrc'))

source = cfg.source('paths', 'default')

if not source:

append_new_parent(parent)

return

else:

path, target = source.rsplit(':', 1)

if path != repo.join('hgrc'):

raise util.Abort("Cannot edit path specification not in repo hgrc\n"

"default path is from: %s" % source)

update_parent(path, int(target), parent)

def backup_name(fullpath):

'''Create a backup directory name based on the specified path.

special = ['usr/closed']

fullpath = fullpath.rstrip(os.path.sep).split(os.path.sep)

#

# If a path is 'special', we append the basename of the path to

# the path element preceding the constant, special, part.

#

# Such that for instance:

# /foo/bar/onnv-fixes/usr/closed

# has a backup name of:

# onnv-fixes-closed

#

for elt in special:

elt = elt.split(os.path.sep)

pathpos = len(elt)

if fullpath[-pathpos:] == elt:

return "%s-%s" % (fullpath[-pathpos - 1], elt[-1])

else:

return fullpath[-1]

def cdm_backup(ui, repo, if_newer=False):

'''backup workspace changes and metadata

name = backup_name(repo.root)

bk = CdmBackup(ui, wslist[repo], name)

wlock = repo.wlock()

lock = repo.lock()

try:

if if_newer and not bk.need_backup():

ui.status('backup is up-to-date\n')

else:

bk.backup()

finally:

lock.release()

wlock.release()

def cdm_restore(ui, repo, backup, **opts):

'''restore workspace from backup

if not os.getcwd().startswith(repo.root):

raise util.Abort('restore is not safe to run with -R')

abort_if_dirty(wslist[repo])

if opts['generation']:

gen = int(opts['generation'])

else:

gen = None

if os.path.exists(backup):

backup = os.path.abspath(backup)

wlock = repo.wlock()

lock = repo.lock()

try:

bk = CdmBackup(ui, wslist[repo], backup)

bk.restore(gen)

finally:

lock.release()

wlock.release()

def cdm_webrev(ui, repo, **opts):

'''generate web-based code review and optionally upload it

webrev_args = ""

for key in opts.keys():

if opts[key]:

if type(opts[key]) == type(True):

webrev_args += '-' + key + ' '

else:

webrev_args += '-' + key + ' ' + opts[key] + ' '

retval = os.system('webrev ' + webrev_args)

if retval != 0:

return retval - 255

return 0

def cdm_debugcdmal(ui, repo, *pats, **opts):

'''dump the active list for the sake of debugging/testing'''

ui.write(wslist[repo].active(opts['parent']).as_text(pats))

def cdm_changed(ui, repo, *pats, **opts):

'''mark a file as changed in the working copy

def modded_files(repo, parent):

out = wslist[repo].findoutgoing(wslist[repo].parent(parent))

outnodes = repo.changelog.nodesbetween(out)[0]

files = set()

for n in outnodes:

files.update(repo.changectx(n).files())

files.update(wslist[repo].status().keys())

return files

#

# specced_pats is convenient to treat as a boolean indicating

# whether any file patterns or paths were specified.

#

specced_pats = pats or opts['include'] or opts['exclude']

if len(filter(None, [opts['delete'], opts['update'], opts['init'],

specced_pats])) > 1:

raise util.Abort("-d, -u, -i and patterns are mutually exclusive")

wl = WorkList(wslist[repo])

if (not wl and specced_pats) or opts['init']:

wl.delete()

if yes_no(ui, "Create a list based on your changes thus far?", True):

map(wl.add, modded_files(repo, opts.get('parent')))

if opts['delete']:

wl.delete()

elif opts['update']:

wl.delete()

map(wl.add, modded_files(repo, opts.get('parent')))

wl.write()

elif opts['init']: # Any possible old list was deleted above

wl.write()

elif specced_pats:

sources = []

match = wslist[repo].matcher(pats=pats, opts=opts)

for abso in repo.walk(match):

if abso in repo.dirstate:

wl.add(abso)

#

# Store the source name of any copy. We use this so

# both the add and delete of a rename can be entered

# into the WorkList with only the destination name

# explicitly being mentioned.

#

fctx = wslist[repo].workingctx().filectx(abso)

rn = fctx.renamed()

if rn:

sources.append(rn[0])

else:

ui.warn("%s is not version controlled -- skipping\n" %

match.rel(abso))

if sources:

for fname, chng in wslist[repo].status(files=sources).iteritems():

if chng == 'removed':

wl.add(fname)

wl.write()

else:

for elt in sorted(wl.list()):

ui.write("%s\n" % wslist[repo].filepath(elt))

cmdtable = {

'apply': (cdm_apply, [('p', 'parent', '', 'parent workspace'),

('r', 'remain', None, 'do not change directory')],

'hg apply [-p PARENT] [-r] command...'),

'^backup|bu': (cdm_backup, [('t', 'if-newer', None,

'only backup if workspace files are newer')],

'hg backup [-t]'),

'branchchk': (cdm_branchchk, [('p', 'parent', '', 'parent workspace')],

'hg branchchk [-p PARENT]'),

'bugs': (cdm_bugs, [('p', 'parent', '', 'parent workspace')],

'hg bugs [-p PARENT]'),

'cddlchk': (cdm_cddlchk, [('p', 'parent', '', 'parent workspace')],

'hg cddlchk [-p PARENT]'),

'changed': (cdm_changed, [('d', 'delete', None, 'delete the file list'),

('u', 'update', None, 'mark all changed files'),

('i', 'init', None, 'create an empty file list'),

('p', 'parent', '', 'parent workspace'),

('I', 'include', [],

'include names matching the given patterns'),

('X', 'exclude', [],

'exclude names matching the given patterns')],

'hg changed -d\n'

'hg changed -u\n'

'hg changed -i\n'

'hg changed [-I PATTERN...] [-X PATTERN...] [FILE...]'),

'comchk': (cdm_comchk, [('p', 'parent', '', 'parent workspace'),

('N', 'nocheck', None,

'do not compare comments with databases')],

'hg comchk [-p PARENT]'),

'comments': (cdm_comments, [('p', 'parent', '', 'parent workspace')],

'hg comments [-p PARENT]'),

'copyright': (cdm_copyright, [('p', 'parent', '', 'parent workspace')],

'hg copyright [-p PARENT]'),

'cstyle': (cdm_cstyle, [('p', 'parent', '', 'parent workspace')],

'hg cstyle [-p PARENT]'),

'debugcdmal': (cdm_debugcdmal, [('p', 'parent', '', 'parent workspace')],

'hg debugcdmal [-p PARENT] [FILE...]'),

'eval': (cdm_eval, [('p', 'parent', '', 'parent workspace'),

('r', 'remain', None, 'do not change directory')],

'hg eval [-p PARENT] [-r] command...'),

'hdrchk': (cdm_hdrchk, [('p', 'parent', '', 'parent workspace')],

'hg hdrchk [-p PARENT]'),

'jstyle': (cdm_jstyle, [('p', 'parent', '', 'parent workspace')],

'hg jstyle [-p PARENT]'),

'keywords': (cdm_keywords, [('p', 'parent', '', 'parent workspace')],

'hg keywords [-p PARENT]'),

'^list|active': (cdm_list, [('p', 'parent', '', 'parent workspace'),

('a', 'added', None, 'show added files'),

('m', 'modified', None, 'show modified files'),

('r', 'removed', None, 'show removed files')],

'hg list [-amrRu] [-p PARENT]'),

'manlint': (cdm_manlintchk, [('p', 'parent', '', 'parent workspace')],

'hg manlint [-p PARENT]'),

'mapfilechk': (cdm_mapfilechk, [('p', 'parent', '', 'parent workspace')],

'hg mapfilechk [-p PARENT]'),

'^nits': (cdm_nits, [('p', 'parent', '', 'parent workspace')],

'hg nits [-p PARENT]'),

'^pbchk': (cdm_pbchk, [('p', 'parent', '', 'parent workspace'),

('N', 'nocheck', None, 'skip database checks')],

'hg pbchk [-N] [-p PARENT]'),

'permchk': (cdm_permchk, [('p', 'parent', '', 'parent workspace')],

'hg permchk [-p PARENT]'),

'^pdiffs': (cdm_pdiffs, [('p', 'parent', '', 'parent workspace'),

('a', 'text', None, 'treat all files as text'),

('g', 'git', None, 'use extended git diff format'),

('w', 'ignore-all-space', None,

'ignore white space when comparing lines'),

('b', 'ignore-space-change', None,

'ignore changes in the amount of white space'),

('B', 'ignore-blank-lines', None,

'ignore changes whose lines are all blank'),

('U', 'unified', 3,

'number of lines of context to show'),

('I', 'include', [],

'include names matching the given patterns'),

('X', 'exclude', [],

'exclude names matching the given patterns')],

'hg pdiffs [OPTION...] [-p PARENT] [FILE...]'),

'^recommit|reci': (cdm_recommit, [('p', 'parent', '', 'parent workspace'),

('m', 'message', '',

'use <text> as commit message'),

('l', 'logfile', '',

'read commit message from file'),

('u', 'user', '',

'record user as committer')],

'hg recommit [-m TEXT] [-l FILE] [-u USER] [-p PARENT]'),

'renamed': (cdm_renamed, [('p', 'parent', '', 'parent workspace')],

'hg renamed [-p PARENT]'),

'reparent': (cdm_reparent, [], 'hg reparent PARENT'),

'^restore': (cdm_restore, [('g', 'generation', '', 'generation number')],

'hg restore [-g GENERATION] BACKUP'),

'tagchk': (cdm_tagchk, [('p', 'parent', '', 'parent workspace')],

'hg tagchk [-p PARENT]'),

'webrev': (cdm_webrev, [('C', 'C', '', 'ITS priority file'),

('D', 'D', '', 'delete remote webrev'),

('I', 'I', '', 'ITS configuration file'),

('i', 'i', '', 'include file'),

('N', 'N', None, 'suppress comments'),

('n', 'n', None, 'do not generate webrev'),

('O', 'O', None, 'OpenSolaris mode'),

('o', 'o', '', 'output directory'),

('p', 'p', '', 'use specified parent'),

('t', 't', '', 'upload target'),

('U', 'U', None, 'upload the webrev'),

('w', 'w', '', 'use wx active file')],

'hg webrev [WEBREV_OPTIONS]'),

}