#!/usr/bin/env python
##===--- iwyu-check-license-header.py - check license headers -------------===##
#
# The LLVM Compiler Infrastructure
#
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
#
##===----------------------------------------------------------------------===##
from __future__ import print_function
import sys
import os
import re
import argparse
# This is used in selected functions to calculate the maximum length of filename
# and filler dashes. Not otherwise useful.
EMBELLISHMENTS = '//===--- ---===//'
HDRFORMAT = """
{c}
{c} The LLVM Compiler Infrastructure
{c}
{c} This file is distributed under the University of Illinois Open Source
{c} License. See LICENSE.TXT for details.
{c}
{t}===----------------------------------------------------------------------==={t}
"""
def make_hdrformat(one, two):
""" Materialize HDRFORMAT based on the one and two comment styles.
The one and two args should be '#' and '##' or '//' and '//', respectively.
Returns a list of lines.
"""
r = HDRFORMAT.lstrip().format(c=one, t=two)
return r.splitlines()
def truncated(filename):
""" Truncate the filename with ellipsis if too long """
maxlen = 80 - len(EMBELLISHMENTS)
trunclen = maxlen - 3 # ...
if len(filename) > maxlen:
filename = filename[:trunclen] + '...'
return filename
def make_license_header(filename, one, two):
""" Build a valid license header from filename and comment styles.
The one and two args should be '#' and '##' or '//' and '//', respectively.
Returns a list of lines.
"""
assert len(two) == 2
filename = os.path.basename(filename)
filename = truncated(filename)
def dashes():
c = 80
c -= len(EMBELLISHMENTS)
c -= len(filename)
return '-' * c
firstline = '%s===--- %s %s===%s' % (two, filename, dashes(), two)
return [firstline] + make_hdrformat(one, two)
def format_file_error(filename, *lines):
""" Format an error message from filename and lines """
lines = list(lines)
lines[0] = '%s: %s' % (filename, lines[0])
return os.linesep.join(lines)
def find_license_header(lines, two):
""" Return an index where the license header begins """
if not lines:
return -1
for i, line in enumerate(lines):
# Allow leading blank lines and hash-bangs.
if not line or line.startswith('#!'):
continue
# Besides those, the first line should be a license header.
if line.startswith(two + '==='):
break
# If not, this fails the test entirely.
return -1
return i
class File(object):
""" Base class for a source file with a license header
Do not use directly, instead use File.parse to instantiate a more derived
class.
Derived classes must have three class variables:
* one - One comment char ('#' for Python, '//' for C++)
* two - Two comment chars ('##' for Python, '//' for C++)
* pattern - a regex matching the first line in a license header
"""
def __init__(self, filename):
with open(filename, 'r') as fd:
content = fd.read()
self.lines = list(content.splitlines())
self.hdrindex = find_license_header(self.lines, self.two)
self.filename = filename
self.errors = []
@classmethod
def parse(_, filename):
""" Return an object derived from File to analyze license headers """
_, ext = os.path.splitext(filename)
if ext == '.py':
klass = PythonFile
elif ext in ('.h', '.c', '.cc'):
klass = CxxFile
else:
return None
return klass(filename)
def has_license_header(self):
""" Return True if a license header has been found """
return self.hdrindex != -1
def add_license_header(self):
""" Add license header to a file that doesn't have one. """
assert not self.has_license_header()
# Find insertion point
for p, line in enumerate(self.lines):
# Skip past leading blank lines and hash-bangs.
if line and not line.startswith('#!'):
break
# Split the lines around the insertion point
if self.lines:
before, after = self.lines[:p], self.lines[p:]
else:
before, after = [], []
# Rebuild the contents with the license header in the middle
lines = before
if before and before[-1] != '':
lines += ['']
lines += make_license_header(self.filename, self.one, self.two)
if after and after[0] != '':
lines += ['']
lines += after
# Write back out
with open(self.filename, 'wb') as fd:
fd.write('\n'.join(lines))
fd.write('\n')
def check_license_header(self):
""" Check that the header lines follow convention.
Returns True if everything is OK, otherwise returns False and populates
self.errors with all found errors.
"""
if not self.has_license_header():
self.file_error('No license header found')
return False
hdrlines = self.lines[self.hdrindex:self.hdrindex+8]
# First line has the most structure
line = hdrlines[0]
if len(line) != 80:
self.line_error(
1, 'Bad header line length (expected: 80, was: %d)' % len(line),
" Header line: '%s'" % line)
m = self.pattern.match(line)
if not m:
self.line_error(1, 'Bad header line',
" Expected: '%s'" % self.pattern.pattern,
" Actual: '%s'" % line)
else:
hfilename = truncated(m.group(1))
xfilename = truncated(os.path.basename(self.filename))
if hfilename != xfilename:
self.line_error(1, 'Bad header filename',
" Expected: '%s'" % xfilename,
" Actual: '%s'" % hfilename)
# The following seven lines always follow the layout of HDRFORMAT.
hdrformat = make_hdrformat(self.one, self.two)
hdrlines = hdrlines[1:]
for lineno, (expected, actual) in enumerate(zip(hdrformat, hdrlines)):
if expected != actual:
self.line_error(lineno + 2, 'Bad header line',
" Expected: '%s'" % expected,
" Actual: '%s'" % actual)
return not self.errors
def file_error(self, *lines):
""" Log an error for the file """
self.errors.append(format_file_error(self.filename, *lines))
def line_error(self, lineno, *lines):
""" Log an error for a specific line in the file """
lines = list(lines)
lines[0] = '%s:%d: %s' % (self.filename, lineno, lines[0])
self.errors.append(os.linesep.join(lines))
class PythonFile(File):
""" Python file with license header """
one = '#'
two = '##'
pattern = re.compile(
r'##===--- ([a-z0-9_.-]+) -[A-Za-z0-9_.,/# -{}]+===##')
def __init__(self, filename):
super(PythonFile, self).__init__(filename)
class CxxFile(File):
""" C++ file with license header """
one = '//'
two = '//'
pattern = re.compile(
r'//===--- ([a-z0-9_.-]+) -[A-Za-z0-9_.,/# -{}]+ [-* C+]+===//')
def __init__(self, filename):
super(CxxFile, self).__init__(filename)
def main(filenames, add_if_missing):
""" Entry point.
Checks license header of all filenames provided.
Returns zero if all license headers are OK, non-zero otherwise.
"""
errors = []
for filename in filenames:
if os.path.isdir(filename):
continue
checker = File.parse(filename)
if not checker:
# TODO: Consider printing a warning here in verbose mode.
continue
if not checker.check_license_header():
errors.extend(checker.errors)
if add_if_missing and not checker.has_license_header():
checker.add_license_header()
for err in errors:
print(err)
return len(errors)
if __name__ == '__main__':
parser = argparse.ArgumentParser('IWYU license header checker')
parser.add_argument('filename', nargs='+')
parser.add_argument('--add', action='store_true')
args = parser.parse_args()
sys.exit(main(args.filename, args.add))
