X-Git-Url: http://git.tremily.us/?p=update-copyright.git;a=blobdiff_plain;f=update_copyright.py;h=f4e39dfcbbfe226b43c97679bde290e0306af192;hp=0a3a281bd878cd543a1fa0834628d9dd5c491cd9;hb=82deee063ae32d4b12df66e8418c6b21479de6a9;hpb=e17cd3d71fd290fdf25a21f2a28e52431e45e828 diff --git a/update_copyright.py b/update_copyright.py index 0a3a281..f4e39df 100755 --- a/update_copyright.py +++ b/update_copyright.py @@ -1,216 +1,126 @@ #!/usr/bin/python # -# Copyright (C) 2009 W. Trevor King -# -# This program is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 2 of the License, or -# (at your option) any later version. -# -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., -# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +# Copyright + +"""Automatically update copyright boilerplate. + +This script is adapted from one written for `Bugs Everywhere`_. + +.. _Bugs Everywhere: http://bugseverywhere.org/ +""" +import difflib +import email.utils +import os import os.path import re +import StringIO import sys import time -import os -import sys -import select -from subprocess import Popen, PIPE, mswindows -from threading import Thread - -COPYRIGHT_TEXT="""# -# This program is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 2 of the License, or -# (at your option) any later version. -# -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., -# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.""" - -COPYRIGHT_TAG='-xyz-COPYRIGHT-zyx-' # unlikely to occur in the wild :p - -ALIASES = [ - ['Ben Finney ', - 'Ben Finney ', - 'John Doe '], - ['Chris Ball ', - 'Chris Ball '], - ['Gianluca Montecchi ', - 'gian ', - 'gianluca '], - ['W. Trevor King ', - 'wking '], - [None, - 'j^ '], - ] -COPYRIGHT_ALIASES = [ - ['Aaron Bentley and Panometrics, Inc.', - 'Aaron Bentley '], - ] -EXCLUDES = [ - ['Aaron Bentley and Panometrics, Inc.', - 'Aaron Bentley ',] - ] - - -IGNORED_PATHS = ['./.be/', './.bzr/', './build/'] -IGNORED_FILES = ['COPYING', 'update_copyright.py', 'catmutt'] - -class Pipe (object): - """ - Simple interface for executing POSIX-style pipes based on the - subprocess module. The only complication is the adaptation of - subprocess.Popen._comminucate to listen to the stderrs of all - processes involved in the pipe, as well as the terminal process' - stdout. There are two implementations of Pipe._communicate, one - for MS Windows, and one for POSIX systems. The MS Windows - implementation is currently untested. - - >>> p = Pipe([['find', '/etc/'], ['grep', '^/etc/ssh$']]) - >>> p.stdout - '/etc/ssh\\n' - >>> p.status - 1 - >>> p.statuses - [1, 0] - >>> p.stderrs # doctest: +ELLIPSIS - ["find: `...': Permission denied\\n...", ''] - """ - def __init__(self, cmds, stdin=None): - # spawn processes - self._procs = [] - for cmd in cmds: - if len(self._procs) != 0: - stdin = self._procs[-1].stdout - self._procs.append(Popen(cmd, stdin=stdin, stdout=PIPE, stderr=PIPE)) - - self.stdout,self.stderrs = self._communicate(input=None) - - # collect process statuses - self.statuses = [] - self.status = 0 - for proc in self._procs: - self.statuses.append(proc.wait()) - if self.statuses[-1] != 0: - self.status = self.statuses[-1] - - # Code excerpted from subprocess.Popen._communicate() - if mswindows == True: - def _communicate(self, input=None): - assert input == None, "stdin != None not yet supported" - # listen to each process' stderr - threads = [] - std_X_arrays = [] - for proc in self._procs: - stderr_array = [] - thread = Thread(target=proc._readerthread, - args=(proc.stderr, stderr_array)) - thread.setDaemon(True) - thread.start() - threads.append(thread) - std_X_arrays.append(stderr_array) - - # also listen to the last processes stdout - stdout_array = [] - thread = Thread(target=proc._readerthread, - args=(proc.stdout, stdout_array)) - thread.setDaemon(True) - thread.start() - threads.append(thread) - std_X_arrays.append(stdout_array) - - # join threads as they die - for thread in threads: - thread.join() - - # read output from reader threads - std_X_strings = [] - for std_X_array in std_X_arrays: - std_X_strings.append(std_X_array[0]) - - stdout = std_X_strings.pop(-1) - stderrs = std_X_strings - return (stdout, stderrs) - else: # POSIX - def _communicate(self, input=None): - read_set = [] - write_set = [] - read_arrays = [] - stdout = None # Return - stderr = None # Return - - if self._procs[0].stdin: - # Flush stdio buffer. This might block, if the user has - # been writing to .stdin in an uncontrolled fashion. - self._procs[0].stdin.flush() - if input: - write_set.append(self._procs[0].stdin) - else: - self._procs[0].stdin.close() - for proc in self._procs: - read_set.append(proc.stderr) - read_arrays.append([]) - read_set.append(self._procs[-1].stdout) - read_arrays.append([]) - - input_offset = 0 - while read_set or write_set: - try: - rlist, wlist, xlist = select.select(read_set, write_set, []) - except select.error, e: - if e.args[0] == errno.EINTR: - continue - raise - if self._procs[0].stdin in wlist: - # When select has indicated that the file is writable, - # we can write up to PIPE_BUF bytes without risk - # blocking. POSIX defines PIPE_BUF >= 512 - chunk = input[input_offset : input_offset + 512] - bytes_written = os.write(self.stdin.fileno(), chunk) - input_offset += bytes_written - if input_offset >= len(input): - self._procs[0].stdin.close() - write_set.remove(self._procs[0].stdin) - if self._procs[-1].stdout in rlist: - data = os.read(self._procs[-1].stdout.fileno(), 1024) - if data == "": - self._procs[-1].stdout.close() - read_set.remove(self._procs[-1].stdout) - read_arrays[-1].append(data) - for i,proc in enumerate(self._procs): - if proc.stderr in rlist: - data = os.read(proc.stderr.fileno(), 1024) - if data == "": - proc.stderr.close() - read_set.remove(proc.stderr) - read_arrays[i].append(data) - - # All data exchanged. Translate lists into strings. - read_strings = [] - for read_array in read_arrays: - read_strings.append(''.join(read_array)) - - stdout = read_strings.pop(-1) - stderrs = read_strings - return (stdout, stderrs) +import mercurial +import mercurial.dispatch + + +PROJECT_INFO = { + 'project': 'Hooke', + 'vcs': 'Mercurial', + } + +# Break "copyright" into "copy" and "right" to avoid matching the +# REGEXP. +COPY_RIGHT_TEXT=""" +This file is part of %(project)s. + +%(project)s is free software: you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation, either +version 3 of the License, or (at your option) any later version. + +%(project)s is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with %(project)s. If not, see +. +""".strip() + +COPY_RIGHT_TAG='-xyz-COPY' + '-RIGHT-zyx-' # unlikely to occur in the wild :p + +ALIASES = { + 'Alberto Gomez-Casado': + ['albertogomcas'], + 'Massimo Sandal ': + ['devicerandom', + 'unknown'], + 'Fabrizio Benedetti':['fabrizio.benedetti'], + 'il':['illysam'], + 'Marco Brucale':['marcobrucale'], + 'pp':['pancaldi.paolo'], + } + +IGNORED_PATHS = ['./.hg/', './doc/img', './test/data/', + './build/', '/doc/build/'] +IGNORED_FILES = ['COPYING', 'COPYING.LESSER'] + + +# VCS-specific commands + +def mercurial_cmd(*args): + cwd = os.getcwd() + stdout = sys.stdout + stderr = sys.stderr + tmp_stdout = StringIO.StringIO() + tmp_stderr = StringIO.StringIO() + sys.stdout = tmp_stdout + sys.stderr = tmp_stderr + try: + mercurial.dispatch.dispatch(list(args)) + finally: + os.chdir(cwd) + sys.stdout = stdout + sys.stderr = stderr + return (tmp_stdout.getvalue().rstrip('\n'), + tmp_stderr.getvalue().rstrip('\n')) + +def original_year(filename): + # shortdate filter: YEAR-MONTH-DAY + output,error = mercurial_cmd('log', '--follow', + '--template', '{date|shortdate}\n', + filename) + years = [int(line.split('-', 1)[0]) for line in output.splitlines()] + years.sort() + return years[0] + +def authors(filename): + output,error = mercurial_cmd('log', '--follow', + '--template', '{author}\n', + filename) + return list(set(output.splitlines())) + +def authors_list(): + output,error = mercurial_cmd('log', '--follow', + '--template', '{author}\n') + return list(set(output.splitlines())) + +def is_versioned(filename): + output,error = mercurial_cmd('log', '--follow', + '--template', '{date|shortdate}\n', + filename) + if len(error) > 0: + return False + return True + +# General utility commands def _strip_email(*args): - """ + """Remove email addresses from a series of names. + + Examples + -------- + >>> _strip_email('J Doe ') ['J Doe'] >>> _strip_email('J Doe ', 'JJJ Smith ') @@ -220,127 +130,109 @@ def _strip_email(*args): for i,arg in enumerate(args): if arg == None: continue - index = arg.find('<') - if index > 0: - args[i] = arg[:index].rstrip() + author,addr = email.utils.parseaddr(arg) + args[i] = author return args -def _replace_aliases(authors, with_email=True, aliases=None, - excludes=None): +def _reverse_aliases(aliases): + """Reverse an `aliases` dict. + + Input: key: canonical name, value: list of aliases + Output: key: alias, value: canonical name + + Examples + -------- + + >>> aliases = { + ... 'J Doe ':['Johnny ', 'J'], + ... 'JJJ Smith ':['Jingly '], + ... None:['Anonymous '], + ... } + >>> r = _reverse_aliases(aliases) + >>> for item in sorted(r.items()): + ... print item + ('Anonymous ', None) + ('J', 'J Doe ') + ('Jingly ', 'JJJ Smith ') + ('Johnny ', 'J Doe ') """ - >>> aliases = [['J Doe and C, Inc.', 'J Doe '], - ... ['J Doe ', 'Johnny '], - ... ['JJJ Smith ', 'Jingly '], - ... [None, 'Anonymous ']] - >>> excludes = [['J Doe and C, Inc.', 'J Doe ']] + output = {} + for canonical_name,_aliases in aliases.items(): + for alias in _aliases: + output[alias] = canonical_name + return output + +def _replace_aliases(authors, with_email=True, aliases=None): + """Consolidate and sort `authors`. + + Make the replacements listed in the `aliases` dict (key: canonical + name, value: list of aliases). If `aliases` is ``None``, default + to ``ALIASES``. + + >>> aliases = { + ... 'J Doe ':['Johnny '], + ... 'JJJ Smith ':['Jingly '], + ... None:['Anonymous '], + ... } >>> _replace_aliases(['JJJ Smith ', 'Johnny ', ... 'Jingly ', 'Anonymous '], - ... with_email=True, aliases=aliases, excludes=excludes) + ... with_email=True, aliases=aliases) ['J Doe ', 'JJJ Smith '] >>> _replace_aliases(['JJJ Smith', 'Johnny', 'Jingly', 'Anonymous'], - ... with_email=False, aliases=aliases, excludes=excludes) + ... with_email=False, aliases=aliases) ['J Doe', 'JJJ Smith'] >>> _replace_aliases(['JJJ Smith ', 'Johnny ', - ... 'Jingly ', 'J Doe '], - ... with_email=True, aliases=aliases, excludes=excludes) - ['J Doe and C, Inc.', 'JJJ Smith '] + ... 'Jingly ', 'J Doe '], + ... with_email=True, aliases=aliases) + ['J Doe ', 'JJJ Smith '] """ if aliases == None: aliases = ALIASES - if excludes == None: - excludes = EXCLUDES if with_email == False: - aliases = [_strip_email(*alias) for alias in aliases] - exclude = [_strip_email(*exclude) for exclude in excludes] - for i,author in enumerate(authors): - for alias in aliases: - if author in alias[1:]: - authors[i] = alias[0] - break + aliases = dict([(_strip_email(author)[0], _strip_email(*_aliases)) + for author,_aliases in aliases.items()]) + rev_aliases = _reverse_aliases(aliases) for i,author in enumerate(authors): - for exclude in excludes: - if author in exclude[1:] and exclude[0] in authors: - authors[i] = None - authors = sorted(set(authors)) + if author in rev_aliases: + authors[i] = rev_aliases[author] + authors = sorted(list(set(authors))) if None in authors: authors.remove(None) return authors -def authors_list(): - p = Pipe([['bzr', 'log', '-n0'], - ['grep', '^ *committer\|^ *author'], - ['cut', '-d:', '-f2'], - ['sed', 's/ <.*//;s/^ *//'], - ['sort'], - ['uniq']]) - assert p.status == 0, p.statuses - authors = p.stdout.rstrip().split('\n') - return _replace_aliases(authors, with_email=False) - -def update_authors(verbose=True): - print "updating AUTHORS" - f = file('AUTHORS', 'w') - authors_text = 'Bugs Everywhere was written by:\n%s\n' % '\n'.join(authors_list()) - f.write(authors_text) - f.close() - -def ignored_file(filename, ignored_paths=None, ignored_files=None): - """ - >>> ignored_paths = ['./a/', './b/'] - >>> ignored_files = ['x', 'y'] - >>> ignored_file('./a/z', ignored_paths, ignored_files) - True - >>> ignored_file('./ab/z', ignored_paths, ignored_files) - False - >>> ignored_file('./ab/x', ignored_paths, ignored_files) - True - >>> ignored_file('./ab/xy', ignored_paths, ignored_files) - False - >>> ignored_file('./z', ignored_paths, ignored_files) - False - """ - if ignored_paths == None: - ignored_paths = IGNORED_PATHS - if ignored_files == None: - ignored_files = IGNORED_FILES - for path in ignored_paths: - if filename.startswith(path): - return True - if os.path.basename(filename) in ignored_files: - return True - if os.path.abspath(filename) != os.path.realpath(filename): - return True # symink somewhere in path... - return False - -def _copyright_string(orig_year, final_year, authors): +def _copyright_string(original_year, final_year, authors, prefix=''): """ - >>> print _copyright_string(orig_year=2005, + >>> print _copyright_string(original_year=2005, ... final_year=2005, - ... authors=['A ', 'B '] + ... authors=['A ', 'B '], + ... prefix='# ' ... ) # doctest: +ELLIPSIS # Copyright (C) 2005 A # B # - # This program... - >>> print _copyright_string(orig_year=2005, + # This file... + >>> print _copyright_string(original_year=2005, ... final_year=2009, ... authors=['A ', 'B '] ... ) # doctest: +ELLIPSIS - # Copyright (C) 2005-2009 A - # B - # - # This program... + Copyright (C) 2005-2009 A + B + + This file... """ - if orig_year == final_year: - date_range = '%s' % orig_year + if original_year == final_year: + date_range = '%s' % original_year else: - date_range = '%s-%s' % (orig_year, final_year) - lines = ['# Copyright (C) %s %s' % (date_range, authors[0])] + date_range = '%s-%s' % (original_year, final_year) + lines = ['Copyright (C) %s %s' % (date_range, authors[0])] for author in authors[1:]: - lines.append('#' + - ' '*(len(' Copyright (C) ')+len(date_range)+1) + + lines.append(' '*(len('Copyright (C) ')+len(date_range)+1) + author) - return '%s\n%s' % ('\n'.join(lines), COPYRIGHT_TEXT) + lines.append('') + lines.extend((COPY_RIGHT_TEXT % PROJECT_INFO).splitlines()) + for i,line in enumerate(lines): + lines[i] = (prefix + line).rstrip() + return '\n'.join(lines) def _tag_copyright(contents): """ @@ -352,75 +244,147 @@ def _tag_copyright(contents): ... (copyright ends) ... bla bla bla ... ''' - >>> print _tag_copyright(contents), + >>> print _tag_copyright(contents).replace('COPY-RIGHT', 'CR') Some file bla bla - -xyz-COPYRIGHT-zyx- + -xyz-CR-zyx- (copyright ends) bla bla bla + """ lines = [] incopy = False for line in contents.splitlines(): if incopy == False and line.startswith('# Copyright'): incopy = True - lines.append(COPYRIGHT_TAG) + lines.append(COPY_RIGHT_TAG) elif incopy == True and not line.startswith('#'): incopy = False if incopy == False: lines.append(line.rstrip('\n')) return '\n'.join(lines)+'\n' -def _update_copyright(contents, orig_year, authors): +def _update_copyright(contents, original_year, authors): + """ + >>> contents = '''Some file + ... bla bla + ... # Copyright (copyright begins) + ... # (copyright continues) + ... # bla bla bla + ... (copyright ends) + ... bla bla bla + ... ''' + >>> print _update_copyright(contents, 2008, ['Jack', 'Jill'] + ... ) # doctest: +ELLIPSIS, +REPORT_UDIFF + Some file + bla bla + # Copyright (C) 2008-... Jack + # Jill + # + # This file... + (copyright ends) + bla bla bla + + """ current_year = time.gmtime()[0] - copyright_string = _copyright_string(orig_year, current_year, authors) + copyright_string = _copyright_string( + original_year, current_year, authors, prefix='# ') contents = _tag_copyright(contents) - return contents.replace(COPYRIGHT_TAG, copyright_string) - -def update_file(filename, verbose=True): - if verbose == True: - print "updating", filename - contents = file(filename, 'r').read() - - p = Pipe([['bzr', 'log', '-n0', filename], - ['grep', '^ *timestamp: '], - ['tail', '-n1'], - ['sed', 's/^ *//;'], - ['cut', '-b', '16-19']]) - if p.status != 0: - assert p.statuses[0] == 3, p.statuses - return # bzr doesn't version that file - assert p.status == 0, p.statuses - orig_year = int(p.stdout.strip()) - - p = Pipe([['bzr', 'log', '-n0', filename], - ['grep', '^ *author: \|^ *committer: '], - ['cut', '-d:', '-f2'], - ['sed', 's/^ *//;s/ *$//'], - ['sort'], - ['uniq']]) - assert p.status == 0, p.statuses - authors = p.stdout.rstrip().split('\n') - authors = _replace_aliases(authors, with_email=True, - aliases=ALIASES+COPYRIGHT_ALIASES) - - contents = _update_copyright(contents, orig_year, authors) - f = file(filename, 'w') - f.write(contents) + return contents.replace(COPY_RIGHT_TAG, copyright_string) + +def ignored_file(filename, ignored_paths=None, ignored_files=None, + check_disk=True, check_vcs=True): + """ + >>> ignored_paths = ['./a/', './b/'] + >>> ignored_files = ['x', 'y'] + >>> ignored_file('./a/z', ignored_paths, ignored_files, False, False) + True + >>> ignored_file('./ab/z', ignored_paths, ignored_files, False, False) + False + >>> ignored_file('./ab/x', ignored_paths, ignored_files, False, False) + True + >>> ignored_file('./ab/xy', ignored_paths, ignored_files, False, False) + False + >>> ignored_file('./z', ignored_paths, ignored_files, False, False) + False + """ + if ignored_paths == None: + ignored_paths = IGNORED_PATHS + if ignored_files == None: + ignored_files = IGNORED_FILES + if check_disk == True and os.path.isfile(filename) == False: + return True + for path in ignored_paths: + if filename.startswith(path): + return True + if os.path.basename(filename) in ignored_files: + return True + if check_vcs == True and is_versioned(filename) == False: + return True + return False + +def _set_contents(filename, contents, original_contents=None, dry_run=False, + verbose=0): + if original_contents == None and os.path.isfile(filename): + f = open(filename, 'r') + original_contents = f.read() + f.close() + if verbose > 0: + print "checking %s ... " % filename, + if contents != original_contents: + if verbose > 0: + if original_contents == None: + print "[creating]" + else: + print "[updating]" + if verbose > 1 and original_contents != None: + print '\n'.join( + difflib.unified_diff( + original_contents.splitlines(), contents.splitlines(), + fromfile=os.path.normpath(os.path.join('a', filename)), + tofile=os.path.normpath(os.path.join('b', filename)), + n=3, lineterm='')) + if dry_run == False: + f = file(filename, 'w') + f.write(contents) + f.close() + elif verbose > 0: + print "[no change]" + +# Update commands + +def update_authors(authors_fn=authors_list, dry_run=False, verbose=0): + new_contents = '%s was written by:\n%s\n' % ( + PROJECT_INFO['project'], + '\n'.join(authors_fn()) + ) + _set_contents('AUTHORS', new_contents, dry_run=dry_run, verbose=verbose) + +def update_file(filename, original_year_fn=original_year, authors_fn=authors, + dry_run=False, verbose=0): + f = file(filename, 'r') + contents = f.read() f.close() -def update_files(files=None): + original_year = original_year_fn(filename) + authors = authors_fn(filename) + authors = _replace_aliases(authors, with_email=True, aliases=ALIASES) + + new_contents = _update_copyright(contents, original_year, authors) + _set_contents(filename, contents=new_contents, original_contents=contents, + dry_run=dry_run, verbose=verbose) + +def update_files(files=None, dry_run=False, verbose=0): if files == None or len(files) == 0: - p = Pipe([['grep', '-rc', '# Copyright', '.'], - ['grep', '-v', ':0$'], - ['cut', '-d:', '-f1']]) - assert p.status == 0 - files = p.stdout.rstrip().split('\n') + files = [] + for dirpath,dirnames,filenames in os.walk('.'): + for filename in filenames: + files.append(os.path.join(dirpath, filename)) for filename in files: if ignored_file(filename) == True: continue - update_file(filename) + update_file(filename, dry_run=dry_run, verbose=verbose) def test(): import doctest @@ -428,28 +392,34 @@ def test(): if __name__ == '__main__': import optparse - usage = """%prog [options] [file ...] + import sys + + usage = """%%prog [options] [file ...] Update copyright information in source code with information from -the bzr repository. Run from the BE repository root. +the %(vcs)s repository. Run from the %(project)s repository root. Replaces every line starting with '^# Copyright' and continuing with '^#' with an auto-generated copyright blurb. If you want to add #-commented material after a copyright blurb, please insert a blank -line between the blurb and your comment (as in this file), so the -next run of update_copyright.py doesn't clobber your comment. +line between the blurb and your comment, so the next run of +``update_copyright.py`` doesn't clobber your comment. If no files are given, a list of files to update is generated automatically. -""" +""" % PROJECT_INFO p = optparse.OptionParser(usage) p.add_option('--test', dest='test', default=False, action='store_true', help='Run internal tests and exit') + p.add_option('--dry-run', dest='dry_run', default=False, + action='store_true', help="Don't make any changes") + p.add_option('-v', '--verbose', dest='verbose', default=0, + action='count', help='Increment verbosity') options,args = p.parse_args() if options.test == True: test() sys.exit(0) - update_authors() - update_files(files=args) + update_authors(dry_run=options.dry_run, verbose=options.verbose) + update_files(files=args, dry_run=options.dry_run, verbose=options.verbose)