aboutsummaryrefslogtreecommitdiffstats
path: root/github3/handlers/gists.py
blob: ed03c31f8af314846aa9f47d3018a9c3c42f3c97 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
#!/usr/bin/env python
# -*- encoding: utf-8 -*-

from .base import Handler, MimeTypeMixin
from github3 import models


class Gist(Handler, MimeTypeMixin):
    """ Gist handler with public access """

    prefix = 'gists'

    def __repr__(self):
        return '<Gist handler>'

    def all_gists(self, limit=None):
        """ Return all public gists

        NOTE: It returns all gists in github environment. Maybe you
        want to use `limit` parameter
        """

        return self._get_resources('', model=models.Gist, limit=limit)

    def get(self, gist_id):
        """ Return gist

        param `gist_id`: Gist id
        """

        return self._get_resource(gist_id, model=models.Gist)

    def get_comments(self, gist_id, limit=None):
        """ Return gist's comments

        param `gist_id`: Gist id
        param `limit`: Number of comments
        """

        return self._get_resources('%s/comments' % gist_id,
            model=models.GistComment, limit=limit,
            headers=self.mime_header())

    def get_comment(self, comment_id):
        """ Return gist's comment

        param `comment_id`: Comment id
        """

        return self._get_resource('comments/%s' % comment_id,
            model=models.GistComment, headers=self.mime_header())


class AuthGist(Gist):

    def all_gists(self, limit=None):
        """ Return all public gists

        NOTE: It returns all gists in github environment. Maybe you
        want to use `limit` parameter
        """

        return self._get_resources('public', model=models.Gist, limit=limit)

    def my_gists(self, limit=None):
        """ Return authenticated user's gists

        param `limit`: Number of gists
        """

        return self._get_resources('', model=models.Gist, limit=limit)

    def my_starred_gists(self, limit=None):
        """ Return authenticated user's starred gists

        param `limit`: Number of gists
        """

        return self._get_resources('starred', model=models.Gist, limit=limit)

    def create_gist(self, is_public, files, desc=None):
        """ Create and return a gist """

        data = {
            'public': bool(is_public),
            'files': files,  # TODO: Issue #1
            'desc': desc or '',
        }
        return self._post_resource('', data=data, model=models.Gist)

    def star_gist(self, gist_id):
        """ Star a gist

        param `gist_id`: Gist id to star
        """

        return self._put('%s/star' % gist_id)

    def unstar_gist(self, gist_id):
        """ Unstar a gist

        param `gist_id`: Gist id to unstar
        """

        return self._delete('%s/star' % gist_id)

    def is_starred(self, gist_id):
        """ True if gist is starred

        param `gist_id`: Gist id
        """

        return self._bool('%s/star' % gist_id)

    def fork_gist(self, gist_id):
        """ Return forked gist from id

        param `gist_id`: Gist id to be forked...
        """

        return self._post_resource('%s/fork' % gist_id, data=None,
                                   model=models.Gist)

    def delete_gist(self, gist_id):
        """ Delete the gist

        param `gist_id`: Gist id
        """

        return self._delete(str(gist_id))

    def create_comment(self, gist_id, comment):
        """ Create comment into gist """

        data = {'body': comment}
        return self._post_resource('%s/comments' % gist_id, data=data,
                            model=models.GistComment)

    def delete_comment(self, comment_id):
        """ Delete comment

        param `comment_id`: Comment id
        """

        return self._delete('comments/%s' % comment_id)