def graphlog(ui, repo, *pats, **opts):
"""show revision history alongside an ASCII revision graph
Print a revision history alongside a revision graph drawn with
ASCII characters.
Nodes printed as an @ character are parents of the working
directory.
"""
revs, expr, filematcher = getlogrevs(repo, pats, opts)
revs = sorted(revs, reverse=1)
limit = cmdutil.loglimit(opts)
if limit is not None:
revs = revs[:limit]
revdag = graphmod.dagwalker(repo, revs)
getrenamed = None
if opts.get('copies'):
endrev = None
if opts.get('rev'):
endrev = max(scmutil.revrange(repo, opts.get('rev'))) + 1
getrenamed = templatekw.getrenamedfn(repo, endrev=endrev)
displayer = show_changeset(ui, repo, opts, buffered=True)
showparents = [ctx.node() for ctx in repo[None].parents()]
generate(ui, revdag, displayer, showparents, asciiedges, getrenamed,
filematcher)
def _graph(self, repo, collection, repo_size, size, p):
"""
Generates a DAG graph for mercurial
:param repo: repo instance
:param size: number of commits to show
:param p: page number
"""
if not collection:
c.jsdata = json.dumps([])
return
data = []
revs = [x.revision for x in collection]
if repo.alias == 'git':
for _ in revs:
vtx = [0, 1]
edges = [[0, 0, 1]]
data.append(['', vtx, edges])
elif repo.alias == 'hg':
dag = graphmod.dagwalker(repo._repo, revs)
c.dag = graphmod.colored(dag, repo._repo)
for (id, type, ctx, vtx, edges) in c.dag:
if type != graphmod.CHANGESET:
continue
data.append(['', vtx, edges])
c.jsdata = json.dumps(data)
def graph(web, req, tmpl):
rev = webutil.changectx(web.repo, req).rev()
bg_height = 39
revcount = web.maxshortchanges
if "revcount" in req.form:
revcount = int(req.form.get("revcount", [revcount])[0])
revcount = max(revcount, 1)
tmpl.defaults["sessionvars"]["revcount"] = revcount
lessvars = copy.copy(tmpl.defaults["sessionvars"])
lessvars["revcount"] = max(revcount / 2, 1)
morevars = copy.copy(tmpl.defaults["sessionvars"])
morevars["revcount"] = revcount * 2
max_rev = len(web.repo) - 1
revcount = min(max_rev, revcount)
revnode = web.repo.changelog.node(rev)
revnode_hex = hex(revnode)
uprev = min(max_rev, rev + revcount)
downrev = max(0, rev - revcount)
count = len(web.repo)
changenav = webutil.revnavgen(rev, revcount, count, web.repo.changectx)
startrev = rev
# if starting revision is less than 60 set it to uprev
if rev < web.maxshortchanges:
startrev = uprev
dag = graphmod.dagwalker(web.repo, range(startrev, downrev - 1, -1))
tree = list(graphmod.colored(dag, web.repo))
canvasheight = (len(tree) + 1) * bg_height - 27
data = []
for (id, type, ctx, vtx, edges) in tree:
if type != graphmod.CHANGESET:
continue
node = str(ctx)
age = templatefilters.age(ctx.date())
desc = templatefilters.firstline(ctx.description())
desc = cgi.escape(templatefilters.nonempty(desc))
user = cgi.escape(templatefilters.person(ctx.user()))
branch = ctx.branch()
branch = branch, web.repo.branchtags().get(branch) == ctx.node()
data.append((node, vtx, edges, desc, user, age, branch, ctx.tags(), ctx.bookmarks()))
return tmpl(
"graph",
rev=rev,
revcount=revcount,
uprev=uprev,
lessvars=lessvars,
morevars=morevars,
downrev=downrev,
canvasheight=canvasheight,
jsdata=data,
bg_height=bg_height,
node=revnode_hex,
changenav=changenav,
)
def graph(web, req, tmpl):
rev = webutil.changectx(web.repo, req).rev()
bg_height = 39
revcount = web.maxshortchanges
if 'revcount' in req.form:
revcount = int(req.form.get('revcount', [revcount])[0])
revcount = max(revcount, 1)
tmpl.defaults['sessionvars']['revcount'] = revcount
lessvars = copy.copy(tmpl.defaults['sessionvars'])
lessvars['revcount'] = max(revcount / 2, 1)
morevars = copy.copy(tmpl.defaults['sessionvars'])
morevars['revcount'] = revcount * 2
max_rev = len(web.repo) - 1
revcount = min(max_rev, revcount)
revnode = web.repo.changelog.node(rev)
revnode_hex = hex(revnode)
uprev = min(max_rev, rev + revcount)
downrev = max(0, rev - revcount)
count = len(web.repo)
changenav = webutil.revnavgen(rev, revcount, count, web.repo.changectx)
startrev = rev
# if starting revision is less than 60 set it to uprev
if rev < web.maxshortchanges:
startrev = uprev
dag = graphmod.dagwalker(web.repo, range(startrev, downrev - 1, -1))
tree = list(graphmod.colored(dag, web.repo))
canvasheight = (len(tree) + 1) * bg_height - 27
data = []
for (id, type, ctx, vtx, edges) in tree:
if type != graphmod.CHANGESET:
continue
node = str(ctx)
age = templatefilters.age(ctx.date())
desc = templatefilters.firstline(ctx.description())
desc = cgi.escape(templatefilters.nonempty(desc))
user = cgi.escape(templatefilters.person(ctx.user()))
branch = ctx.branch()
branch = branch, web.repo.branchtags().get(branch) == ctx.node()
data.append((node, vtx, edges, desc, user, age, branch, ctx.tags(),
ctx.bookmarks()))
return tmpl('graph',
rev=rev,
revcount=revcount,
uprev=uprev,
lessvars=lessvars,
morevars=morevars,
downrev=downrev,
canvasheight=canvasheight,
jsdata=data,
bg_height=bg_height,
node=revnode_hex,
changenav=changenav)
def showwork(ui, repo, displayer):
"""changesets that aren't finished"""
# TODO support date-based limiting when calling revset.
revs = repo.revs('sort(_underway(), topo)')
revdag = graphmod.dagwalker(repo, revs)
ui.setconfig('experimental', 'graphshorten', True)
cmdutil.displaygraph(ui, repo, revdag, displayer, graphmod.asciiedges)
def showjenkins(ui, repo):
"""Jenkins build status"""
revs = repo.revs('sort(_underway(), topo)')
revdag = graphmod.dagwalker(repo, revs)
ui.setconfig(b'experimental', b'graphshorten', True)
spec = formatter.lookuptemplate(ui, None, tmpl)
displayer = changesettemplater(ui, repo, spec, buffered=True)
displaygraph(ui, repo, revdag, displayer, graphmod.asciiedges)
def parents_from_source(self):
revrange = scmutil.revrange(self.source, self.src_revs)
self.graph = list(graphmod.dagwalker(self.source, revrange))
gid2rev = dict(
((id, ctx.rev()) for id, C, ctx, parents in self.graph))
# graphmod returns a graph of all possible connections through
# the underlying original graph.
# We want a minimal graph instead, that goes through our nodes if it
# can.
# get the full graph of all nodes first
# we ignore missing parents, too, we collect those in self.roots
for _id, C, src_ctx, parents in self.graph:
local_parents = set((
gid2rev.get(p[1]) for p in parents if p[0] != b'M'))
yield src_ctx.rev(), local_parents
def showwork(ui, repo, fm):
"""changesets that aren't finished"""
# TODO support date-based limiting when calling revset.
revs = repo.revs('sort(_underway(), topo)')
revdag = graphmod.dagwalker(repo, revs)
displayer = cmdutil.changeset_templater(ui,
repo,
None,
None,
tmpl=fm._t.load(fm._topic),
mapfile=None,
buffered=True)
ui.setconfig('experimental', 'graphshorten', True)
cmdutil.displaygraph(ui, repo, revdag, displayer, graphmod.asciiedges)
def showwork(ui, repo, displayer):
"""changesets that aren't finished"""
# TODO support date-based limiting when calling revset.
revs = repo.revs(b'sort(_underway(), topo)')
nodelen = longestshortest(repo, revs)
revdag = graphmod.dagwalker(repo, revs)
ui.setconfig(b'experimental', b'graphshorten', True)
logcmdutil.displaygraph(
ui,
repo,
revdag,
displayer,
graphmod.asciiedges,
props={b'nodelen': nodelen},
)
def graphlog(ui, repo, *pats, **opts):
"""show revision history alongside an ASCII revision graph
Print a revision history alongside a revision graph drawn with
ASCII characters.
Nodes printed as an @ character are parents of the working
directory.
"""
check_unsupported_flags(pats, opts)
revs = sorted(scmutil.revrange(repo, [revset(pats, opts)]), reverse=1)
limit = cmdutil.loglimit(opts)
if limit is not None:
revs = revs[:limit]
revdag = graphmod.dagwalker(repo, revs)
displayer = show_changeset(ui, repo, opts, buffered=True)
showparents = [ctx.node() for ctx in repo[None].parents()]
generate(ui, revdag, displayer, showparents, asciiedges)
def graphlog(ui, repo, *pats, **opts):
"""show revision history alongside an ASCII revision graph
Print a revision history alongside a revision graph drawn with
ASCII characters.
Nodes printed as an @ character are parents of the working
directory.
"""
check_unsupported_flags(pats, opts)
revs = sorted(scmutil.revrange(repo, [revset(pats, opts)]), reverse=1)
limit = cmdutil.loglimit(opts)
if limit is not None:
revs = revs[:limit]
revdag = graphmod.dagwalker(repo, revs)
displayer = show_changeset(ui, repo, opts, buffered=True)
showparents = [ctx.node() for ctx in repo[None].parents()]
generate(ui, revdag, displayer, showparents, asciiedges)
def _graph(self, repo, repo_size, size, p):
"""
Generates a DAG graph for mercurial
:param repo: repo instance
:param size: number of commits to show
:param p: page number
"""
if not repo.revisions:
c.jsdata = json.dumps([])
return
revcount = min(repo_size, size)
offset = 1 if p == 1 else ((p - 1) * revcount + 1)
try:
rev_end = repo.revisions.index(repo.revisions[(-1 * offset)])
except IndexError:
rev_end = repo.revisions.index(repo.revisions[-1])
rev_start = max(0, rev_end - revcount)
data = []
rev_end += 1
if repo.alias == 'git':
for _ in xrange(rev_start, rev_end):
vtx = [0, 1]
edges = [[0, 0, 1]]
data.append(['', vtx, edges])
elif repo.alias == 'hg':
revs = list(reversed(xrange(rev_start, rev_end)))
c.dag = graphmod.colored(graphmod.dagwalker(repo._repo, revs))
for (id, type, ctx, vtx, edges) in c.dag:
if type != graphmod.CHANGESET:
continue
data.append(['', vtx, edges])
c.jsdata = json.dumps(data)
def graph(web, req, tmpl):
"""
/graph[/{revision}]
-------------------
Show information about the graphical topology of the repository.
Information rendered by this handler can be used to create visual
representations of repository topology.
The ``revision`` URL parameter controls the starting changeset.
The ``revcount`` query string argument can define the number of changesets
to show information for.
This handler will render the ``graph`` template.
"""
if 'node' in req.form:
ctx = webutil.changectx(web.repo, req)
symrev = webutil.symrevorshortnode(req, ctx)
else:
ctx = web.repo['tip']
symrev = 'tip'
rev = ctx.rev()
bg_height = 39
revcount = web.maxshortchanges
if 'revcount' in req.form:
try:
revcount = int(req.form.get('revcount', [revcount])[0])
revcount = max(revcount, 1)
tmpl.defaults['sessionvars']['revcount'] = revcount
except ValueError:
pass
lessvars = copy.copy(tmpl.defaults['sessionvars'])
lessvars['revcount'] = max(revcount / 2, 1)
morevars = copy.copy(tmpl.defaults['sessionvars'])
morevars['revcount'] = revcount * 2
count = len(web.repo)
pos = rev
uprev = min(max(0, count - 1), rev + revcount)
downrev = max(0, rev - revcount)
changenav = webutil.revnav(web.repo).gen(pos, revcount, count)
tree = []
if pos != -1:
allrevs = web.repo.changelog.revs(pos, 0)
revs = []
for i in allrevs:
revs.append(i)
if len(revs) >= revcount:
break
# We have to feed a baseset to dagwalker as it is expecting smartset
# object. This does not have a big impact on hgweb performance itself
# since hgweb graphing code is not itself lazy yet.
dag = graphmod.dagwalker(web.repo, revset.baseset(revs))
# As we said one line above... not lazy.
tree = list(graphmod.colored(dag, web.repo))
def getcolumns(tree):
cols = 0
for (id, type, ctx, vtx, edges) in tree:
if type != graphmod.CHANGESET:
continue
cols = max(cols, max([edge[0] for edge in edges] or [0]),
max([edge[1] for edge in edges] or [0]))
return cols
def graphdata(usetuples, **map):
data = []
row = 0
for (id, type, ctx, vtx, edges) in tree:
if type != graphmod.CHANGESET:
continue
node = str(ctx)
age = templatefilters.age(ctx.date())
desc = templatefilters.firstline(ctx.description())
desc = cgi.escape(templatefilters.nonempty(desc))
user = cgi.escape(templatefilters.person(ctx.user()))
branch = cgi.escape(ctx.branch())
try:
branchnode = web.repo.branchtip(branch)
except error.RepoLookupError:
branchnode = None
branch = branch, branchnode == ctx.node()
if usetuples:
data.append((node, vtx, edges, desc, user, age, branch,
[cgi.escape(x) for x in ctx.tags()
], [cgi.escape(x) for x in ctx.bookmarks()]))
else:
edgedata = [{
'col': edge[0],
'nextcol': edge[1],
'color': (edge[2] - 1) % 6 + 1,
'width': edge[3],
'bcolor': edge[4]
} for edge in edges]
data.append({
'node':
node,
'col':
vtx[0],
'color': (vtx[1] - 1) % 6 + 1,
'edges':
edgedata,
'row':
row,
'nextrow':
row + 1,
'desc':
desc,
'user':
user,
'age':
age,
'bookmarks':
webutil.nodebookmarksdict(web.repo, ctx.node()),
'branches':
webutil.nodebranchdict(web.repo, ctx),
'inbranch':
webutil.nodeinbranch(web.repo, ctx),
'tags':
webutil.nodetagsdict(web.repo, ctx.node())
})
row += 1
return data
cols = getcolumns(tree)
rows = len(tree)
canvasheight = (rows + 1) * bg_height - 27
return tmpl('graph',
rev=rev,
symrev=symrev,
revcount=revcount,
uprev=uprev,
lessvars=lessvars,
morevars=morevars,
downrev=downrev,
cols=cols,
rows=rows,
canvaswidth=(cols + 1) * bg_height,
truecanvasheight=rows * bg_height,
canvasheight=canvasheight,
bg_height=bg_height,
jsdata=lambda **x: graphdata(True, **x),
nodes=lambda **x: graphdata(False, **x),
node=ctx.hex(),
changenav=changenav)
def graph(web, req, tmpl):
ctx = webutil.changectx(web.repo, req)
rev = ctx.rev()
bg_height = 39
revcount = web.maxshortchanges
if 'revcount' in req.form:
revcount = int(req.form.get('revcount', [revcount])[0])
revcount = max(revcount, 1)
tmpl.defaults['sessionvars']['revcount'] = revcount
lessvars = copy.copy(tmpl.defaults['sessionvars'])
lessvars['revcount'] = max(revcount / 2, 1)
morevars = copy.copy(tmpl.defaults['sessionvars'])
morevars['revcount'] = revcount * 2
count = len(web.repo)
pos = rev
uprev = min(max(0, count - 1), rev + revcount)
downrev = max(0, rev - revcount)
changenav = webutil.revnav(web.repo).gen(pos, revcount, count)
tree = []
if pos != -1:
allrevs = web.repo.changelog.revs(pos, 0)
revs = []
for i in allrevs:
revs.append(i)
if len(revs) >= revcount:
break
dag = graphmod.dagwalker(web.repo, revs)
tree = list(graphmod.colored(dag, web.repo))
def getcolumns(tree):
cols = 0
for (id, type, ctx, vtx, edges) in tree:
if type != graphmod.CHANGESET:
continue
cols = max(cols, max([edge[0] for edge in edges] or [0]),
max([edge[1] for edge in edges] or [0]))
return cols
def graphdata(usetuples, **map):
data = []
row = 0
for (id, type, ctx, vtx, edges) in tree:
if type != graphmod.CHANGESET:
continue
node = str(ctx)
age = templatefilters.age(ctx.date())
desc = templatefilters.firstline(ctx.description())
desc = cgi.escape(templatefilters.nonempty(desc))
user = cgi.escape(templatefilters.person(ctx.user()))
branch = ctx.branch()
try:
branchnode = web.repo.branchtip(branch)
except error.RepoLookupError:
branchnode = None
branch = branch, branchnode == ctx.node()
if usetuples:
data.append((node, vtx, edges, desc, user, age, branch,
ctx.tags(), ctx.bookmarks()))
else:
edgedata = [dict(col=edge[0], nextcol=edge[1],
color=(edge[2] - 1) % 6 + 1,
width=edge[3], bcolor=edge[4])
for edge in edges]
data.append(
dict(node=node,
col=vtx[0],
color=(vtx[1] - 1) % 6 + 1,
edges=edgedata,
row=row,
nextrow=row + 1,
desc=desc,
user=user,
age=age,
bookmarks=webutil.nodebookmarksdict(
web.repo, ctx.node()),
branches=webutil.nodebranchdict(web.repo, ctx),
inbranch=webutil.nodeinbranch(web.repo, ctx),
tags=webutil.nodetagsdict(web.repo, ctx.node())))
row += 1
return data
cols = getcolumns(tree)
rows = len(tree)
canvasheight = (rows + 1) * bg_height - 27
return tmpl('graph', rev=rev, revcount=revcount, uprev=uprev,
lessvars=lessvars, morevars=morevars, downrev=downrev,
cols=cols, rows=rows,
canvaswidth=(cols + 1) * bg_height,
truecanvasheight=rows * bg_height,
canvasheight=canvasheight, bg_height=bg_height,
jsdata=lambda **x: graphdata(True, **x),
nodes=lambda **x: graphdata(False, **x),
node=ctx.hex(), changenav=changenav)
def graph(web, req, tmpl):
ctx = webutil.changectx(web.repo, req)
rev = ctx.rev()
bg_height = 39
revcount = web.maxshortchanges
if 'revcount' in req.form:
revcount = int(req.form.get('revcount', [revcount])[0])
revcount = max(revcount, 1)
tmpl.defaults['sessionvars']['revcount'] = revcount
lessvars = copy.copy(tmpl.defaults['sessionvars'])
lessvars['revcount'] = max(revcount / 2, 1)
morevars = copy.copy(tmpl.defaults['sessionvars'])
morevars['revcount'] = revcount * 2
count = len(web.repo)
pos = rev
start = max(0, pos - revcount + 1)
end = min(count, start + revcount)
pos = end - 1
uprev = min(max(0, count - 1), rev + revcount)
downrev = max(0, rev - revcount)
changenav = webutil.revnav(web.repo).gen(pos, revcount, count)
tree = []
if start < end:
revs = list(web.repo.changelog.revs(end - 1, start))
dag = graphmod.dagwalker(web.repo, revs)
tree = list(graphmod.colored(dag, web.repo))
def getcolumns(tree):
cols = 0
for (id, type, ctx, vtx, edges) in tree:
if type != graphmod.CHANGESET:
continue
cols = max(cols, max([edge[0] for edge in edges] or [0]),
max([edge[1] for edge in edges] or [0]))
return cols
def graphdata(usetuples, **map):
data = []
row = 0
for (id, type, ctx, vtx, edges) in tree:
if type != graphmod.CHANGESET:
continue
node = str(ctx)
age = templatefilters.age(ctx.date())
desc = templatefilters.firstline(ctx.description())
desc = cgi.escape(templatefilters.nonempty(desc))
user = cgi.escape(templatefilters.person(ctx.user()))
branch = ctx.branch()
try:
branchnode = web.repo.branchtip(branch)
except error.RepoLookupError:
branchnode = None
branch = branch, branchnode == ctx.node()
if usetuples:
data.append((node, vtx, edges, desc, user, age, branch,
ctx.tags(), ctx.bookmarks()))
else:
edgedata = [
dict(col=edge[0],
nextcol=edge[1],
color=(edge[2] - 1) % 6 + 1,
width=edge[3],
bcolor=edge[4]) for edge in edges
]
data.append(
dict(node=node,
col=vtx[0],
color=(vtx[1] - 1) % 6 + 1,
edges=edgedata,
row=row,
nextrow=row + 1,
desc=desc,
user=user,
age=age,
bookmarks=webutil.nodebookmarksdict(
web.repo, ctx.node()),
branches=webutil.nodebranchdict(web.repo, ctx),
inbranch=webutil.nodeinbranch(web.repo, ctx),
tags=webutil.nodetagsdict(web.repo, ctx.node())))
row += 1
return data
cols = getcolumns(tree)
rows = len(tree)
canvasheight = (rows + 1) * bg_height - 27
return tmpl('graph',
rev=rev,
revcount=revcount,
uprev=uprev,
lessvars=lessvars,
morevars=morevars,
downrev=downrev,
cols=cols,
rows=rows,
canvaswidth=(cols + 1) * bg_height,
truecanvasheight=rows * bg_height,
canvasheight=canvasheight,
bg_height=bg_height,
jsdata=lambda **x: graphdata(True, **x),
nodes=lambda **x: graphdata(False, **x),
node=ctx.hex(),
changenav=changenav)
def createGraph(self, max_depth=1, optimize=True):
"""Create the sparse graph.
max_depth: Direct grand-parent loops to detect and remove
optimize: Find long-range loops and remove them from the
graph. Requires at least max_depth of 1
"""
self.parents.clear()
self.heads.clear()
del self.archived_parents[:]
del self.merges[:]
range = scmutil.revrange(self.source, self.src_revs)
self.graph = list(graphmod.dagwalker(self.source, range))
gid2rev = dict(((id, ctx.rev()) for id, C, ctx, parents in self.graph))
# graphmod returns a graph of all possible connections through
# the underlying original graph.
# We want a minimal graph instead, that goes through our nodes if it
# can.
# get the full graph of all nodes first
# we ignore missing parents, too, we collect those in self.roots
for _id, C, src_ctx, parents in self.graph:
local_parents = set(
(gid2rev.get(p[1]) for p in parents if p[0] != 'M'))
self.parents[src_ctx.rev()] = local_parents
# eliminate leap-frog loops where the grandchild is also a child
# we do this for grandchildren, and deeper.
# The depth is a bit of an optimization problem.
def iterate_parents(parents, depth):
# recursive parents helper
if depth > 0:
for p in parents:
for grandparents in \
iterate_parents(self.parents.get(p, []), depth-1):
yield grandparents
else:
yield parents
for depth in xrange(1, max_depth + 1):
self.archived_parents.append(self.parents)
new_parents = {}
for src_rev, local_parents in self.parents.items():
minimal_parents = local_parents.copy()
for parents in iterate_parents(local_parents, depth):
minimal_parents.difference_update(parents)
new_parents[src_rev] = minimal_parents
self.parents = new_parents
# find heads, roots, merges, children and forks
all_parents = set()
for src_rev, local_parents in self.parents.items():
if src_rev not in all_parents and src_rev is not node.nullrev:
self.heads.add(src_rev)
if not local_parents and src_rev is not node.nullrev:
self.roots.append(src_rev)
else:
all_parents.update(local_parents)
self.heads.difference_update(local_parents)
if len(local_parents) > 1:
self.merges.append(src_rev)
for c in local_parents:
self.children[c].append(src_rev)
self.forks = [
rev for rev, children in self.children.items() if len(children) > 1
]
if optimize:
self.archived_parents.append(self.parents.copy())
self.eliminateShortCuts()
def graph(web, req, tmpl):
ctx = webutil.changectx(web.repo, req)
rev = ctx.rev()
bg_height = 39
revcount = web.maxshortchanges
if 'revcount' in req.form:
try:
revcount = int(req.form.get('revcount', [revcount])[0])
revcount = max(revcount, 1)
tmpl.defaults['sessionvars']['revcount'] = revcount
except ValueError:
pass
lessvars = copy.copy(tmpl.defaults['sessionvars'])
lessvars['revcount'] = max(revcount / 2, 1)
morevars = copy.copy(tmpl.defaults['sessionvars'])
morevars['revcount'] = revcount * 2
count = len(web.repo)
pos = rev
uprev = min(max(0, count - 1), rev + revcount)
downrev = max(0, rev - revcount)
changenav = webutil.revnav(web.repo).gen(pos, revcount, count)
tree = []
if pos != -1:
allrevs = web.repo.changelog.revs(pos, 0)
revs = []
for i in allrevs:
revs.append(i)
if len(revs) >= revcount:
break
# We have to feed a baseset to dagwalker as it is expecting smartset
# object. This does not have a big impact on hgweb performance itself
# since hgweb graphing code is not itself lazy yet.
dag = graphmod.dagwalker(web.repo, revset.baseset(revs))
# As we said one line above... not lazy.
tree = list(graphmod.colored(dag, web.repo))
def getcolumns(tree):
cols = 0
for (id, type, ctx, vtx, edges) in tree:
if type != graphmod.CHANGESET:
continue
cols = max(cols, max([edge[0] for edge in edges] or [0]),
max([edge[1] for edge in edges] or [0]))
return cols
def graphdata(usetuples, **map):
data = []
row = 0
for (id, type, ctx, vtx, edges) in tree:
if type != graphmod.CHANGESET:
continue
node = str(ctx)
age = templatefilters.age(ctx.date())
desc = templatefilters.firstline(ctx.description())
desc = cgi.escape(templatefilters.nonempty(desc))
user = cgi.escape(templatefilters.person(ctx.user()))
branch = cgi.escape(ctx.branch())
try:
branchnode = web.repo.branchtip(branch)
except error.RepoLookupError:
branchnode = None
branch = branch, branchnode == ctx.node()
if usetuples:
data.append((node, vtx, edges, desc, user, age, branch,
[cgi.escape(x) for x in ctx.tags()],
[cgi.escape(x) for x in ctx.bookmarks()]))
else:
edgedata = [{'col': edge[0], 'nextcol': edge[1],
'color': (edge[2] - 1) % 6 + 1,
'width': edge[3], 'bcolor': edge[4]}
for edge in edges]
data.append(
{'node': node,
'col': vtx[0],
'color': (vtx[1] - 1) % 6 + 1,
'edges': edgedata,
'row': row,
'nextrow': row + 1,
'desc': desc,
'user': user,
'age': age,
'bookmarks': webutil.nodebookmarksdict(
web.repo, ctx.node()),
'branches': webutil.nodebranchdict(web.repo, ctx),
'inbranch': webutil.nodeinbranch(web.repo, ctx),
'tags': webutil.nodetagsdict(web.repo, ctx.node())})
row += 1
return data
cols = getcolumns(tree)
rows = len(tree)
canvasheight = (rows + 1) * bg_height - 27
return tmpl('graph', rev=rev, revcount=revcount, uprev=uprev,
lessvars=lessvars, morevars=morevars, downrev=downrev,
cols=cols, rows=rows,
canvaswidth=(cols + 1) * bg_height,
truecanvasheight=rows * bg_height,
canvasheight=canvasheight, bg_height=bg_height,
jsdata=lambda **x: graphdata(True, **x),
nodes=lambda **x: graphdata(False, **x),
node=ctx.hex(), changenav=changenav)
