buildbot/steps/python.py

   1
   2 from buildbot.status.builder import SUCCESS, FAILURE, WARNINGS
   3 from buildbot.steps.shell import ShellCommand
   4 import re
   5
   6 try:
   7     import cStringIO
   8     StringIO = cStringIO.StringIO
   9 except ImportError:
  10     from StringIO import StringIO
  11
  12
  13 class BuildEPYDoc(ShellCommand):
  14     name = "epydoc"
  15     command = ["make", "epydocs"]
  16     description = ["building", "epydocs"]
  17     descriptionDone = ["epydoc"]
  18
  19     def createSummary(self, log):
  20         import_errors = 0
  21         warnings = 0
  22         errors = 0
  23
  24         for line in StringIO(log.getText()):
  25             if line.startswith("Error importing "):
  26                 import_errors += 1
  27             if line.find("Warning: ") != -1:
  28                 warnings += 1
  29             if line.find("Error: ") != -1:
  30                 errors += 1
  31
  32         self.descriptionDone = self.descriptionDone[:]
  33         if import_errors:
  34             self.descriptionDone.append("ierr=%d" % import_errors)
  35         if warnings:
  36             self.descriptionDone.append("warn=%d" % warnings)
  37         if errors:
  38             self.descriptionDone.append("err=%d" % errors)
  39
  40         self.import_errors = import_errors
  41         self.warnings = warnings
  42         self.errors = errors
  43
  44     def evaluateCommand(self, cmd):
  45         if cmd.rc != 0:
  46             return FAILURE
  47         if self.warnings or self.errors:
  48             return WARNINGS
  49         return SUCCESS
  50
  51
  52 class PyFlakes(ShellCommand):
  53     name = "pyflakes"
  54     command = ["make", "pyflakes"]
  55     description = ["running", "pyflakes"]
  56     descriptionDone = ["pyflakes"]
  57     flunkOnFailure = False
  58     flunkingIssues = ["undefined"] # any pyflakes lines like this cause FAILURE
  59
  60     MESSAGES = ("unused", "undefined", "redefs", "import*", "misc")
  61
  62     def createSummary(self, log):
  63         counts = {}
  64         summaries = {}
  65         for m in self.MESSAGES:
  66             counts[m] = 0
  67             summaries[m] = []
  68
  69         first = True
  70         for line in StringIO(log.getText()).readlines():
  71             # the first few lines might contain echoed commands from a 'make
  72             # pyflakes' step, so don't count these as warnings. Stop ignoring
  73             # the initial lines as soon as we see one with a colon.
  74             if first:
  75                 if line.find(":") != -1:
  76                     # there's the colon, this is the first real line
  77                     first = False
  78                     # fall through and parse the line
  79                 else:
  80                     # skip this line, keep skipping non-colon lines
  81                     continue
  82             if line.find("imported but unused") != -1:
  83                 m = "unused"
  84             elif line.find("*' used; unable to detect undefined names") != -1:
  85                 m = "import*"
  86             elif line.find("undefined name") != -1:
  87                 m = "undefined"
  88             elif line.find("redefinition of unused") != -1:
  89                 m = "redefs"
  90             else:
  91                 m = "misc"
  92             summaries[m].append(line)
  93             counts[m] += 1
  94
  95         self.descriptionDone = self.descriptionDone[:]
  96         for m in self.MESSAGES:
  97             if counts[m]:
  98                 self.descriptionDone.append("%s=%d" % (m, counts[m]))
  99                 self.addCompleteLog(m, "".join(summaries[m]))
 100             self.setProperty("pyflakes-%s" % m, counts[m], "pyflakes")
 101         self.setProperty("pyflakes-total", sum(counts.values()), "pyflakes")
 102
 103
 104     def evaluateCommand(self, cmd):
 105         if cmd.rc != 0:
 106             return FAILURE
 107         for m in self.flunkingIssues:
 108             if self.getProperty("pyflakes-%s" % m):
 109                 return FAILURE
 110         if self.getProperty("pyflakes-total"):
 111             return WARNINGS
 112         return SUCCESS
 113
 114 class PyLint(ShellCommand):
 115     '''A command that knows about pylint output.
 116     It's a good idea to add --output-format=parseable to your
 117     command, since it includes the filename in the message.
 118     '''
 119     name = "pylint"
 120     description = ["running", "pylint"]
 121     descriptionDone = ["pylint"]
 122
 123     # Using the default text output, the message format is :
 124     # MESSAGE_TYPE: LINE_NUM:[OBJECT:] MESSAGE
 125     # with --output-format=parseable it is: (the outer brackets are literal)
 126     # FILE_NAME:LINE_NUM: [MESSAGE_TYPE[, OBJECT]] MESSAGE
 127     # message type consists of the type char and 4 digits
 128     # The message types:
 129
 130     MESSAGES = {
 131             'C': "convention", # for programming standard violation
 132             'R': "refactor", # for bad code smell
 133             'W': "warning", # for python specific problems
 134             'E': "error", # for much probably bugs in the code
 135             'F': "fatal", # error prevented pylint from further processing.
 136             'I': "info",
 137         }
 138
 139     flunkingIssues = ["F", "E"] # msg categories that cause FAILURE
 140
 141     _re_groupname = 'errtype'
 142     _msgtypes_re_str = '(?P<%s>[%s])' % (_re_groupname, ''.join(MESSAGES.keys()))
 143     _default_line_re = re.compile(r'%s\d{4}: *\d+:.+' % _msgtypes_re_str)
 144     _parseable_line_re = re.compile(r'[^:]+:\d+: \[%s\d{4}[,\]] .+' % _msgtypes_re_str)
 145
 146     def createSummary(self, log):
 147         counts = {}
 148         summaries = {}
 149         for m in self.MESSAGES:
 150             counts[m] = 0
 151             summaries[m] = []
 152
 153         line_re = None # decide after first match
 154         for line in StringIO(log.getText()).readlines():
 155             if not line_re:
 156                 # need to test both and then decide on one
 157                 if self._parseable_line_re.match(line):
 158                     line_re = self._parseable_line_re
 159                 elif self._default_line_re.match(line):
 160                     line_re = self._default_line_re
 161                 else: # no match yet
 162                     continue
 163             mo = line_re.match(line)
 164             if mo:
 165                 msgtype = mo.group(self._re_groupname)
 166                 assert msgtype in self.MESSAGES
 167             summaries[msgtype].append(line)
 168             counts[msgtype] += 1
 169
 170         self.descriptionDone = self.descriptionDone[:]
 171         for msg, fullmsg in self.MESSAGES.items():
 172             if counts[msg]:
 173                 self.descriptionDone.append("%s=%d" % (fullmsg, counts[msg]))
 174                 self.addCompleteLog(fullmsg, "".join(summaries[msg]))
 175             self.setProperty("pylint-%s" % fullmsg, counts[msg])
 176         self.setProperty("pylint-total", sum(counts.values()))
 177
 178     def evaluateCommand(self, cmd):
 179         if cmd.rc != 0:
 180             return FAILURE
 181         for msg in self.flunkingIssues:
 182             if self.getProperty("pylint-%s" % self.MESSAGES[msg]):
 183                 return FAILURE
 184         if self.getProperty("pylint-total"):
 185             return WARNINGS
 186         return SUCCESS
 187