Session().commit()

            return dict(

                msg='deleted gist ID:%s' % (gist.gist_access_id,),

                gist=None

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to delete gist ID:%s'

                               % (gist.gist_access_id,))

    # permission check inside

    def get_changesets(self, repoid, start=None, end=None, start_date=None,

        repo = get_repo_or_error(repoid)

        if not HasRepoPermissionLevel('read')(repo.repo_name):

            raise JSONRPCError('Access denied to repo %s' % repo.repo_name)

        format = "%Y-%m-%dT%H:%M:%S"

        try:

            return [e.__json__(with_file_list) for e in

                repo.scm_instance.get_changesets(start,

                                                 end,

                                                 datetime.strptime(start_date, format) if start_date else None,

                                                 datetime.strptime(end_date, format) if end_date else None,

                                                 branch_name,

        except EmptyRepositoryError as e:

            raise JSONRPCError(e.message)

    # permission check inside

    def get_changeset(self, repoid, raw_id, with_reviews=Optional(False)):

        repo = get_repo_or_error(repoid)

        if not HasRepoPermissionLevel('read')(repo.repo_name):

            raise JSONRPCError('Access denied to repo %s' % repo.repo_name)

        changeset = repo.get_changeset(raw_id)

        if isinstance(changeset, EmptyChangeset):

            raise JSONRPCError('Changeset %s does not exist' % raw_id)

        raise NotImplementedError

    def __iter__(self):

        """

        Allows Repository objects to be iterated.

        *Requires* implementation of ``__getitem__`` method.

        """

        for revision in self.revisions:

            yield self.get_changeset(revision)

    def get_changesets(self, start=None, end=None, start_date=None,

        """

        Returns iterator of ``BaseChangeset`` objects from start to end,

        both inclusive.

        :param start: None or str

        :param end: None or str

        :param start_date:

        :param end_date:

        :param branch_name:

        :param reversed:

        """

        raise NotImplementedError

    def get_changeset(self, revision=None):

        """

        Returns ``GitChangeset`` object representing commit from git repository

        at the given revision or head (most recent commit) if None given.

        """

        if isinstance(revision, GitChangeset):

            return revision

        revision = self._get_revision(revision)

        changeset = GitChangeset(repository=self, revision=revision)

        return changeset

    def get_changesets(self, start=None, end=None, start_date=None,

        """

        Returns iterator of ``GitChangeset`` objects from start to end (both

        are inclusive), in ascending date order (unless ``reverse`` is set).

        :param start: changeset ID, as str; first returned changeset

        :param end: changeset ID, as str; last returned changeset

        :param start_date: if specified, changesets with commit date less than

          ``start_date`` would be filtered out from returned set

        :param end_date: if specified, changesets with commit date greater than

          ``end_date`` would be filtered out from returned set

        :param branch_name: if specified, changesets not reachable from given

          branch would be filtered out from returned set

        """

        if branch_name and branch_name not in self.branches:

            raise BranchDoesNotExistError("Branch '%s' not found"

                                          % branch_name)

        # actually we should check now if it's not an empty repo to not spaw

        # subprocess commands

        if self._empty:

            raise EmptyRepositoryError("There are no changesets yet")

        # %H at format means (full) commit hash, initial hashes are retrieved

        # in ascending date order

        cmd = ['log', '--date-order', '--reverse', '--pretty=format:%H']

        if start_date:

            cmd += ['--since', start_date.strftime('%m/%d/%y %H:%M:%S')]

        if end_date:

            cmd += ['--until', end_date.strftime('%m/%d/%y %H:%M:%S')]

        if branch_name:

            cmd.append(branch_name)

        else:

            cmd.append(settings.GIT_REV_FILTER)

        revs = self.run_git_command(cmd)[0].splitlines()

        start_pos = 0

        end_pos = len(revs)

        return os.path.join(self.path, '.hg', '.hgrc')

    def get_changeset(self, revision=None):

        """

        Returns ``MercurialChangeset`` object representing repository's

        changeset at the given ``revision``.

        """

        revision = self._get_revision(revision)

        changeset = MercurialChangeset(repository=self, revision=revision)

        return changeset

    def get_changesets(self, start=None, end=None, start_date=None,

        """

        Returns iterator of ``MercurialChangeset`` objects from start to end

        (both are inclusive)

        :param start: None, str, int or mercurial lookup format

        :param end:  None, str, int or mercurial lookup format

        :param start_date:

        :param end_date:

        :param branch_name:

        :param reversed: return changesets in reversed order

        """

            raise RepositoryError("Start revision '%s' cannot be "

                                  "after end revision '%s'" % (start, end))

        if branch_name and branch_name not in self.allbranches.keys():

            msg = ("Branch %s not found in %s" % (branch_name, self))

            raise BranchDoesNotExistError(msg)

        if end_pos is not None:

            end_pos += 1

        # filter branches

        filter_ = []

        if branch_name:

            filter_.append('branch("%s")' % (branch_name))

        if start_date:

            filter_.append('date(">%s")' % start_date)

        if end_date:

            filter_.append('date("<%s")' % end_date)

            revisions = scmutil.revrange(self._repo, [revspec])

        else:

            revisions = self.revisions

        # this is very much a hack to turn this into a list; a better solution

        # would be to get rid of this function entirely and use revsets

        revs = list(revisions)[start_pos:end_pos]

        if reverse:

            revs = reversed(revs)

        return CollectionGenerator(self, revs)

        expected = Setting.get_server_info()

        self._compare_ok(id_, expected, given=response.body)

    def test_api_get_changesets(self):

        id_, params = _build_data(self.apikey, 'get_changesets',

                                  repoid=self.REPO, start=0, end=2)

        response = api_call(self, params)

        result = json.loads(response.body)["result"]

        assert len(result) == 3

        assert 'message' in result[0]

        assert 'added' not in result[0]

    def test_api_get_changesets_with_branch(self):

        if self.REPO == 'vcs_test_hg':

            branch = 'stable'

        else:

            pytest.skip("skipping due to missing branches in git test repo")

        id_, params = _build_data(self.apikey, 'get_changesets',

                                  repoid=self.REPO, branch_name=branch, start_date="2011-02-24T00:00:00")

        response = api_call(self, params)

        result = json.loads(response.body)["result"]

        assert len(result) == 5

        assert 'message' in result[0]

        assert 'added' not in result[0]