row = []

    colors = {}

    newcolor = 1

    for (rev, dagparents) in dag:

        # Compute row and nextrow

        if rev not in row:

            row.append(rev)  # new head

            colors[rev] = newcolor

            newcolor += 1

        col = row.index(rev)

        addparents = [p for p in dagparents if p not in row]

        # Add unknown parents to nextrow

        tmprow = row[:]

        tmprow[col:col + 1] = reversed(addparents) # higest revs first (to the right), dead ends last (to the left)

        # Stop looking for non-existing ancestors

        nextrow = []

        for r in tmprow:

            if r > nullrev or r in dagparents:

                nextrow.append(r)

            else:

                colors.pop(r)

        # Set colors for the parents

        color = colors.pop(rev)

        if addparents:

            b = branch(rev)

            for p in reversed(addparents):

                if b and branch(abs(p)) == b:

                    colors[p] = color

                    b = None

                else:

                    colors[p] = newcolor

                    newcolor += 1

        # Add edges to the graph

        edges = []

        for ecol, ep in enumerate(row):

            if ep in nextrow:

                edges.append((ecol, nextrow.index(ep), colors[ep]))

            elif ep == rev:

                for p in dagparents:

                    edges.append((ecol, nextrow.index(p), colors[p]))

        # Yield and move on

        row = nextrow

        raise NotImplementedError

    @LazyProperty

    def removed(self):

        """

        Returns list of removed ``FileNode`` objects.

        """

        raise NotImplementedError

    @LazyProperty

    def size(self):

        """

        Returns total number of bytes from contents of all filenodes.

        """

        return sum((node.size for node in self.get_filenodes_generator()))

    def walk(self, topurl=''):

        """

        Similar to os.walk method. Insted of filesystem it walks through

        changeset starting at given ``topurl``.  Returns generator of tuples

        (topnode, dirnodes, filenodes).

        """

        topnode = self.get_node(topurl)

        yield (topnode, topnode.dirs, topnode.files)

        for dirnode in topnode.dirs:

            for tup in self.walk(dirnode.path):

                yield tup

    def get_filenodes_generator(self):

        """

        Returns generator that yields *all* file nodes.

        """

        for topnode, dirs, files in self.walk():

            for node in files:

                yield node

    def as_dict(self):

        """

        Returns dictionary with changeset's attributes and their values.

        """

        data = get_dict_for_attrs(self, ['id', 'raw_id', 'short_id',

            'revision', 'date', 'message'])

        data['author'] = {'name': self.author_name, 'email': self.author_email}

        data['added'] = [node.path for node in self.added]

        data['changed'] = [node.path for node in self.changed]

        data['removed'] = [node.path for node in self.removed]

        return data

class BaseWorkdir(object):

    """

    Working directory representation of single repository.

    :attribute: repository: repository object of working directory

    """

    def __init__(self, repository):

        self.repository = repository

    def get_branch(self):

        """

        Returns name of current branch.

        """

        raise NotImplementedError

    def get_changeset(self):

        """

        Returns current changeset.

        """

        raise NotImplementedError

    def get_added(self):

        """

        Returns list of ``FileNode`` objects marked as *new* in working

        directory.

        """

        raise NotImplementedError

    def get_changed(self):

        """

        Returns list of ``FileNode`` objects *changed* in working directory.

        """

        raise NotImplementedError

    def get_removed(self):

        """

        Returns list of ``RemovedFileNode`` objects marked as *removed* in

        working directory.

        """

        raise NotImplementedError

    def get_untracked(self):

        """

        Returns list of ``FileNode`` objects which are present within working

        directory however are not tracked by repository.

        """

import os

import posixpath

from kallithea.lib.vcs.conf import settings

from kallithea.lib.vcs.backends.base import BaseChangeset

from kallithea.lib.vcs.exceptions import (

    ChangesetDoesNotExistError, ChangesetError, ImproperArchiveTypeError,

    NodeDoesNotExistError, VCSError

)

from kallithea.lib.vcs.nodes import (

    AddedFileNodesGenerator, ChangedFileNodesGenerator, DirNode, FileNode,

    NodeKind, RemovedFileNodesGenerator, RootNode, SubModuleNode

)

from kallithea.lib.vcs.utils import safe_str, safe_unicode, date_fromtimestamp

from kallithea.lib.vcs.utils.lazy import LazyProperty

from kallithea.lib.vcs.utils.paths import get_dirs_for_path

from kallithea.lib.vcs.utils.hgcompat import archival, hex

class MercurialChangeset(BaseChangeset):

    """

    Represents state of the repository at the single revision.

    """

    def __init__(self, repository, revision):

        self.repository = repository

        self.raw_id = revision

        self._ctx = repository._repo[revision]

        self.revision = self._ctx._rev

        self.nodes = {}

    @LazyProperty

    def tags(self):

        return map(safe_unicode, self._ctx.tags())

    @LazyProperty

    def branch(self):

        return  safe_unicode(self._ctx.branch())

    @LazyProperty

    def bookmarks(self):

        return map(safe_unicode, self._ctx.bookmarks())

    @LazyProperty

    def message(self):

        return safe_unicode(self._ctx.description())

    @LazyProperty

    def committer(self):

        return safe_unicode(self.author)

    @LazyProperty

    def author(self):

        return safe_unicode(self._ctx.user())

    @LazyProperty

    def date(self):

        return date_fromtimestamp(*self._ctx.date())

    @LazyProperty

    def _timestamp(self):

        return self._ctx.date()[0]

    @LazyProperty

    def status(self):

        """

        Returns modified, added, removed, deleted files for current changeset

        """

        return self.repository._repo.status(self._ctx.p1().node(),

                                            self._ctx.node())

    @LazyProperty

    def _file_paths(self):

        return list(self._ctx)

    @LazyProperty

    def _dir_paths(self):

        p = list(set(get_dirs_for_path(*self._file_paths)))

        p.insert(0, '')

        return p

    @LazyProperty

    def _paths(self):

        return self._dir_paths + self._file_paths

    @LazyProperty

    def id(self):

        if self.last:

// branch_renderer.js - Rendering of branch DAGs on the client side

//

// Copyright 2010 Marcin Kuzminski <marcin AT python-works DOT com>

// Copyright 2008 Jesper Noehr <jesper AT noehr DOT org>

// Copyright 2008 Dirkjan Ochtman <dirkjan AT ochtman DOT nl>

// Copyright 2006 Alexander Schremmer <alex AT alexanderweb DOT de>

//

// derived from code written by Scott James Remnant <scott@ubuntu.com>

// Copyright 2005 Canonical Ltd.

//

// This software may be used and distributed according to the terms

// of the GNU General Public License, incorporated herein by reference.

var colors = [

	[ 1.0, 0.0, 0.0 ],

	[ 1.0, 1.0, 0.0 ],

	[ 0.0, 1.0, 0.0 ],

	[ 0.0, 1.0, 1.0 ],

	[ 0.0, 0.0, 1.0 ],

	[ 1.0, 0.0, 1.0 ],

	[ 1.0, 1.0, 0.0 ],

	[ 0.0, 0.0, 0.0 ]

];

function BranchRenderer(canvas_id, content_id) {

	this.canvas = document.getElementById(canvas_id);

	var t = document.getElementById(content_id);

	this.canvas.setAttribute('height',t.clientHeight);

	if (!document.createElement("canvas").getContext)

		this.canvas = window.G_vmlCanvasManager.initElement(this.canvas);

	this.ctx = this.canvas.getContext('2d');

	this.ctx.strokeStyle = 'rgb(0, 0, 0)';

	this.ctx.fillStyle = 'rgb(0, 0, 0)';

	this.cur = [0, 0];

	this.line_width = 2.0;

	this.dot_radius = 3.5;

	this.calcColor = function(color, bg, fg) {

		color %= colors.length;

		var red = (colors[color][0] * fg) || bg;

		var green = (colors[color][1] * fg) || bg;

		var blue = (colors[color][2] * fg) || bg;

		red = Math.round(red * 255);

		green = Math.round(green * 255);

		blue = Math.round(blue * 255);

		var s = 'rgb(' + red + ', ' + green + ', ' + blue + ')';

		return s;

	}

	this.setColor = function(color, bg, fg) {

		var s = this.calcColor(color, bg, fg);

		this.ctx.strokeStyle = s;

		this.ctx.fillStyle = s;

	}

	this.render = function(data,canvasWidth) {

		var idx = 1;

		var rela = this.canvas;

		this.canvas.setAttribute('width',canvasWidth);

		var lineCount = 1;

		for (var i=0;i<data.length;i++) {

			var in_l = data[i][1];

			for (var j in in_l) {

				var m = in_l[j][0];

				if (m > lineCount)

					lineCount = m;

			}

		}

		var edge_pad = this.dot_radius + 2;

		var box_size = Math.min(18, Math.floor((canvasWidth - edge_pad*2)/(lineCount)));

		var base_x = canvasWidth - edge_pad;

		for (var i=0; i < data.length; ++i) {

			var row = document.getElementById("chg_"+idx);

			if (row == null)

				continue;

			var	next = document.getElementById("chg_"+(idx+1));

			var extra = 0;

			cur = data[i];

			node = cur[0];

			in_l = cur[1];

			var rowY = row.offsetTop + row.offsetHeight/2 - rela.offsetTop;

			var nextY = (next == null) ? rowY + row.offsetHeight/2 : next.offsetTop + next.offsetHeight/2 - rela.offsetTop;

			for (var j in in_l) {

				line = in_l[j];

				start = line[0];

				end = line[1];

				color = line[2];

				x = base_x - box_size * start;

				// figure out if this is a dead-end;

				// we want to fade away this line

				var dead_end = true;

				if (next != null) {

					nextdata = data[i+1];

					next_l = nextdata[1];

					found = false;

					for (var k=0; k < next_l.length; ++k) {

						if (next_l[k][0] == end) {

							dead_end = false;

							break;

						}

					}

				}

				if (dead_end) {

					var gradient = this.ctx.createLinearGradient(x,rowY,x,nextY);

					gradient.addColorStop(0,this.calcColor(color, 0.0, 0.65));

					gradient.addColorStop(1,this.calcColor(color, 1.0, 0.0));

					this.ctx.strokeStyle = gradient;

					this.ctx.fillStyle = gradient;

				}

				// if this is a merge of differently

				// colored line, make it a gradient towards

				// the merged color

				else if (color != node[1] && start == node[0])

				{

					var gradient = this.ctx.createLinearGradient(x,rowY,x,nextY);

					gradient.addColorStop(0,this.calcColor(node[1], 0.0, 0.65));

					gradient.addColorStop(1,this.calcColor(color, 0.0, 0.65));

					this.ctx.strokeStyle = gradient;

					this.ctx.fillStyle = gradient;

				}

				else

				{

					this.setColor(color, 0.0, 0.65);

				}

				this.ctx.lineWidth=this.line_width;

				this.ctx.beginPath();

				this.ctx.moveTo(x, rowY);

				if (start == end)

				{

					this.ctx.lineTo(x,nextY+extra,3);

				}

				else

				{

					var x2 = base_x - box_size * end;

					var ymid = (rowY+nextY) / 2;

					this.ctx.bezierCurveTo (x,ymid,x2,ymid,x2,nextY);

				}

				this.ctx.stroke();

			}

			column = node[0];

			color = node[1];

			x = base_x - box_size * column;

			this.setColor(color, 0.25, 0.75);

			idx++;

		}

	}

}