1
=== added directory 'contrib/rules'
2
=== added file 'contrib/rules/do_checks.py'
3
--- contrib/rules/do_checks.py	1970-01-01 00:00:00 +0000
4
+++ contrib/rules/do_checks.py	2011-05-20 05:15:12 +0000
5
@@ -0,0 +1,329 @@
6
1
#!/usr/bin/env python
7
2
# vim: tabstop=4 shiftwidth=4 softtabstop=4
8
3
9
4
# Copyright 2011 Justin Santa Barbara
10
5
# All Rights Reserved.
11
6
#
12
7
#    Licensed under the Apache License, Version 2.0 (the "License"); you may
13
8
#    not use this file except in compliance with the License. You may obtain
14
9
#    a copy of the License at
15
10
#
16
11
#         http://www.apache.org/licenses/LICENSE-2.0
17
12
#
18
13
#    Unless required by applicable law or agreed to in writing, software
19
14
#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
20
15
#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
21
16
#    License for the specific language governing permissions and limitations
22
17
#    under the License.
23
18
24
19
25
20
import gflags
26
21
import imp
27
22
import os
28
23
import re
29
24
import sys
30
25
31
26
import __main__
32
27
33
28
34
29
FLAGS = gflags.FLAGS
35
30
gflags.DEFINE_enum('format', 'pretty', ['pretty', 'pylint', 'pep8'],
36
31
                   'Output format to use')
37
32
38
33
39
34
class SourceFile(object):
40
35
    """A source code file."""
41
36
42
37
    def __init__(self, path):
43
38
        self.path = path
44
39
45
40
        f = open(path, 'r')
46
41
        code = f.read()
47
42
        code = code.replace('\r\n', '\n')
48
43
        code = code.replace('\n\r', '\n')
49
44
        self.code = code
50
45
        self.lines = code.splitlines()
51
46
        f.close()
52
47
        self.module = None
53
48
54
49
    def get_module(self):
55
50
        # NOTE(justinsb): This would be nice, but causes errors because the
56
51
        # code is actually executed (e.g. flags)
57
52
        if self.module is None:
58
53
            mod_name, _ext = os.path.splitext(os.path.split(self.path)[-1])
59
54
            self.module = imp.load_source(mod_name, self.path)
60
55
        return self.module
61
56
62
57
    def map_to_line_index(self, index):
63
58
        line_index = 0
64
59
        for i in xrange(index):
65
60
            if self.code[i] == '\n':
66
61
                line_index = line_index + 1
67
62
        return line_index
68
63
69
64
70
65
class Violation(object):
71
66
    """Records a rule infraction."""
72
67
73
68
    def __init__(self, src, index, tag, message):
74
69
        self.src = src
75
70
        self.index = index
76
71
        self.tag = tag
77
72
        self.message = message
78
73
79
74
    def print_warning(self):
80
75
        if FLAGS.format == 'pylint':
81
76
            self.print_pylint()
82
77
        elif FLAGS.format == 'pep8':
83
78
            self.print_pep8()
84
79
        else:
85
80
            self.print_pretty()
86
81
87
82
    def print_pylint(self):
88
83
        line = self.src.map_to_line_index(self.index)
89
84
        level = 'C'
90
85
        description = self.tag + ' ' + self.message
91
86
        print "%s:%s: [%s] %s" % (self.src.path, line + 1, level, description)
92
87
93
88
    def print_pep8(self):
94
89
        line = self.src.map_to_line_index(self.index)
95
90
        level = 'E'
96
91
        column = 1
97
92
        errnum = self.tag
98
93
        description = self.message
99
94
        print ("%s:%s:%s: %s%s %s" %
100
95
               (self.src.path, line + 1, column, level, errnum, description))
101
96
102
97
    def print_pretty(self):
103
98
        line = self.src.map_to_line_index(self.index)
104
99
        print "%s %s %s" % (self.tag, self.src.path, line + 1)
105
100
        if self.message != self.tag:
106
101
            print "\t%s" % (self.message)
107
102
        for i in xrange(line - 2, line + 3):
108
103
            if i < 0 or i >= len(self.src.lines):
109
104
                continue
110
105
            if i == line:
111
106
                prefix = "*   "
112
107
            else:
113
108
                prefix = "    "
114
109
            print prefix + self.src.lines[i]
115
110
116
111
117
112
class Checker(object):
118
113
    """Base class for all rule-checkers."""
119
114
120
115
    def __init__(self, src):
121
116
        self.src = src
122
117
123
118
    def do_check(self):
124
119
        raise NotImplementedError()
125
120
126
121
    def _build_error(self, index, message=None):
127
122
        tag = self.__class__.__name__
128
123
129
124
        if message is None:
130
125
            message = self.__class__.__doc__
131
126
            if message is None:
132
127
                message = tag
133
128
        return Violation(self.src, index, tag, message)
134
129
135
130
136
131
class DocStringChecker(Checker):
137
132
    """Checks docstrings against our style."""
138
133
139
134
    def do_check(self):
140
135
        errors = []
141
136
142
137
        # NOTE(justinsb): We hit a bug in re module: the below regex hangs
143
138
        # on some inputs.  In addition, it gets confused by quotes in docs.
144
139
        #regex = ':(\s)*"""((\s|[^"])*?)"""'
145
140
        #matches = re.finditer(regex, self.src.code)
146
141
147
142
        code = self.src.code
148
143
        start_pos = 0
149
144
150
145
        while True:
151
146
            docstring_start = code.find('"""', start_pos)
152
147
            if docstring_start == -1:
153
148
                break
154
149
155
150
            docstring_end = code.find('"""', docstring_start + 3)
156
151
            if docstring_end == -1:
157
152
                break
158
153
            docstring_end += 3
159
154
            docstring = code[docstring_start:docstring_end]
160
155
161
156
            errors += self._check_docstring(docstring_start, docstring)
162
157
163
158
            start_pos = docstring_end + 3
164
159
165
160
        return errors
166
161
167
162
    def _check_docstring(self, index, text):
168
163
        errors = []
169
164
        assert text.startswith('"""')
170
165
        assert text.endswith('"""')
171
166
        text = text[3:]
172
167
        text = text[:-3]
173
168
174
169
        lines = text.splitlines()
175
170
176
171
        if len(lines) == 0:
177
172
            message = "Docstrings should not be empty"
178
173
            errors.append(self._build_error(index, message=message))
179
174
180
175
        else:
181
176
            if lines[0].startswith(' '):
182
177
                message = "Docstrings do not start with whitespace"
183
178
                errors.append(self._build_error(index, message=message))
184
179
185
180
            if lines[0].endswith(' '):
186
181
                message = "Docstrings should not end with whitespace"
187
182
                errors.append(self._build_error(index, message=message))
188
183
189
184
        if len(lines) == 1:
190
185
            # Single line docstring
191
186
            if not lines[0].endswith('.'):
192
187
                message = "A single line docstring ends in a full stop (.)"
193
188
                errors.append(self._build_error(index, message=message))
194
189
195
190
        if len(lines) > 1:
196
191
            # Multi-line docstring
197
192
            if not lines[0].endswith('.'):
198
193
                message = ("The first line of a multi-line docstring ends in "
199
194
                           "a full stop (.)")
200
195
                errors.append(self._build_error(index, message=message))
201
196
202
197
            if lines[1]:
203
198
                message = ("The second line of a multi-line docstring must "
204
199
                           "be blank")
205
200
                errors.append(self._build_error(index, message=message))
206
201
207
202
            if lines[-2] or lines[-1].strip():
208
203
                message = ("Leave a blank line at the end of a multi-line "
209
204
                           "docstring")
210
205
                errors.append(self._build_error(index, message=message))
211
206
212
207
        # TODO(justinsb): On a class docstring, there should be a blank line
213
208
        # after the closing """
214
209
215
210
        return errors
216
211
217
212
218
213
class SimpleRegexChecker(Checker):
219
214
    """Base class for checkers that find violations based on regex."""
220
215
221
216
    def __init__(self, src, regex=None, skip_chars=0):
222
217
        super(SimpleRegexChecker, self).__init__(src)
223
218
        self.regex = regex
224
219
        self.skip_chars = skip_chars
225
220
226
221
    def _build_regex(self):
227
222
        raise NotImplementedError()
228
223
229
224
    def do_check(self):
230
225
        if not self.regex:
231
226
            self._build_regex()
232
227
233
228
        errors = []
234
229
        matches = re.finditer(self.regex, self.src.code)
235
230
        for match in matches:
236
231
            index = match.start()
237
232
238
233
            index = index + self.skip_chars
239
234
240
235
            errors.append(self._build_error(index))
241
236
242
237
        return errors
243
238
244
239
245
240
class TwoLinesAfterLog(SimpleRegexChecker):
246
241
    """After a LOG statement, leave two blank lines before the FLAGS/code."""
247
242
248
243
    def _build_regex(self):
249
244
        self.regex = '\nLOG(\s)*=[^\n]*\n[^\n][^\n]'
250
245
        # We matched a leading \n
251
246
        self.skip_chars = 1
252
247
253
248
254
249
class RethrowExceptionsCarefully(SimpleRegexChecker):
255
250
    """When rethrowing an exception, do 'raise', not 'raise e'.
256
251
257
252
    This preserves the stack trace.  Note that there are some complexities
258
253
    with eventlet, because eventlet can wipe the 'current' exception.
259
254
260
255
    """
261
256
262
257
    def _build_regex(self):
263
258
        self.regex = '\n[ ]*raise([ ]+)([a-z]+)\n'
264
259
        self.skip_chars = 1
265
260
266
261
267
262
class NoWhiteSpaceLeadingDocString(SimpleRegexChecker):
268
263
    """Don't start your docstrings with whitespace."""
269
264
270
265
    def _build_regex(self):
271
266
        self.regex = '\):\n(\s)*"""\s'
272
267
        self.skip_chars = 3
273
268
274
269
275
270
class AvoidAggressivePunctuation(SimpleRegexChecker):
276
271
    """Punctuation that includes repeated question marks can upset people."""
277
272
278
273
    def _build_regex(self):
279
274
        self.regex = '\?\?'
280
275
281
276
282
277
class OneSpaceInTodoOrNotes(SimpleRegexChecker):
283
278
    """Use one space in your TODO and NOTE comments."""
284
279
285
280
    def _build_regex(self):
286
281
        self.regex = '#(TODO|NOTE)'
287
282
288
283
289
284
class ClaimYourTodoAndNotes(SimpleRegexChecker):
290
285
    """Put your name in brackets after a TODO/NOTE."""
291
286
292
287
    def _build_regex(self):
293
288
        self.regex = '(TODO|NOTE)(\s*):'
294
289
295
290
296
291
def check_file(src_path):
297
292
    src = SourceFile(src_path)
298
293
    
299
294
    for x in dir(__main__):
300
295
        s = getattr(__main__, x)
301
296
        if not hasattr(s, 'do_check'):
302
297
            continue
303
298
304
299
        try:
305
300
            checker = s(src)
306
301
            errors = checker.do_check()
307
302
            for error in errors:
308
303
                error.print_warning()
309
304
        except NotImplementedError, AttributeError:
310
305
            pass
311
306
312
307
313
308
def check_dir(dir_path):
314
309
    for child_name in os.listdir(dir_path):
315
310
        child_path = os.path.join(dir_path, child_name)
316
311
        if os.path.isfile(child_path):
317
312
            if child_path.endswith(".py"):
318
313
                check_file(child_path)
319
314
        else:
320
315
            check_dir(child_path)
321
316
322
317
323
318
def do_main():
324
319
    args = FLAGS(sys.argv)
325
320
326
321
    for path in args[1:]:
327
322
        if os.path.isdir(path):
328
323
            check_dir(path)
329
324
        else:
330
325
            check_file(path)
331
326
332
327
333
328
if __name__ == '__main__':
334
329
    do_main()
Status:	Work in progress
Proposed branch:	lp:~justin-fathomdb/nova/termie-bot
Merge into:	lp:~hudson-openstack/nova/trunk
Diff against target:	334 lines (+329/-0) 1 file modified contrib/rules/do_checks.py (+329/-0)
To merge this branch:	bzr merge lp:~justin-fathomdb/nova/termie-bot
Related bugs:	Link a bug report
Reviewer	Date Requested	Status
Vish Ishaya (community)	2011-04-06	Approve on 2011-05-20
Brian Lamar (community)		Abstain on 2011-04-12
termie (community)	2011-03-28	Needs Fixing on 2011-03-28
Nova Core security contacts	2011-03-29	Pending
Review via email: mp+55031@code.launchpad.net