x = 0

            for line in lines:

                if line.startswith('diff'):

                    break

                x += 1

            # Append new line just like 'diff' command do

            stdout = '\n'.join(lines[x:]) + '\n'

        return stdout

    @LazyProperty

    def in_memory_changeset(self):

        """

        Returns ``GitInMemoryChangeset`` object for this repository.

        """

        return GitInMemoryChangeset(self)

    def clone(self, url, update_after_clone=True, bare=False):

        """

        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 = ['pull']

        cmd.append("--ff-only")

        cmd.append(url)

        cmd = ' '.join(cmd)

        # If error occurs run_git_command raises RepositoryError already

        self.run_git_command(cmd)

    @LazyProperty

    def workdir(self):

        """

        Returns ``Workdir`` instance for this repository.

        """

        return GitWorkdir(self)

    def get_config_value(self, section, name, config_file=None):

        """

        Returns configuration value for a given [``section``] and ``name``.

        :param section: Section we want to retrieve value from

        :param name: Name of configuration we want to retrieve

        :param config_file: A path to file which should be used to retrieve

          configuration from (might also be a list of file paths)

        """

        if config_file is None:

            config_file = []

        elif isinstance(config_file, basestring):

            config_file = [config_file]

        def gen_configs():

            for path in config_file + self._config_files:

                try:

                    yield ConfigFile.from_path(path)

                except (IOError, OSError, ValueError):

                    continue

        for config in gen_configs():

            try:

                return config.get(section, name)

            except KeyError:

                continue

        return None

    def get_user_name(self, config_file=None):

        """

        Returns user's name from global configuration file.

        :param config_file: A path to file which should be used to retrieve

          configuration from (might also be a list of file paths)

        """

        return self.get_config_value('user', 'name', config_file)

    def get_user_email(self, config_file=None):

        """

        Returns user's email from global configuration file.

        u = User.get_by_username(username)

        f = self.sa.query(UserFollowing)\

            .filter(UserFollowing.follows_user == u)\

            .filter(UserFollowing.user_id == user_id).scalar()

        return f is not None

    def get_followers(self, repo_id):

        if not isinstance(repo_id, int):

            repo_id = getattr(Repository.get_by_repo_name(repo_id), 'repo_id')

        return self.sa.query(UserFollowing)\

                .filter(UserFollowing.follows_repo_id == repo_id).count()

    def get_forks(self, repo_id):

        if not isinstance(repo_id, int):

            repo_id = getattr(Repository.get_by_repo_name(repo_id), 'repo_id')

        return self.sa.query(Repository)\

                .filter(Repository.fork_id == repo_id).count()

    def mark_as_fork(self, repo, fork, user):

        repo = self.__get_repo(repo)

        fork = self.__get_repo(fork)

        repo.fork = fork

        self.sa.add(repo)

        return repo

    def pull_changes(self, repo_name, username):

        dbrepo = Repository.get_by_repo_name(repo_name)

        clone_uri = dbrepo.clone_uri

        if not clone_uri:

            raise Exception("This repository doesn't have a clone uri")

        repo = dbrepo.scm_instance

        try:

            extras = {

                'ip': '',

                'username': username,

                'action': 'push_remote',

                'repository': repo_name,

                'scm': repo.alias,

            }

            # inject ui extra param to log this action via push logger

            for k, v in extras.items():

                repo._repo.ui.setconfig('rhodecode_extras', k, v)

            repo.pull(clone_uri)

            self.mark_for_invalidation(repo_name)

        except:

            log.error(traceback.format_exc())

            raise

    def commit_change(self, repo, repo_name, cs, user, author, message,

                      content, f_path):

        if repo.alias == 'hg':

            from rhodecode.lib.vcs.backends.hg import \

                MercurialInMemoryChangeset as IMC

        elif repo.alias == 'git':

            from rhodecode.lib.vcs.backends.git import \

                GitInMemoryChangeset as IMC

        # decoding here will force that we have proper encoded values

        # in any other case this will throw exceptions and deny commit

        content = safe_str(content)

        path = safe_str(f_path)

        # message and author needs to be unicode

        # proper backend should then translate that into required type

        message = safe_unicode(message)

        author = safe_unicode(author)

        m = IMC(repo)

        m.change(FileNode(path, content))

        tip = m.commit(message=message,

                       author=author,

                       parents=[cs], branch=cs.branch)

        new_cs = tip.short_id

        action = 'push_local:%s' % new_cs

        action_logger(user, action, repo_name)

        self.mark_for_invalidation(repo_name)

    def create_node(self, repo, repo_name, cs, user, author, message, content,

                      f_path):

        if repo.alias == 'hg':

            from rhodecode.lib.vcs.backends.hg import MercurialInMemoryChangeset as IMC

        elif repo.alias == 'git':

            from rhodecode.lib.vcs.backends.git import GitInMemoryChangeset as IMC

        # decoding here will force that we have proper encoded values

        # in any other case this will throw exceptions and deny commit

        if isinstance(content, (basestring,)):

            content = safe_str(content)