Source

Pypaste / friendpaste / ext / webpylint.py

The default branch has multiple heads

  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
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
# -*- coding: utf-8 -

# Copyright 2008 by Benoît Chesneau <benoit@amisphere.org>
# 
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import os
import re

from logilab.common.ureports import BaseWriter, Section, Table, HTMLWriter
from pylint.reporters.html import HTMLReporter

from friendpaste.utils import force_unicode


PYLINT_ALLMSGS= {
        'E0100': ('__init__ method is a generator',
            'Used when the special class method __init__ is turned into a '
            'generator by a yield in its body.'),    
        'E0101': ('Explicit return in __init__',
            'Used when the special class method __init__ has an explicit \
                    return value.'),    
        'E0102': ('%s already defined line %s',
            'Used when a function / class / method is redefined.'),
        'E0103': ('%r not properly in loop',
            'Used when break or continue keywords are used outside a loop.'),

        'E0104': ('return outside function',
            'Used when a "return" statement is found outside a function or '
            'method.'),
        'E0105': ('yield outside function',
            'Used when a "yield" statement is found outside a function or '
            'method.'),
        'E0106': ('return with argument inside generator',
            'Used when a "return" statement with an argument is found '
            'outside in a generator function or method (e.g. with some '
            '"yield" statements).'),

        'W0101': ('Unreachable code',
            'Used when there is some code behind a "return" or "raise" \
                    statement, which will never be accessed.'),
        'W0102': ('Dangerous default value %s as argument',
            'Used when a mutable value as list or dictionary is detected in \
                    a default value for an argument.'),
        'W0104': ('Statement seems to have no effect',
            'Used when a statement doesn\'t have (or at least seems to) \
                    any effect.'),
        'W0105': ('String statement has no effect',
            'Used when a string is used as a statement (which of course \
                    has no effect). This is a particular case of W0104 with its \
                    own message so you can easily disable it if you\'re using \
                    those strings as documentation, instead of comments.'),
        'W0106': ('Unnecessary semicolon',
            'Used when a statement is endend by a semi-colon (";"), which \
                    isn\'t necessary (that\'s python, not C ;).'),
        'W0107': ('Unnecessary pass statement',
            'Used when a "pass" statement that can be avoided is '
            'encountered.)'),

        'W0122': ('Use of the exec statement',
            'Used when you use the "exec" statement, to discourage its \
                    usage. That doesn\'t mean you can not use it !'),

        'W0141': ('Used builtin function %r',
            'Used when a black listed builtin function is used (see the '
            'bad-function option). Usual black listed functions are the ones '
            'like map, or filter , where Python offers now some cleaner '
            'alternative like list comprehension.'),
        'W0142': ('Used * or ** magic',
                'Used when a function or method is called using `*args` or '
                '`**kwargs` to dispatch arguments. This doesn\'t improve '
                'readability and should be used with care.'),

        'C0102': ('Black listed name "%s"',
                'Used when the name is listed in the black list (unauthorized \
                        names).'),
        'C0103': ('Invalid name "%s" (should match %s)',
                'Used when the name doesn\'t match the regular expression \
                        associated to its type (constant, variable, class...).'),

        'C0111': ('Missing docstring', # W0131
                'Used when a module, function, class or method has no docstring.\
                        Some special methods like __init__ doesn\'t necessary require a \
                        docstring.'),
        'C0112': ('Empty docstring', # W0132
                'Used when a module, function, class or method has an empty \
                        docstring (it would be too easy ;).'),

        'C0121': ('Missing required attribute "%s"', # W0103
                'Used when an attribute required for modules is missing.'),
        'F0202': ('Unable to check methods signature (%s / %s)',
                'Used when PyLint has been unable to check methods signature \
                        compatibility for an unexpected raison. Please report this kind \
                        if you don\'t make sense of it.'),

        'E0202': ('An attribute inherited from %s hide this method',
                'Used when a class defines a method which is hiden by an \
                        instance attribute from an ancestor class.'),
        'E0203': ('Access to member %r before its definition line %s',
                'Used when an instance member is accessed before it\'s actually\
                        assigned.'),
        'W0201': ('Attribute %r defined outside __init__',
                'Used when an instance attribute is defined outside the __init__\
                        method.'),

        'W0212': ('Access to a protected member %s of a client class', # E0214
                'Used when a protected member (i.e. class member with a name \
                        beginning with an underscore) is access outside the class or a \
                        descendant of the class where it\'s defined.'),

        'E0211': ('Method has no argument',
                'Used when a method which should have the bound instance as \
                        first argument has no argument defined.'),
        'E0213': ('Method should have "self" as first argument',
                'Used when a method has an attribute different the "self" as\
                        first argument. This is considered as an error since this is\
                        a soooo common convention that you should\'nt break it!'),
        'C0202': ('Class method should have "cls" as first argument', # E0212
                'Used when a class method has an attribute different than "cls"\
                        as first argument, to easily differentiate them from regular \
                        instance methods.'),
        'C0203': ('Metaclass method should have "mcs" as first argument', # E0214
                'Used when a metaclass method has an attribute different the \
                        "mcs" as first argument.'),

        'W0211': ('Static method with %r as first argument',
                'Used when a static method has "self" or "cls" as first argument.'
                ),
        'R0201': ('Method could be a function',
                'Used when a method doesn\'t use its bound instance, and so could\
                        be written as a function.'
                        ),

        'E0221': ('Interface resolved to %s is not a class',
                'Used when a class claims to implement an interface which is not \
                        a class.'),
        'E0222': ('Missing method %r from %s interface' ,
                'Used when a method declared in an interface is missing from a \
                        class implementing this interface'),
        'W0221': ('Arguments number differs from %s method',
                'Used when a method has a different number of arguments than in \
                        the implemented interface or in an overridden method.'),
        'W0222': ('Signature differs from %s method',
                'Used when a method signature is different than in the \
                        implemented interface or in an overridden method.'),
        'W0223': ('Method %r is abstract in class %r but is not overridden',
                'Used when an abstract method (ie raise NotImplementedError) is \
                        not overridden in concrete class.'
                        ),
        'F0220': ('failed to resolve interfaces implemented by %s (%s)', # W0224
                'Used when a PyLint as failed to find interfaces implemented by \
                        a class'),


        'W0231': ('__init__ method from base class %r is not called',
                'Used when an ancestor class method has an __init__ method \
                        which is not called by a derived class.'),
        'W0232': ('Class has no __init__ method',
                'Used when a class has no __init__ method, neither its parent \
                        classes.'),
        'W0233': ('__init__ method from a non direct base class %r is called',
                'Used when an __init__ method is called on a class which is not \
                        in the direct ancestors for the analysed class.'),

        'R0901': ('Too many ancestors (%s/%s)',
                'Used when class has too many parent classes, try to reduce \
                        this to get a more simple (and so easier to use) class.'),
        'R0902': ('Too many instance attributes (%s/%s)',
                'Used when class has too many instance attributes, try to reduce \
                        this to get a more simple (and so easier to use) class.'),
        'R0903': ('Too few public methods (%s/%s)',
                'Used when class has too few public methods, so be sure it\'s \
                        really worth it.'),
        'R0904': ('Too many public methods (%s/%s)',
                'Used when class has too many public methods, try to reduce \
                        this to get a more simple (and so easier to use) class.'),

        'R0911': ('Too many return statements (%s/%s)',
                'Used when a function or method has too many return statement, \
                        making it hard to follow.'),
        'R0912': ('Too many branches (%s/%s)',
                'Used when a function or method has too many branches, \
                        making it hard to follow.'),
        'R0913': ('Too many arguments (%s/%s)',
                'Used when a function or method takes too many arguments.'),
        'R0914': ('Too many local variables (%s/%s)',
                'Used when a function or method has too many local variables.'),
        'R0915': ('Too many statements (%s/%s)',
                'Used when a function or method has too many statements. You \
                        should then split it in smaller functions / methods.'),

        'R0921': ('Abstract class not referenced',
                'Used when an abstract class is not used as ancestor anywhere.'),
        'R0922': ('Abstract class is only referenced %s times',
                'Used when an abstract class is used less than X times as \
                        ancestor.'),
        'R0923': ('Interface not implemented',
                'Used when an interface class is not implemented anywhere.'),

        'E0701': (
                'Bad except clauses order (%s)',
                'Used when except clauses are not in the correct order (from the \
                        more specific to the more generic). If you don\'t fix the order, \
                        some exceptions may not be catched by the most specific handler.'),
        'E0702': ('Raising %s while only classes, instances or string are allowed',
                'Used when something which is neither a class, an instance or a \
                        string is raised (i.e. a `TypeError` will be raised).'),

        'W0701': ('Raising a string exception',
                'Used when a string exception is raised.'),
        'W0702': ('No exception type(s) specified',
                'Used when an except clause doesn\'t specify exceptions type to \
                        catch.'),
        'W0703': ('Catch "Exception"',
                'Used when an except catches Exception instances.'),
        'W0704': ('Except doesn\'t do anything',
                'Used when an except clause does nothing but "pass" and there is\
                        no "else" clause.'),
        'W0706': (
                'Identifier %s used to raise an exception is assigned to %s',
                'Used when a variable used to raise an exception is initially \
                        assigned to a value which can\'t be used as an exception.'),
        'C0301': ('Line too long (%s/%s)',
                'Used when a line is longer than a given number of characters.'),
        'C0302': ('Too many lines in module (%s)', # was W0302
                'Used when a module has too much lines, reducing its readibility.'
                ),

        'W0311': ('Bad indentation. Found %s %s, expected %s',
                'Used when an unexpected number of indentation\'s tabulations or '
                'spaces has been found.'),
        'W0312': ('Found indentation with %ss instead of %ss',
                'Used when there are some mixed tabs and spaces in a module.'),

        'F0321': ('Format detection error in %r',
                'Used when an unexpected error occured in bad format detection.'
                'Please report the error if it occurs.'),
        'C0321': ('More than one statement on a single line',
                'Used when more than on statement are found on the same line.'),
        'C0322': ('Operator not preceded by a space\n%s',
                'Used when one of the following operator (!= | <= | == | >= | < '
                '| > | = | \+= | -= | \*= | /= | %) is not preceded by a space.'),
        'C0323': ('Operator not followed by a space\n%s',
                'Used when one of the following operator (!= | <= | == | >= | < '
                '| > | = | \+= | -= | \*= | /= | %) is not followed by a space.'),
        'C0324': ('Comma not followed by a space\n%s',
                'Used when a comma (",") is not followed by a space.'),

        'W0331': ('Use of the <> operator',
                'Used when the deprecated "<>" operator is used instead \
                        of "!=".'),
        'W0332': ('Use l as long integer identifier',
                'Used when a lower case "l" is used to mark a long integer. You '
                'should use a upper case "L" since the letter "l" looks too much '
                'like the digit "1"'),
        'W0333': ('Use of the `` operator',
                'Used when the deprecated "``" (backtick) operator is used '
                'instead  of the str() function.'),
        'F0401': ('Unable to import %r (%s)' ,
                'Used when pylint has been unable to import a module.'),
        'R0401': ('Cyclic import (%s)',
                'Used when a cyclic import between two or more modules is \
                        detected.'),

        'W0401': ('Wildcard import %s',
                'Used when `from module import *` is detected.'),
        'W0402': ('Uses of a deprecated module %r',
                'Used a module marked as deprecated is imported.'),
        'W0403': ('Relative import %r',
                'Used when an import relative to the package directory is \
                        detected.'),
        'W0404': ('Reimport %r (imported line %s)',
                'Used when a module is reimported multiple times.'),
        'W0406': ('Module import itself',
                'Used when a module is importing itself.'),

        'W0410': ('__future__ import is not the first non docstring statement',
                'Python 2.5 and greater require __future__ import to be the \
                        first non docstring statement in the module.'),
        'E0501': ('Non ascii characters found but no encoding specified (PEP 263)',
                'Used when some non ascii characters are detected but now \
                        encoding is specified, as explicited in the PEP 263.'),
        'E0502': ('Wrong encoding specified (%s)',
                'Used when a known encoding is specified but the file doesn\'t \
                        seem to be actually in this encoding.'),
        'E0503': ('Unknown encoding specified (%s)',
                'Used when an encoding is specified, but it\'s unknown to Python.'
                ),

        'W0511': ('%s',
                'Used when a warning note as FIXME or XXX is detected.'),
        'E1001': ('Use __slots__ on an old style class',
                'Used when an old style class use the __slots__ attribute.'),
        'E1002': ('Use super on an old style class',
                'Used when an old style class use the super builtin.'),
        'E1003': ('Bad first argument %r given to super class',
                'Used when another argument than the current class is given as \
                        first argument of the super builtin.'),
        'E1010': ('Raising a new style class',
                'Used when a new style class is raised since it\'s not \
                        possible with python < 2.5.'),

        'W1001': ('Use of "property" on an old style class',
                'Used when PyLint detect the use of the builtin "property" \
                        on an old style class while this is relying on new style \
                        classes features'),
        'W1010': ('Exception doesn\'t inherit from standard "Exception" class',
                'Used when a custom exception class is raised but doesn\'t \
                        inherit from the builtin "Exception" class.'),
        'E1201': ('Using unavailable keyword %r',
                'Used when a keyword which is not available in rpython is used.'),
        'E1202': ('Using unavailable builtin %r',
                'Used when a built-in which is not available in rpython is used.'
                ),
        'E1203': ('generator expressions are not supported',
                'Used when a generator expression is used while generator are \
                        not available in rpython.'),    
        'E1204': ('multiple inheritance only supported under specific rules \
                which doesn\'t seems to be satisfied',
                'Multiple inheritance is only supported using pure mixin (no \
                        instance attribute defined in the mix-in) with "_mixin_" class attribute set \
                        to True.'),
        'E1205': ('Using unavailable protocol %r',
                'Used when a special method not handled by rpython is used *and*'
                ' that may not be used explicitly is used (see W1201).'),


        'E1210': ('Multiple types assigned to %s %r',
                'Used when an identifier or attribut is infered as having values'
                ' of different types assigned.'),
        'E1211': ('Can\'t mix %s and None on %s %r',
                'Used when an int or float variable is assigned to None.'),    
        'E1212': ('Non homogeneous values in list',
                'Used when a list is not containing homogeneous values.'),


        ##     'E1205': ('Identifier %r is not properly initialized',
##               'Used when an identifier is used in some conditional block \
        ## without being properly initialized before that block.'),

    'E1220': ('Modifying global %r from module %s',
            'Used when a module variable is modified, which is not allowed '
            'in rpython since globals are considered as constants.'),


    'E1230': ('Using negative slice %s %s (infered to %s)',
            'Used when a negative integer is used as lower, upper or step of'
            ' a slice.'),
    'E1231': ('Using non constant step',
            'Used when a variable not annotated as a constant is used as '
            'step of a slice.'),

    'E1240': ('%r format is not supported',
            'Used when the unavailable "%r" formatting instruction is used.'
            ),

    'W1201': ('special method %s has to be called explicitly',
            'Used when a special method is defined on a class, as rpython '
            'won\'t call the explicitly.'),
    'R0801': ('Similar lines in %s files\n%s',
            'Indicates that a set of similar lines has been detected \
                    among multiple file. This usually means that the code should \
                    be refactored to avoid this duplication.'),
    'E1101': ('%s %r has no %r member',
            'Used when a variable is accessed for an unexistant member.'),
    'E1102': ('%s is not callable',
            'Used when an object being called has been infered to a non \
                    callable object'),
    'E1103': ('%s %r has no %r member (but some types could not be inferred)',
            'Used when a variable is accessed for an unexistant member, but \
                    astng was not able to interpret all possible types of this \
                    variable.'),
    'E1111': ('Assigning to function call which doesn\'t return',
            'Used when an assigment is done on a function call but the \
                    infered function doesn\'t return anything.'),
    'W1111': ('Assigning to function call which only returns None',
            'Used when an assigment is done on a function call but the \
                    infered function returns nothing but None.'),
    'E0601': ('Using variable %r before assignment',
            'Used when a local variable is accessed before it\'s \
                    assignment.'),
    'E0602': ('Undefined variable %r',
            'Used when an undefined variable is accessed.'),

    'E0611': ('No name %r in module %r',
            'Used when a name cannot be found in a module.'),

    'W0601': ('Global variable %r undefined at the module level',
            'Used when a variable is defined through the "global" statement \
                    but the variable is not defined in the module scope.'),
    'W0602': ('Using global for %r but no assigment is done',
            'Used when a variable is defined through the "global" statement \
                    but no assigment to this variable is done.'),
    'W0603': ('Using the global statement', # W0121
            'Used when you use the "global" statement to update a global \
                    variable. PyLint just try to discourage this \
                    usage. That doesn\'t mean you can not use it !'),
    'W0604': ('Using the global statement at the module level', # W0103
            'Used when you use the "global" statement at the module level \
                    since it has no effect'),
    'W0611': ('Unused import %s',
            'Used when an imported module or variable is not used.'),
    'W0612': ('Unused variable %r',
            'Used when a variable is defined but not used.'),
    'W0613': ('Unused argument %r',
            'Used when a function or method argument is not used.'),
    'W0614': ('Unused import %s from wildcard import',
            'Used when an imported module or variable is not used from a \
                    \'from X import *\' style import.'),

    'W0621': ('Redefining name %r from outer scope (line %s)',
            'Used when a variable\'s name hide a name defined in the outer \
                    scope.'),
    'W0622': ('Redefining built-in %r',
            'Used when a variable or function override a built-in.'),

    'W0631': ('Using possibly undefined loop variable %r',
            'Used when an loop variable (i.e. defined by a for loop or \
                    a list comprehension or a generator expression) is used outside \
                    the loop.')

    }


class PYPHTMLWriter(BaseWriter):
    """format layouts as HTML"""
    
    def __init__(self, snipet=None):
        super(PYPHTMLWriter, self).__init__(self)
        self.snipet = snipet 
        
    def handle_attrs(self, layout):
        """get an attribute string from layout member attributes"""
        attrs = ''
        klass = getattr(layout, 'klass', None)
        if klass:
            attrs += ' class="%s"' % klass
        nid = getattr(layout, 'id', None)
        if nid: 
            attrs += ' id="%s"' % nid
        return attrs
    
    def begin_format(self, layout):
        """begin to format a layout"""
        super(PYPHTMLWriter, self).begin_format(layout)
        if self.snipet is None:
            self.writeln('<div id="report">')
        
    def end_format(self, layout):
        """finished to format a layout"""
        if self.snipet is None:
            self.writeln('</div>')

    def visit_section(self, layout):
        """display a section as html, using div + h[section level]"""
        self.section += 1
        self.writeln('<div%s>' % self.handle_attrs(layout))
        self.format_children(layout)
        self.writeln('</div>')
        self.section -= 1

    def visit_title(self, layout):
        """display a title using <hX>"""
        self.write('<h%s%s>' % (self.section, self.handle_attrs(layout)))
        self.format_children(layout)
        self.writeln('</h%s>' % self.section)

    def visit_table(self, layout):
        """display a table as html"""
        self.writeln('<table%s>' % self.handle_attrs(layout))
        table_content = self.get_table_content(layout)
        for i in range(len(table_content)):
            row = table_content[i]
            if i == 0 and layout.rheaders:
                self.writeln('<tr class="header">')
            elif i+1 == len(table_content) and layout.rrheaders:
                self.writeln('<tr class="header">')
            else:
                self.writeln('<tr class="%s">' % (i%2 and 'even' or 'odd'))
            for j in range(len(row)):
                cell = row[j] or '&nbsp;'
                if (layout.rheaders and i == 0) or \
                   (layout.cheaders and j == 0) or \
                   (layout.rrheaders and i+1 == len(table_content)) or \
                   (layout.rcheaders and j+1 == len(row)):
                    self.writeln('<th>%s</th>' % cell)
                else:
                    self.writeln('<td>%s</td>' % cell)
            self.writeln('</tr>')
        self.writeln('</table>')
        
    def visit_list(self, layout):
        """display a list as html"""
        self.writeln('<ul%s>' % self.handle_attrs(layout))
        for row in list(self.compute_content(layout)):
            self.writeln('<li>%s</li>' % row)
        self.writeln('</ul>')
        
    def visit_paragraph(self, layout):
        """display links (using <p>)"""
        self.write('<p>')
        self.format_children(layout)
        self.write('</p>')
                   
    def visit_span(self, layout):
        """display links (using <p>)"""
        self.write('<span%s>' % self.handle_attrs(layout))
        self.format_children(layout)
        self.write('</span>')
                   
    def visit_link(self, layout):
        """display links (using <a>)"""
        self.write(' <a href="%s"%s>%s</a>' % (layout.url,
                                               self.handle_attrs(layout),
                                               layout.label))
    def visit_verbatimtext(self, layout):
        """display verbatim text (using <pre>)"""
        self.write('<pre>')
        self.write(layout.data.replace('&', '&amp;').replace('<', '&lt;'))
        self.write('</pre>')
        
    def visit_text(self, layout):
        """add some text"""
        data = layout.data
        if layout.escaped:
            data = data.replace('&', '&amp;').replace('<', '&lt;')
        self.write(data)

class PYPHTMLReporter(HTMLReporter):
    def _display(self, layout):
        if self.msgs:
            # add stored messages to the layout
            msgs = ['type', 'module', 'object', 'line', 'message']
            msgs += self.msgs
            sect = Section('Messages')
            layout.append(sect)
            sect.append(Table(cols=5, children=msgs, rheaders=1))
            self.msgs = []
        PYPHTMLWriter().format(layout, self.out)


def replace_tips(dict, text): 
    regex = re.compile("(%s)" % "|".join(map(re.escape, dict.keys())))
    return regex.sub(lambda mo: '<span class="tips" title="%s|%s">%s</span>' % (mo.string[mo.start():mo.end()],dict[mo.string[mo.start():mo.end()]][1],mo.string[mo.start():mo.end()]), text)


def parse_report(report, fname, id):
    re_module = re.compile('%s' % os.path.basename(fname), re.U)
    ret = replace_tips(PYLINT_ALLMSGS, report)
    ret = re_module.sub('<a href="/%s">%s</a>' % (id,id), force_unicode(ret))

    return ret