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
27from __future__ import print_function
28
29import getopt
30import io
31import os
32import re
33import subprocess
34import sys
35import tempfile
36
37if sys.version_info[0] < 3:
38    from cStringIO import StringIO
39else:
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#
48sys.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#
55sys.path.insert(2, os.path.join(os.path.dirname(__file__), ".."))
56
57from onbld.Scm import Ignore
58from onbld.Checks import Comments, Copyright, CStyle, HdrChk, WsCheck
59from onbld.Checks import JStyle, Keywords, ManLint, Mapfile, SpellCheck
60
61class GitError(Exception):
62    pass
63
64def 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
95def 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
103def 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
114def 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(err)
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
138def 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("Failed getting git comments\n")
145        sys.exit(err)
146
147    return [x.strip() for x in p if x != ':SEP:\n']
148
149def 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(err)
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
169def 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
178def 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
212def 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
219def 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
243def 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
251def 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
259def 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
269def 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
277def 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
287def 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
295def 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
303def 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
327def 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
338def 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
350def 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
387if __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)
393