|
|
import os, re, traceback, sys
|
|
|
from mercurial import fancyopts, ui, hg
|
|
|
|
|
|
class UnknownCommand(Exception): pass
|
|
|
|
|
|
def filterfiles(list, files):
|
|
|
l = [ x for x in list if x in files ]
|
|
|
|
|
|
for f in files:
|
|
|
if f[-1] != os.sep: f += os.sep
|
|
|
l += [ x for x in list if x.startswith(f) ]
|
|
|
return l
|
|
|
|
|
|
def relfilter(repo, args):
|
|
|
if os.getcwd() != repo.root:
|
|
|
p = os.getcwd()[len(repo.root) + 1: ]
|
|
|
return filterfiles(p, args)
|
|
|
return args
|
|
|
|
|
|
def relpath(repo, args):
|
|
|
if os.getcwd() != repo.root:
|
|
|
p = os.getcwd()[len(repo.root) + 1: ]
|
|
|
return [ os.path.join(p, x) for x in args ]
|
|
|
return args
|
|
|
|
|
|
def help(ui, cmd=None):
|
|
|
'''show help'''
|
|
|
if cmd:
|
|
|
try:
|
|
|
i = find(cmd)
|
|
|
ui.write("%s\n\n" % i[2])
|
|
|
ui.write(i[0].__doc__, "\n")
|
|
|
except UnknownCommand:
|
|
|
ui.warn("unknown command %s", cmd)
|
|
|
sys.exit(0)
|
|
|
|
|
|
ui.status("""\
|
|
|
hg commands:
|
|
|
|
|
|
add [files...] add the given files in the next commit
|
|
|
addremove add all new files, delete all missing files
|
|
|
annotate [files...] show changeset number per file line
|
|
|
branch <path> create a branch of <path> in this directory
|
|
|
checkout [changeset] checkout the latest or given changeset
|
|
|
commit commit all changes to the repository
|
|
|
diff [files...] diff working directory (or selected files)
|
|
|
dump <file> [rev] dump the latest or given revision of a file
|
|
|
dumpmanifest [rev] dump the latest or given revision of the manifest
|
|
|
export <rev> dump the changeset header and diffs for a revision
|
|
|
history show changeset history
|
|
|
init create a new repository in this directory
|
|
|
log <file> show revision history of a single file
|
|
|
merge <path> merge changes from <path> into local repository
|
|
|
recover rollback an interrupted transaction
|
|
|
remove [files...] remove the given files in the next commit
|
|
|
serve export the repository via HTTP
|
|
|
status show new, missing, and changed files in working dir
|
|
|
tags show current changeset tags
|
|
|
undo undo the last transaction
|
|
|
""")
|
|
|
|
|
|
def init(ui):
|
|
|
"""create a repository"""
|
|
|
hg.repository(ui, ".", create=1)
|
|
|
|
|
|
def branch(ui, path):
|
|
|
'''branch from a local repository'''
|
|
|
# this should eventually support remote repos
|
|
|
os.system("cp -al %s/.hg .hg" % path)
|
|
|
|
|
|
def checkout(u, repo, changeset=None):
|
|
|
'''checkout a given changeset or the current tip'''
|
|
|
node = repo.changelog.tip()
|
|
|
if changeset:
|
|
|
node = repo.lookup(changeset)
|
|
|
repo.checkout(node)
|
|
|
|
|
|
def annotate(u, repo, *args, **ops):
|
|
|
def getnode(rev):
|
|
|
return hg.short(repo.changelog.node(rev))
|
|
|
|
|
|
def getname(rev):
|
|
|
try:
|
|
|
return bcache[rev]
|
|
|
except KeyError:
|
|
|
cl = repo.changelog.read(repo.changelog.node(rev))
|
|
|
name = cl[1]
|
|
|
f = name.find('@')
|
|
|
if f >= 0:
|
|
|
name = name[:f]
|
|
|
bcache[rev] = name
|
|
|
return name
|
|
|
|
|
|
bcache = {}
|
|
|
opmap = [['user', getname], ['number', str], ['changeset', getnode]]
|
|
|
if not ops['user'] and not ops['changeset']:
|
|
|
ops['number'] = 1
|
|
|
|
|
|
args = relpath(repo, args)
|
|
|
node = repo.current
|
|
|
if ops['revision']:
|
|
|
node = repo.changelog.lookup(ops['revision'])
|
|
|
change = repo.changelog.read(node)
|
|
|
mmap = repo.manifest.read(change[0])
|
|
|
maxuserlen = 0
|
|
|
maxchangelen = 0
|
|
|
for f in args:
|
|
|
lines = repo.file(f).annotate(mmap[f])
|
|
|
pieces = []
|
|
|
|
|
|
for o, f in opmap:
|
|
|
if ops[o]:
|
|
|
l = [ f(n) for n,t in lines ]
|
|
|
m = max(map(len, l))
|
|
|
pieces.append([ "%*s" % (m, x) for x in l])
|
|
|
|
|
|
for p,l in zip(zip(*pieces), lines):
|
|
|
u.write(" ".join(p) + ": " + l[1])
|
|
|
|
|
|
def status(ui, repo):
|
|
|
'''show changed files in the working directory
|
|
|
|
|
|
C = changed
|
|
|
A = added
|
|
|
R = removed
|
|
|
? = not tracked'''
|
|
|
(c, a, d) = repo.diffdir(repo.root, repo.current)
|
|
|
(c, a, d) = map(lambda x: relfilter(repo, x), (c, a, d))
|
|
|
|
|
|
for f in c: print "C", f
|
|
|
for f in a: print "?", f
|
|
|
for f in d: print "R", f
|
|
|
|
|
|
def undo(ui, repo):
|
|
|
repo.undo()
|
|
|
|
|
|
table = {
|
|
|
"init": (init, [], 'hg init'),
|
|
|
"branch|clone": (branch, [], 'hg branch [path]'),
|
|
|
"help": (help, [], 'hg help [command]'),
|
|
|
"checkout|co": (checkout, [], 'hg checkout [changeset]'),
|
|
|
"ann|annotate": (annotate,
|
|
|
[('r', 'revision', '', 'revision'),
|
|
|
('u', 'user', None, 'show user'),
|
|
|
('n', 'number', None, 'show revision number'),
|
|
|
('c', 'changeset', None, 'show changeset')],
|
|
|
'hg annotate [-u] [-c] [-n] [-r id] [files]'),
|
|
|
"status": (status, [], 'hg status'),
|
|
|
"undo": (undo, [], 'hg undo'),
|
|
|
}
|
|
|
|
|
|
norepo = "init branch help"
|
|
|
|
|
|
def find(cmd):
|
|
|
i = None
|
|
|
for e in table.keys():
|
|
|
if re.match(e + "$", cmd):
|
|
|
return table[e]
|
|
|
|
|
|
raise UnknownCommand(cmd)
|
|
|
|
|
|
def dispatch(args):
|
|
|
options = {}
|
|
|
opts = [('v', 'verbose', None, 'verbose'),
|
|
|
('d', 'debug', None, 'debug'),
|
|
|
('q', 'quiet', None, 'quiet'),
|
|
|
('y', 'noninteractive', None, 'run non-interactively'),
|
|
|
]
|
|
|
|
|
|
args = fancyopts.fancyopts(args, opts, options,
|
|
|
'hg [options] <command> [options] [files]')
|
|
|
|
|
|
if not args:
|
|
|
cmd = "help"
|
|
|
else:
|
|
|
cmd, args = args[0], args[1:]
|
|
|
|
|
|
u = ui.ui(options["verbose"], options["debug"], options["quiet"],
|
|
|
not options["noninteractive"])
|
|
|
|
|
|
# deal with unfound commands later
|
|
|
i = find(cmd)
|
|
|
|
|
|
cmdoptions = {}
|
|
|
args = fancyopts.fancyopts(args, i[1], cmdoptions, i[2])
|
|
|
|
|
|
if cmd not in norepo.split():
|
|
|
repo = hg.repository(ui = u)
|
|
|
d = lambda: i[0](u, repo, *args, **cmdoptions)
|
|
|
else:
|
|
|
d = lambda: i[0](u, *args, **cmdoptions)
|
|
|
|
|
|
try:
|
|
|
d()
|
|
|
except KeyboardInterrupt:
|
|
|
u.warn("interrupted!\n")
|
|
|
except TypeError, inst:
|
|
|
# was this an argument error?
|
|
|
tb = traceback.extract_tb(sys.exc_info()[2])
|
|
|
if len(tb) > 2: # no
|
|
|
raise
|
|
|
u.warn("%s: invalid arguments\n" % i[0].__name__)
|
|
|
u.warn("syntax: %s\n" % i[2])
|
|
|
sys.exit(-1)
|
|
|
|