1 #!@TOOLS_PYTHON@
   2 #
   3 #  This program is free software; you can redistribute it and/or modify
   4 #  it under the terms of the GNU General Public License version 2
   5 #  as published by the Free Software Foundation.
   6 #
   7 #  This program is distributed in the hope that it will be useful,
   8 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
   9 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10 #  GNU General Public License for more details.
  11 #
  12 #  You should have received a copy of the GNU General Public License
  13 #  along with this program; if not, write to the Free Software
  14 #  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  15 #
  16 
  17 #
  18 # Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
  19 # Copyright 2008, 2012 Richard Lowe
  20 # Copyright 2014 Garrett D'Amore <garrett@damore.org>
  21 # Copyright (c) 2015, 2016 by Delphix. All rights reserved.
  22 # Copyright 2016 Nexenta Systems, Inc.
  23 # Copyright 2018 Joyent, Inc.
  24 # Copyright 2018 OmniOS Community Edition (OmniOSce) Association.
  25 #
  26 
  27 from __future__ import print_function
  28 
  29 import getopt
  30 import io
  31 import os
  32 import re
  33 import subprocess
  34 import sys
  35 import tempfile
  36 
  37 if sys.version_info[0] < 3:
  38     from cStringIO import StringIO
  39 else:
  40     from io import StringIO
  41 
  42 #
  43 # Adjust the load path based on our location and the version of python into
  44 # which it is being loaded.  This assumes the normal onbld directory
  45 # structure, where we are in bin/ and the modules are in
  46 # lib/python(version)?/onbld/Scm/.  If that changes so too must this.
  47 #
  48 sys.path.insert(1, os.path.join(os.path.dirname(__file__), "..", "lib",
  49                                 "python%d.%d" % sys.version_info[:2]))
  50 
  51 #
  52 # Add the relative path to usr/src/tools to the load path, such that when run
  53 # from the source tree we use the modules also within the source tree.
  54 #
  55 sys.path.insert(2, os.path.join(os.path.dirname(__file__), ".."))
  56 
  57 from onbld.Scm import Ignore
  58 from onbld.Checks import Comments, Copyright, CStyle, HdrChk, WsCheck
  59 from onbld.Checks import JStyle, Keywords, ManLint, Mapfile, SpellCheck
  60 
  61 class GitError(Exception):
  62     pass
  63 
  64 def git(command):
  65     """Run a command and return a stream containing its stdout (and write its
  66     stderr to its stdout)"""
  67 
  68     if type(command) != list:
  69         command = command.split()
  70 
  71     command = ["git"] + command
  72 
  73     try:
  74         tmpfile = tempfile.TemporaryFile(prefix="git-nits", mode="w+b")
  75     except EnvironmentError as e:
  76         raise GitError("Could not create temporary file: %s\n" % e)
  77 
  78     try:
  79         p = subprocess.Popen(command,
  80                              stdout=tmpfile,
  81                              stderr=subprocess.PIPE)
  82     except OSError as e:
  83         raise GitError("could not execute %s: %s\n" % (command, e))
  84 
  85     err = p.wait()
  86     if err != 0:
  87         raise GitError(p.stderr.read())
  88 
  89     tmpfile.seek(0)
  90     lines = []
  91     for l in tmpfile:
  92         lines.append(l.decode('utf-8', 'replace'))
  93     return lines
  94 
  95 def git_root():
  96     """Return the root of the current git workspace"""
  97 
  98     p = git('rev-parse --git-dir')
  99     dir = p[0]
 100 
 101     return os.path.abspath(os.path.join(dir, os.path.pardir))
 102 
 103 def git_branch():
 104     """Return the current git branch"""
 105 
 106     p = git('branch')
 107 
 108     for elt in p:
 109         if elt[0] == '*':
 110             if elt.endswith('(no branch)'):
 111                 return None
 112             return elt.split()[1]
 113 
 114 def git_parent_branch(branch):
 115     """Return the parent of the current git branch.
 116 
 117     If this branch tracks a remote branch, return the remote branch which is
 118     tracked.  If not, default to origin/master."""
 119 
 120     if not branch:
 121         return None
 122 
 123     p = git(["for-each-ref", "--format=%(refname:short) %(upstream:short)",
 124             "refs/heads/"])
 125 
 126     if not p:
 127         sys.stderr.write("Failed finding git parent branch\n")
 128         sys.exit(1)
 129 
 130     for line in p:
 131         # Git 1.7 will leave a ' ' trailing any non-tracking branch
 132         if ' ' in line and not line.endswith(' \n'):
 133             local, remote = line.split()
 134             if local == branch:
 135                 return remote
 136     return 'origin/master'
 137 
 138 def git_comments(parent):
 139     """Return a list of any checkin comments on this git branch"""
 140 
 141     p = git('log --pretty=tformat:%%B:SEP: %s..' % parent)
 142 
 143     if not p:
 144         sys.stderr.write("No outgoing changesets found - missing -p option?\n");
 145         sys.exit(1)
 146 
 147     return [x.strip() for x in p if x != ':SEP:\n']
 148 
 149 def git_file_list(parent, paths=None):
 150     """Return the set of files which have ever changed on this branch.
 151 
 152     NB: This includes files which no longer exist, or no longer actually
 153     differ."""
 154 
 155     p = git("log --name-only --pretty=format: %s.. %s" %
 156              (parent, ' '.join(paths)))
 157 
 158     if not p:
 159         sys.stderr.write("Failed building file-list from git\n")
 160         sys.exit(1)
 161 
 162     ret = set()
 163     for fname in p:
 164         if fname and not fname.isspace() and fname not in ret:
 165             ret.add(fname.strip())
 166 
 167     return ret
 168 
 169 def not_check(root, cmd):
 170     """Return a function which returns True if a file given as an argument
 171     should be excluded from the check named by 'cmd'"""
 172 
 173     ignorefiles = list(filter(os.path.exists,
 174                          [os.path.join(root, ".git", "%s.NOT" % cmd),
 175                           os.path.join(root, "exception_lists", cmd)]))
 176     return Ignore.ignore(root, ignorefiles)
 177 
 178 def gen_files(root, parent, paths, exclude):
 179     """Return a function producing file names, relative to the current
 180     directory, of any file changed on this branch (limited to 'paths' if
 181     requested), and excluding files for which exclude returns a true value """
 182 
 183     # Taken entirely from Python 2.6's os.path.relpath which we would use if we
 184     # could.
 185     def relpath(path, here):
 186         c = os.path.abspath(os.path.join(root, path)).split(os.path.sep)
 187         s = os.path.abspath(here).split(os.path.sep)
 188         l = len(os.path.commonprefix((s, c)))
 189         return os.path.join(*[os.path.pardir] * (len(s)-l) + c[l:])
 190 
 191     def ret(select=None):
 192         if not select:
 193             select = lambda x: True
 194 
 195         for abspath in git_file_list(parent, paths):
 196             path = relpath(abspath, '.')
 197             try:
 198                 res = git("diff %s HEAD %s" % (parent, path))
 199             except GitError as e:
 200                 # This ignores all the errors that can be thrown. Usually, this
 201                 # means that git returned non-zero because the file doesn't
 202                 # exist, but it could also fail if git can't create a new file
 203                 # or it can't be executed.  Such errors are 1) unlikely, and 2)
 204                 # will be caught by other invocations of git().
 205                 continue
 206             empty = not res
 207             if (os.path.isfile(path) and not empty and
 208                 select(path) and not exclude(abspath)):
 209                 yield path
 210     return ret
 211 
 212 def comchk(root, parent, flist, output):
 213     output.write("Comments:\n")
 214 
 215     return Comments.comchk(git_comments(parent), check_db=True,
 216                            output=output)
 217 
 218 
 219 def mapfilechk(root, parent, flist, output):
 220     ret = 0
 221 
 222     # We are interested in examining any file that has the following
 223     # in its final path segment:
 224     #    - Contains the word 'mapfile'
 225     #    - Begins with 'map.'
 226     #    - Ends with '.map'
 227     # We don't want to match unless these things occur in final path segment
 228     # because directory names with these strings don't indicate a mapfile.
 229     # We also ignore files with suffixes that tell us that the files
 230     # are not mapfiles.
 231     MapfileRE = re.compile(r'.*((mapfile[^/]*)|(/map\.+[^/]*)|(\.map))$',
 232         re.IGNORECASE)
 233     NotMapSuffixRE = re.compile(r'.*\.[ch]$', re.IGNORECASE)
 234 
 235     output.write("Mapfile comments:\n")
 236 
 237     for f in flist(lambda x: MapfileRE.match(x) and not
 238                    NotMapSuffixRE.match(x)):
 239         with io.open(f, encoding='utf-8', errors='replace') as fh:
 240             ret |= Mapfile.mapfilechk(fh, output=output)
 241     return ret
 242 
 243 def copyright(root, parent, flist, output):
 244     ret = 0
 245     output.write("Copyrights:\n")
 246     for f in flist():
 247         with io.open(f, encoding='utf-8', errors='replace') as fh:
 248             ret |= Copyright.copyright(fh, output=output)
 249     return ret
 250 
 251 def hdrchk(root, parent, flist, output):
 252     ret = 0
 253     output.write("Header format:\n")
 254     for f in flist(lambda x: x.endswith('.h')):
 255         with io.open(f, encoding='utf-8', errors='replace') as fh:
 256             ret |= HdrChk.hdrchk(fh, lenient=True, output=output)
 257     return ret
 258 
 259 def cstyle(root, parent, flist, output):
 260     ret = 0
 261     output.write("C style:\n")
 262     for f in flist(lambda x: x.endswith('.c') or x.endswith('.h')):
 263         with io.open(f, encoding='utf-8', errors='replace') as fh:
 264             ret |= CStyle.cstyle(fh, output=output, picky=True,
 265                              check_posix_types=True,
 266                              check_continuation=True)
 267     return ret
 268 
 269 def jstyle(root, parent, flist, output):
 270     ret = 0
 271     output.write("Java style:\n")
 272     for f in flist(lambda x: x.endswith('.java')):
 273         with io.open(f, encoding='utf-8', errors='replace') as fh:
 274             ret |= JStyle.jstyle(fh, output=output, picky=True)
 275     return ret
 276 
 277 def manlint(root, parent, flist, output):
 278     ret = 0
 279     output.write("Man page format/spelling:\n")
 280     ManfileRE = re.compile(r'.*\.[0-9][a-z]*$', re.IGNORECASE)
 281     for f in flist(lambda x: ManfileRE.match(x)):
 282         with io.open(f, encoding='utf-8', errors='replace') as fh:
 283             ret |= ManLint.manlint(fh, output=output, picky=True)
 284             ret |= SpellCheck.spellcheck(fh, output=output)
 285     return ret
 286 
 287 def keywords(root, parent, flist, output):
 288     ret = 0
 289     output.write("SCCS Keywords:\n")
 290     for f in flist():
 291         with io.open(f, encoding='utf-8', errors='replace') as fh:
 292             ret |= Keywords.keywords(fh, output=output)
 293     return ret
 294 
 295 def wscheck(root, parent, flist, output):
 296     ret = 0
 297     output.write("white space nits:\n")
 298     for f in flist():
 299         with io.open(f, encoding='utf-8', errors='replace') as fh:
 300             ret |= WsCheck.wscheck(fh, output=output)
 301     return ret
 302 
 303 def run_checks(root, parent, cmds, paths='', opts={}):
 304     """Run the checks given in 'cmds', expected to have well-known signatures,
 305     and report results for any which fail.
 306 
 307     Return failure if any of them did.
 308 
 309     NB: the function name of the commands passed in is used to name the NOT
 310     file which excepts files from them."""
 311 
 312     ret = 0
 313 
 314     for cmd in cmds:
 315         s = StringIO()
 316 
 317         exclude = not_check(root, cmd.__name__)
 318         result = cmd(root, parent, gen_files(root, parent, paths, exclude),
 319                      output=s)
 320         ret |= result
 321 
 322         if result != 0:
 323             print(s.getvalue())
 324 
 325     return ret
 326 
 327 def nits(root, parent, paths):
 328     cmds = [copyright,
 329             cstyle,
 330             hdrchk,
 331             jstyle,
 332             keywords,
 333             manlint,
 334             mapfilechk,
 335             wscheck]
 336     run_checks(root, parent, cmds, paths)
 337 
 338 def pbchk(root, parent, paths):
 339     cmds = [comchk,
 340             copyright,
 341             cstyle,
 342             hdrchk,
 343             jstyle,
 344             keywords,
 345             manlint,
 346             mapfilechk,
 347             wscheck]
 348     run_checks(root, parent, cmds)
 349 
 350 def main(cmd, args):
 351     parent_branch = None
 352     checkname = None
 353 
 354     try:
 355         opts, args = getopt.getopt(args, 'b:c:p:')
 356     except getopt.GetoptError as e:
 357         sys.stderr.write(str(e) + '\n')
 358         sys.stderr.write("Usage: %s [-c check] [-p branch] [path...]\n" % cmd)
 359         sys.exit(1)
 360 
 361     for opt, arg in opts:
 362         # We accept "-b" as an alias of "-p" for backwards compatibility.
 363         if opt == '-p' or opt == '-b':
 364             parent_branch = arg
 365         elif opt == '-c':
 366             checkname = arg
 367 
 368     if not parent_branch:
 369         parent_branch = git_parent_branch(git_branch())
 370 
 371     if checkname is None:
 372         if cmd == 'git-pbchk':
 373             checkname = 'pbchk'
 374         else:
 375             checkname = 'nits'
 376 
 377     if checkname == 'pbchk':
 378         if args:
 379             sys.stderr.write("only complete workspaces may be pbchk'd\n");
 380             sys.exit(1)
 381         pbchk(git_root(), parent_branch, None)
 382     elif checkname == 'nits':
 383         nits(git_root(), parent_branch, args)
 384     else:
 385         run_checks(git_root(), parent_branch, [eval(checkname)], args)
 386 
 387 if __name__ == '__main__':
 388     try:
 389         main(os.path.basename(sys.argv[0]), sys.argv[1:])
 390     except GitError as e:
 391         sys.stderr.write("failed to run git:\n %s\n" % str(e))
 392         sys.exit(1)