h.shorter(cs.message, 160)

        )

    def __changes(self, cs):

        changes = []

        diff_processor = DiffProcessor(cs.diff(),

                                       diff_limit=self.feed_diff_limit)

        _parsed = diff_processor.prepare(inline_diff=False)

        limited_diff = False

        if isinstance(_parsed, LimitedDiffContainer):

            limited_diff = True

        for st in _parsed:

            st.update({'added': st['stats']['added'],

                       'removed': st['stats']['deleted']})

            changes.append('\n %(operation)s %(filename)s '

                           '(%(added)s lines added, %(removed)s lines removed)'

                            % st)

        if limited_diff:

            changes = changes + ['\n ' +

                                 _('Changeset was too big and was cut off...')]

        return diff_processor, changes

    def __get_desc(self, cs):

        #branches, tags, bookmarks

        if cs.branch:

            desc_msg.append('branch: %s<br/>' % cs.branch)

        if h.is_hg(c.rhodecode_repo):

            for book in cs.bookmarks:

                desc_msg.append('bookmark: %s<br/>' % book)

        for tag in cs.tags:

            desc_msg.append('tag: %s<br/>' % tag)

        diff_processor, changes = self.__changes(cs)

        # rev link

        _url = url('changeset_home', repo_name=cs.repository.name,

                   revision=cs.raw_id, qualified=True)

        desc_msg.append('changeset: <a href="%s">%s</a>' % (_url, cs.raw_id[:8]))

        desc_msg.append('<pre>')

        desc_msg.append(cs.message)

        desc_msg.append('\n')

        desc_msg.extend(changes)

        if self.include_diff:

            desc_msg.append('\n\n')

            desc_msg.append(diff_processor.as_raw())

        desc_msg.append('</pre>')

        return map(safe_unicode, desc_msg)

            repo = None

            for rev in revs_ids[:revs_top_limit]:

                _op, _name = _get_op(rev)

                # we want parsed changesets, or new log store format is bad

                if parse_cs:

                    try:

                        if repo is None:

                            repo = user_log.repository.scm_instance

                        _rev = repo.get_changeset(rev)

                        revs.append(_rev)

                    except ChangesetDoesNotExistError:

                        log.error('cannot find revision %s in this repo' % rev)

                        revs.append(rev)

                        continue

                else:

                    _rev = AttributeDict({

                        'short_id': rev[:12],

                        'raw_id': rev,

                        'message': '',

                        'op': _op,

                        'ref_name': _name

                    })

                    revs.append(_rev)

            [lnk(rev, repo_name) for rev in revs[:revs_limit]]

        _op1, _name1 = _get_op(revs_ids[0])

        _op2, _name2 = _get_op(revs_ids[-1])

        _rev = '%s...%s' % (_name1, _name2)

        compare_view = (

            ' <div class="compare_view tooltip" title="%s">'

            '<a href="%s">%s</a> </div>' % (

                _('Show all combined changesets %s->%s') % (

                    revs_ids[0][:12], revs_ids[-1][:12]

                ),

                url('changeset_home', repo_name=repo_name,

                    revision=_rev

                ),

                _('compare view')

            )

        )

        # if we have exactly one more than normally displayed

        # just display it, takes less space than displaying

        # "and 1 more revisions"

        if len(revs_ids) == revs_limit + 1:

            rev = revs[revs_limit]

            cs_links.append(", " + lnk(rev, repo_name))

from rhodecode.lib.exceptions import HTTPLockedRC

from rhodecode.lib.hooks import pre_pull

class SimpleGitUploadPackHandler(dulserver.UploadPackHandler):

    def handle(self):

        write = lambda x: self.proto.write_sideband(1, x)

        graph_walker = dulserver.ProtocolGraphWalker(self,

                                                     self.repo.object_store,

                                                     self.repo.get_peeled)

        objects_iter = self.repo.fetch_objects(

          graph_walker.determine_wants, graph_walker, self.progress,

          get_tagged=self.get_tagged)

        # Did the process short-circuit (e.g. in a stateless RPC call)? Note

        # that the client still expects a 0-object pack in most cases.

        if objects_iter is None:

            return

        self.progress("counting objects: %d, done.\n" % len(objects_iter))

        dulserver.write_pack_objects(dulserver.ProtocolFile(None, write),

                                     objects_iter)

        for msg in messages:

            self.progress(msg + "\n")

        # we are done

        self.proto.write("0000")

dulserver.DEFAULT_HANDLERS = {

  #git-ls-remote, git-clone, git-fetch and git-pull

  'git-upload-pack': SimpleGitUploadPackHandler,

  #git-push

  'git-receive-pack': dulserver.ReceivePackHandler,

}

# not used for now until dulwich get's fixed

#from dulwich.repo import Repo

#from dulwich.web import make_wsgi_chain

from paste.httpheaders import REMOTE_USER, AUTH_TYPE

from webob.exc import HTTPNotFound, HTTPForbidden, HTTPInternalServerError, \

    HTTPBadRequest, HTTPNotAcceptable

from rhodecode.lib.utils2 import safe_str, fix_PATH, get_server_url,\

    _set_extras

            else:

                f.write("[%s \"%s\"]\n" % (section_name, subsection_name))

            for key, value in values.iteritems():

                f.write("%s = %s\n" % (key, _escape_value(value)))

class StackedConfig(Config):

    """Configuration which reads from multiple config files.."""

    def __init__(self, backends, writable=None):

        self.backends = backends

        self.writable = writable

    def __repr__(self):

        return "<%s for %r>" % (self.__class__.__name__, self.backends)

    @classmethod

    def default_backends(cls):

        """Retrieve the default configuration.

        This will look in the repository configuration (if for_path is

        specified), the users' home directory and the system

        configuration.

        """

        backends = []

        for path in paths:

            try:

                cf = ConfigFile.from_path(path)

            except (IOError, OSError), e:

                if e.errno != errno.ENOENT:

                    raise

                else:

                    continue

            backends.append(cf)

        return backends

    def get(self, section, name):

        for backend in self.backends:

            try:

                return backend.get(section, name)

            except KeyError:

                pass

        raise KeyError(name)

    def set(self, section, name, value):

        if self.writable is None:

            raise NotImplementedError(self.set)

        return self.writable.set(section, name, value)

        """

        Tries to clone changes from external location.

        :param update_after_clone: If set to ``False``, git won't checkout

          working directory

        :param bare: If set to ``True``, repository would be cloned into

          *bare* git repository (no working directory at all).

        """

        url = self._get_url(url)

        cmd = ['clone']

        if bare:

            cmd.append('--bare')

        elif not update_after_clone:

            cmd.append('--no-checkout')

        cmd += ['--', '"%s"' % url, '"%s"' % self.path]

        cmd = ' '.join(cmd)

        # If error occurs run_git_command raises RepositoryError already

        self.run_git_command(cmd)

    def pull(self, url):

        """

        Tries to pull changes from external location.

        """

        url = self._get_url(url)

        cmd = ' '.join(cmd)

        # If error occurs run_git_command raises RepositoryError already

        self.run_git_command(cmd)

    def fetch(self, url):

        """

        Tries to pull changes from external location.

        """

        url = self._get_url(url)

        so, se = self.run_git_command('ls-remote -h %s' % url)

        refs = []

        for line in (x for x in so.splitlines()):

            sha, ref = line.split('\t')

            refs.append(ref)

        refs = ' '.join(('+%s:%s' % (r, r) for r in refs))

        cmd = '''fetch %s -- %s''' % (url, refs)

        self.run_git_command(cmd)

    @LazyProperty

    def workdir(self):

        """

        Returns ``Workdir`` instance for this repository.

        """

        return GitWorkdir(self)