Merge branch features/gitlab-gists-requests into devel

Author: guyzmo

buildout.cfg

@@ -9,7 +9,7 @@ develop-eggs-directory = ${buildout:directory}/var/develop-eggs
 parts-directory    = ${buildout:directory}/var/parts
 # develop-dir        = ${buildout:directory}/var/clone/
 # extensions=gp.vcsdevelop
-# vcs-extend-develop=git+https://github.com/gitpython-developers/GitPython#egg=GitPython
+# vcs-extend-develop=git+https://github.com/…@…#egg=…
 
 [git_repo]
 recipe = zc.recipe.egg

git_repo/repo.py

@@ -438,12 +438,14 @@ def do_request_fetch(self):
     @register_action('snippet', 'list')
     def do_gist_list(self):
         service = self.get_service(lookup_repository=False)
-        if self.gist_ref:
+        if 'github' == service.name and self.gist_ref:
             log.info("{:15}\t{:>7}\t{}".format('language', 'size', 'name'))
+        else:
+            log.info("{:56}\t{}".format('id', 'title'.ljust(60)))
+        if self.gist_ref:
             for gist_file in service.gist_list(self.gist_ref):
                 print("{:15}\t{:7}\t{}".format(*gist_file))
         else:
-            log.info("{:56}\t{}".format('id', 'title'.ljust(60)))
             for gist in service.gist_list():
                 print( "{:56}\t{}".format(gist[0], gist[1]))
         return 0

git_repo/services/ext/github.py

@@ -266,7 +266,7 @@ def request_fetch(self, user, repo, request, pull=False):
         try:
             for remote in self.repository.remotes:
                 if remote.name == self.name:
-                    local_branch_name = 'request/{}'.format(request)
+                    local_branch_name = 'requests/github/{}'.format(request)
                     self.fetch(
                         remote,
                         'pull/{}/head'.format(request),

git_repo/services/ext/gitlab.py

@@ -7,8 +7,11 @@
 from ...exceptions import ArgumentError, ResourceError, ResourceExistsError, ResourceNotFoundError
 
 import gitlab
-from gitlab.exceptions import GitlabCreateError, GitlabGetError
+from gitlab.exceptions import GitlabListError, GitlabCreateError, GitlabGetError
 
+from git.exc import GitCommandError
+
+import os
 import json, time
 
 @register_target('lab', 'gitlab')
@@ -131,14 +134,198 @@ def get_repository(self, user, repo):
             return self.gl.projects.get('{}/{}'.format(user, repo))
         except GitlabGetError as err:
             if err.response_code == 404:
-                raise ResourceNotFoundError("Cannot delete: repository {}/{} does not exists.".format(user, repo)) from err
+                raise ResourceNotFoundError("Cannot get: repository {}/{} does not exists.".format(user, repo)) from err
 
     @classmethod
     def get_auth_token(cls, login, password, prompt=None):
         gl = gitlab.Gitlab(url='https://{}'.format(cls.fqdn), email=login, password=password)
         gl.auth()
         return gl.user.private_token
 
+    def _deconstruct_snippet_uri(self, uri):
+        path = uri.split('https://{}/'.format(self.fqdn))[-1].split('/')
+        if 4 == len(path):
+            user, project_name, _, snippet_id = path
+        elif 2 == len(path):
+            _, snippet_id = path
+            project_name = None
+            user = None
+        elif 1 == len(path):
+            snippet_id = path[0]
+            project_name = None
+            user = None
+        else:
+            raise ResourceNotFoundError('URL is not of a snippet')
+        return (user, project_name, snippet_id)
+
+    def gist_list(self, project=None):
+        if not project:
+            try:
+                for snippet in self.gl.snippets.list():
+                    yield (snippet.web_url, snippet.title)
+            except GitlabListError as err:
+                if err.response_code == 404:
+                    raise ResourceNotFoundError('Feature not available, please upgrade your gitlab instance.') from err
+                raise ResourceError('Cannot list snippet') from err
+        else:
+            if '/' not in project:
+                project = '/'.join([self.username, project])
+            try:
+                project = self.gl.projects.get(project)
+                for snippet in project.snippets.list():
+                    yield (snippet.web_url, 0, snippet.title)
+            except GitlabGetError as err:
+                raise ResourceNotFoundError('Could not retrieve project "{}".'.format(project)) from err
+
+    def gist_fetch(self, snippet, fname=None):
+        if fname:
+            raise ArgumentError('Snippets contain only single file in gitlab.')
+        try:
+            *_, snippet_id = self._deconstruct_snippet_uri(snippet)
+            snippet = self.gl.snippets.get(id=snippet_id)
+        except GitlabGetError as err:
+            if err.response_code == 404:
+                if "The page you're looking for could not be found." in err.response_body.decode('utf-8'):
+                    raise ResourceNotFoundError('Feature not available, please upgrade your gitlab instance.') from err
+                raise ResourceNotFoundError('Cannot fetch snippet') from err
+            raise ResourceError('Cannot fetch snippet') from err
+        except Exception as err:
+            raise ResourceNotFoundError('Could not find snippet') from err
+
+        return snippet.raw().decode('utf-8')
+
+    def gist_clone(self, gist):
+        raise ArgumentError('Snippets cannot be cloned in gitlab.')
+
+    def gist_create(self, gist_pathes, description, secret=False):
+        def load_file(fname, path='.'):
+            with open(os.path.join(path, fname), 'r') as f:
+                return f.read()
+
+        if len(gist_pathes) > 2:
+            raise ArgumentError('Snippets contain only single file in gitlab.')
+
+        data = {
+            'title': description,
+            'visibility_level': 0 if secret else 20
+        }
+
+        try:
+
+            if len(gist_pathes) == 2:
+                project = gist_pathes[0]
+                if '/' in project:
+                    *namespace, project = project.split('/')
+                    namespace = '/'.join(namespace)
+                else:
+                    namespace = self.username
+                gist_path = gist_pathes[1]
+                data.update({
+                        'project_id': '/'.join([namespace, project]),
+                        'code': load_file(gist_path),
+                        'file_name': os.path.basename(gist_path),
+                    }
+                )
+                gist = self.gl.project_snippets.create(data)
+
+            elif len(gist_pathes) == 1:
+                gist_path = gist_pathes[0]
+                data.update({
+                        'content': load_file(gist_path),
+                        'file_name': os.path.basename(gist_path),
+                    }
+                )
+                gist = self.gl.snippets.create(data)
+
+            return gist.web_url
+        except GitlabCreateError as err:
+            if err.response_code == 422:
+                raise ResourceNotFoundError('Feature not available, please upgrade your gitlab instance.') from err
+            raise ResourceError('Cannot create snippet') from err
+
+    def gist_delete(self, snippet):
+        try:
+            _, project, snippet_id = self._deconstruct_snippet_uri(snippet)
+            if project:
+                if '/' in project:
+                    *namespace, project = project.split('/')
+                    namespace = '/'.join(namespace)
+                else:
+                    namespace = self.username
+                snippet = self.gl.projects.get(
+                        '/'.join([namespace, project])
+                    ).snippets.get(id=snippet_id)
+            else:
+                snippet = self.gl.snippets.get(id=snippet_id)
+        except GitlabCreateError as err:
+            if err.response_code == 422:
+                raise ResourceNotFoundError('Cannot delete snippet, please upgrade your gitlab instance.') from err
+            raise ResourceError('Cannot delete snippet') from err
+        except Exception as err:
+            raise ResourceNotFoundError('Could not find snippet') from err
+
+        return snippet.delete()
+
+    def request_create(self, user, repo, local_branch, remote_branch, title, description=None):
+        try:
+            repository = self.gl.projects.get('/'.join([user, repo]))
+            if not repository:
+                raise ResourceNotFoundError('Could not find repository `{}/{}`!'.format(user, repo))
+            if not local_branch:
+                remote_branch = self.repository.active_branch.name or self.repository.active_branch.name
+            if not remote_branch:
+                local_branch = repository.master_branch or 'master'
+            request = self.gl.project_mergerequests.create(
+                    project_id=repository.id,
+                    data= {
+                        'source_branch':local_branch,
+                        'target_branch':remote_branch,
+                        'title':title,
+                        'description':description
+                        }
+                    )
+        except GitlabGetError as err:
+            raise ResourceNotFoundError(err) from err
+        except Exception as err:
+            raise ResourceError("Unhandled error: {}".format(err)) from err
+
+        return {'local': local_branch,
+                'remote': remote_branch,
+                'ref': request.iid}
+
+    def request_list(self, user, repo):
+        project = self.gl.projects.get('/'.join([user, repo]))
+        for mr in self.gl.project_mergerequests.list(project_id=project.id):
+            yield ( str(mr.iid),
+                    mr.title,
+                    'https://{}/{}/{}/merge_requests/{}'.format(
+                        self.fqdn,
+                        project.namespace.name,
+                        project.name,
+                        mr.iid
+                        )
+                    )
+
+    def request_fetch(self, user, repo, request, pull=False):
+        if pull:
+            raise NotImplementedError('Pull operation on requests for merge are not yet supported')
+        try:
+            for remote in self.repository.remotes:
+                if remote.name == self.name:
+                    local_branch_name = 'requests/gitlab/{}'.format(request)
+                    self.fetch(
+                        remote,
+                       'merge_requests/{}/head'.format(request),
+                        local_branch_name
+                    )
+                    return local_branch_name
+            else:
+                raise ResourceNotFoundError('Could not find remote {}'.format(self.name))
+        except GitCommandError as err:
+            if 'Error when fetching: fatal: Couldn\'t find remote ref' in err.command[0]:
+                raise ResourceNotFoundError('Could not find opened request #{}'.format(request)) from err
+            raise err
+
     @property
     def user(self):
         return self.gl.user.username

requirements.txt

@@ -3,5 +3,5 @@ progress
 GitPython>=2.1.0
 uritemplate.py==2.0.0
 github3.py==0.9.5
-python-gitlab>=0.13
+python-gitlab>=0.18
 bitbucket-api

tests/helpers.py

@@ -618,7 +618,7 @@ def action_request_list(self, namespace, repository, rq_list_data=[]):
             for i, rq in enumerate(rq_list_data):
                 assert requests[i] == rq
 
-    def action_request_fetch(self, namespace, repository, request, pull=False, fail=False):
+    def action_request_fetch(self, namespace, repository, request, pull=False, fail=False, remote_branch='pull', local_branch='requests'):
         local_slug = self.service.format_path(namespace=namespace, repository=repository, rw=False)
         with self.recorder.use_cassette(self._make_cassette_name()):
             with self.mockup_git(namespace, repository):
@@ -635,10 +635,14 @@ def action_request_fetch(self, namespace, repository, request, pull=False, fail=
                         'Resolving deltas: 100% (5126/5126), done.',
                         'From {}:{}/{}'.format(self.service.fqdn, namespace, repository),
                         ' * branch            master     -> FETCH_HEAD',
-                        ' * [new branch]      master     -> {}/master'.format(self.service.name)]).encode('utf-8'),
+                        ' * [new branch]      master     -> {1}/{0}'.format(request, local_branch)]).encode('utf-8'),
                     0),
                     ('git version', b'git version 2.8.0', b'', 0),
-                    ('git fetch --progress -v {0} pull/{1}/head:request/{1}'.format(self.service.name, request), b'', '\n'.join([
+                    ('git fetch --progress -v {0} {2}/{1}/head:{3}/{1}'.format(
+                            self.service.name,
+                            request,
+                            remote_branch,
+                            local_branch), b'', '\n'.join([
                         'POST git-upload-pack (140 bytes)',
                         'remote: Counting objects: 8318, done.',
                         'remote: Compressing objects: 100% (3/3), done.',
@@ -657,22 +661,26 @@ def action_request_fetch(self, namespace, repository, request, pull=False, fail=
             with self.mockup_git(namespace, repository):
                 self.set_mock_popen_commands([
                     ('git version', b'git version 2.8.0', b'', 0),
-                    ('git fetch --progress -v {0} pull/{1}/head:request/{1}'.format(self.service.name, request), b'', '\n'.join([
+                    ('git fetch --progress -v {0} {2}/{1}/head:{3}/{1}'.format(
+                            self.service.name,
+                            request,
+                            remote_branch,
+                            local_branch), b'', '\n'.join([
                         'POST git-upload-pack (140 bytes)',
                         'remote: Counting objects: 8318, done.',
                         'remote: Compressing objects: 100% (3/3), done.',
                         'remote: Total 8318 (delta 0), reused 0 (delta 0), pack-reused 8315',
                         'Receiving objects: 100% (8318/8318), 3.59 MiB | 974.00 KiB/s, done.',
                         'Resolving deltas: 100% (5126/5126), done.',
                         'From {}:{}/{}'.format(self.service.fqdn, namespace, repository),
-                        ' * [new branch]      master     -> request/{}'.format(request)]).encode('utf-8'),
+                        ' * [new branch]      master     -> {1}/{0}'.format(request, local_branch)]).encode('utf-8'),
                     0)
                 ])
                 self.service.request_fetch(repository, namespace, request)
 
     def action_request_create(self,
             namespace, repository, branch,
-            title, description,
+            title, description, service,
             create_repository='test_create_requests',
             create_branch='pr-test'):
         '''
@@ -723,7 +731,7 @@ def prepare_project_for_test():
                     test.write('La meilleure façon de ne pas avancer est de suivre une idée fixe. J.Prévert')
                 self.repository.git.add('second_file')
                 self.repository.git.commit(message='Second commit')
-                self.repository.git.push('github', create_branch)
+                self.repository.git.push(service, create_branch)
             yield
             if will_record:
                 self.service.delete(create_repository)
@@ -749,7 +757,7 @@ def action_gist_list(self, gist=None, gist_list_data=[]):
                 for i, g in enumerate(gist_list_data):
                     assert gists[i] == g
             else:
-                gist_files = list(self.service.gist_list())
+                gist_files = list(self.service.gist_list(gist))
                 for i, gf in enumerate(gist_list_data):
                     assert gist_files[i] == gf