diff options
| -rwxr-xr-x | update_copyright.py | 741 |
1 files changed, 538 insertions, 203 deletions
diff --git a/update_copyright.py b/update_copyright.py index 2490ba9..a600eac 100755 --- a/update_copyright.py +++ b/update_copyright.py @@ -1,79 +1,352 @@ #!/usr/bin/python # -# Copyright (C) 2009 W. Trevor King <wking@drexel.edu> +# Copyright (C) 2009-2010 W. Trevor King <wking@drexel.edu> # -# 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 file is part of Bugs Everywhere. # -# 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. +# Bugs Everywhere 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. # -# 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. +# Bugs Everywhere 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 Bugs Everywhere. If not, see <http://www.gnu.org/licenses/>. + +"""Automatically update copyright boilerplate. + +This script is adapted from one written for `Bugs Everywhere`_. and +later modified for `Hooke`_ before returning to `Bugs Everywhere`_. + +.. _Bugs Everywhere: http://bugseverywhere.org/ +.. _Hooke: http://code.google.com/p/hooke/ +""" +import difflib +import email.utils +import os import os.path import re import sys import time -import os -import sys -import select -from threading import Thread -from libbe.util.subproc import Pipe +PROJECT_INFO = { + 'project': 'Bugs Everywhere', + 'vcs': 'Git', + } -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 <benf@cybersource.com.au>', - 'Ben Finney <ben+python@benfinney.id.au>', - 'John Doe <jdoe@example.com>'], - ['Chris Ball <cjb@laptop.org>', - 'Chris Ball <cjb@thunk.printf.net>'], - ['Gianluca Montecchi <gian@grys.it>', - 'gian <gian@li82-39>', - 'gianluca <gian@galactica>'], - ['W. Trevor King <wking@drexel.edu>', - 'wking <wking@mjolnir>'], - [None, - 'j^ <j@oil21.org>'], - ] -COPYRIGHT_ALIASES = [ - ['Aaron Bentley and Panometrics, Inc.', - 'Aaron Bentley <abentley@panoramicfeedback.com>'], - ] -EXCLUDES = [ - ['Aaron Bentley and Panometrics, Inc.', - 'Aaron Bentley <aaron.bentley@utoronto.ca>',] - ] - - -IGNORED_PATHS = ['./.be/', './.bzr/', './build/'] -IGNORED_FILES = ['COPYING', 'update_copyright.py', 'catmutt'] +# Break "copyright" into "copy" and "right" to avoid matching the +# REGEXP. +COPY_RIGHT_TEXT=""" +This file is part of %(project)s. -def _strip_email(*args): +%(project)s 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. + +%(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 +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with %(project)s. If not, see <http://www.gnu.org/licenses/>. +""".strip() + +COPY_RIGHT_TAG='-xyz-COPY' + '-RIGHT-zyx-' # unlikely to occur in the wild :p + +# Convert author names to canonical forms. +# ALIASES[<canonical name>] = <list of aliases> +# for example, +# ALIASES = { +# 'John Doe <jdoe@a.com>': +# ['John Doe', 'jdoe', 'J. Doe <j@doe.net>'], +# } +# Git-based projects are encouraged to use .mailmap instead of +# ALIASES. See git-shortlog(1) for details. +ALIASES = { + 'Aaron Bentley <abentley@panoramicfeedback.com>': + ['Aaron Bentley <aaron.bentley@utoronto.ca>'], + 'Panometrics, Inc.': + ['Aaron Bentley and Panometrics, Inc.'], + 'Ben Finney <benf@cybersource.com.au>': + ['Ben Finney <ben+python@benfinney.id.au>', + 'John Doe <jdoe@example.com>'], + 'Chris Ball <cjb@laptop.org>': + ['Chris Ball <cjb@thunk.printf.net>'], + 'Gianluca Montecchi <gian@grys.it>': + ['gian <gian@li82-39>', + 'gianluca <gian@galactica>'], + 'W. Trevor King <wking@drexel.edu>': + ['wking <wking@mjolnir>', + 'wking <wking@thialfi>'], + None: + ['j^ <j@oil21.org>'], + } + +# List of paths that should not be scanned for copyright updates. +# IGNORED_PATHS = ['./.git/'] +IGNORED_PATHS = ['./.be/', './.git/', './build/', './doc/.build/'] +# List of files that should not be scanned for copyright updates. +# IGNORED_FILES = ['COPYING'] +IGNORED_FILES = ['COPYING', 'catmutt'] + +# Work around missing author holes in the VCS history. +# AUTHOR_HACKS[<path tuple>] = [<missing authors] +# for example, if John Doe contributed to module.py but wasn't listed +# in the VCS history of that file: +# AUTHOR_HACKS = { +# ('path', 'to', 'module.py'):['John Doe'], +# } +AUTHOR_HACKS = {} + +# Work around missing year holes in the VCS history. +# YEAR_HACKS[<path tuple>] = <original year> +# for example, if module.py was published in 2008 but the VCS history +# only goes back to 2010: +# YEAR_HACKS = { +# ('path', 'to', 'module.py'):2008, +# } +YEAR_HACKS = {} + +# Helpers for VCS-specific commands + +def splitpath(path): + """Recursively split a path into elements. + + Examples + -------- + + >>> splitpath(os.path.join('a', 'b', 'c')) + ('a', 'b', 'c') + >>> splitpath(os.path.join('.', 'a', 'b', 'c')) + ('a', 'b', 'c') """ + path = os.path.normpath(path) + elements = [] + while True: + dirname,basename = os.path.split(path) + elements.insert(0,basename) + if dirname in ['', '.']: + break + path = dirname + return tuple(elements) + +# VCS-specific commands + +if PROJECT_INFO['vcs'] == 'Git': + + import subprocess + + _MSWINDOWS = sys.platform == 'win32' + _POSIX = not _MSWINDOWS + + def invoke(args, stdin=None, stdout=subprocess.PIPE, stderr=subprocess.PIPE, expect=(0,)): + """ + expect should be a tuple of allowed exit codes. + """ + try : + if _POSIX: + q = subprocess.Popen(args, stdin=subprocess.PIPE, + stdout=stdout, stderr=stderr) + else: + assert _MSWINDOWS == True, 'invalid platform' + # win32 don't have os.execvp() so run the command in a shell + q = subprocess.Popen(args, stdin=subprocess.PIPE, + stdout=stdout, stderr=stderr, shell=True) + except OSError, e: + raise ValueError([args, e]) + stdout,stderr = q.communicate(input=stdin) + status = q.wait() + if status not in expect: + raise ValueError([args, status, stdout, stderr]) + return status, stdout, stderr + + def git_cmd(*args): + status,stdout,stderr = invoke(['git'] + list(args)) + return stdout.rstrip('\n') + + version = git_cmd('--version').split(' ')[-1] + if version.startswith('1.5.'): + # Author name <author email> + author_format = '--pretty=format:%an <%ae>' + year_format = ['--pretty=format:%ai'] # Author date + # YYYY-MM-DD HH:MM:SS Z + # Earlier versions of Git don't seem to recognize --date=short + else: + author_format = '--pretty=format:%aN <%aE>' + year_format = ['--pretty=format:%ad', # Author date + '--date=short'] # YYYY-MM-DD + + def original_year(filename, year_hacks=YEAR_HACKS): + output = git_cmd(*(['log', '--follow'] + + year_format + + [filename])) + if version.startswith('1.5.'): + output = '\n'.join([x.split()[0] for x in output.splitlines()]) + years = [int(line.split('-', 1)[0]) for line in output.splitlines()] + if splitpath(filename) in year_hacks: + years.append(year_hacks[splitpath(filename)]) + years.sort() + return years[0] + + def authors(filename, author_hacks=AUTHOR_HACKS): + output = git_cmd('log', '--follow', author_format, + filename) + ret = list(set(output.splitlines())) + if splitpath(filename) in author_hacks: + ret.extend(author_hacks[splitpath(filename)]) + return ret + + def authors_list(author_hacks=AUTHOR_HACKS): + output = git_cmd('log', author_format) + ret = list(set(output.splitlines())) + for path,authors in author_hacks.items(): + ret.extend(authors) + return ret + + def is_versioned(filename): + output = git_cmd('log', '--follow', filename) + if len(output) == 0: + return False + return True + +elif PROJECT_INFO['vcs'] == 'Mercurial': + + import StringIO + import mercurial + import mercurial.dispatch + + 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, year_hacks=YEAR_HACKS): + # 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()] + if splitpath(filename) in year_hacks: + years.append(year_hacks[splitpath(filename)]) + years.sort() + return years[0] + + def authors(filename, author_hacks=AUTHOR_HACKS): + output,error = mercurial_cmd('log', '--follow', + '--template', '{author}\n', + filename) + ret = list(set(output.splitlines())) + if splitpath(filename) in author_hacks: + ret.extend(author_hacks[splitpath(filename)]) + return ret + + def authors_list(author_hacks=AUTHOR_HACKS): + output,error = mercurial_cmd('log', '--template', '{author}\n') + ret = list(set(output.splitlines())) + for path,authors in author_hacks.items(): + ret.extend(authors) + return ret + + def is_versioned(filename): + output,error = mercurial_cmd('log', '--follow', filename) + if len(error) > 0: + return False + return True + +elif PROJECT_INFO['vcs'] == 'Bazaar': + + import StringIO + import bzrlib + import bzrlib.builtins + import bzrlib.log + + class LogFormatter (bzrlib.log.LogFormatter): + supports_merge_revisions = True + preferred_levels = 0 + supports_deta = False + supports_tags = False + supports_diff = False + + def log_revision(self, revision): + raise NotImplementedError + + class YearLogFormatter (LogFormatter): + def log_revision(self, revision): + self.to_file.write( + time.strftime('%Y', time.gmtime(revision.rev.timestamp)) + +'\n') + + class AuthorLogFormatter (LogFormatter): + def log_revision(self, revision): + authors = revision.rev.get_apparent_authors() + self.to_file.write('\n'.join(authors)+'\n') + + def original_year(filename, year_hacks=YEAR_HACKS): + cmd = bzrlib.builtins.cmd_log() + cmd.outf = StringIO.StringIO() + cmd.run(file_list=[filename], log_format=YearLogFormatter, levels=0) + years = [int(year) for year in set(cmd.outf.getvalue().splitlines())] + if splitpath(filename) in year_hacks: + years.append(year_hacks[splitpath(filename)]) + years.sort() + return years[0] + + def authors(filename, author_hacks=AUTHOR_HACKS): + cmd = bzrlib.builtins.cmd_log() + cmd.outf = StringIO.StringIO() + cmd.run(file_list=[filename], log_format=AuthorLogFormatter, levels=0) + ret = list(set(cmd.outf.getvalue().splitlines())) + if splitpath(filename) in author_hacks: + ret.extend(author_hacks[splitpath(filename)]) + return ret + + def authors_list(author_hacks=AUTHOR_HACKS): + cmd = bzrlib.builtins.cmd_log() + cmd.outf = StringIO.StringIO() + cmd.run(log_format=AuthorLogFormatter, levels=0) + output = cmd.outf.getvalue() + ret = list(set(cmd.outf.getvalue().splitlines())) + for path,authors in author_hacks.items(): + ret.extend(authors) + return ret + + def is_versioned(filename): + cmd = bzrlib.builtins.cmd_log() + cmd.outf = StringIO.StringIO() + cmd.run(file_list=[filename]) + return True + +else: + raise NotImplementedError('Unrecognized VCS: %(vcs)s' % PROJECT_INFO) + +# General utility commands + +def _strip_email(*args): + """Remove email addresses from a series of names. + + Examples + -------- + >>> _strip_email('J Doe <jdoe@a.com>') ['J Doe'] >>> _strip_email('J Doe <jdoe@a.com>', 'JJJ Smith <jjjs@a.com>') @@ -83,127 +356,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 <jdoe@a.com>':['Johnny <jdoe@b.edu>', 'J'], + ... 'JJJ Smith <jjjs@a.com>':['Jingly <jjjs@b.edu>'], + ... None:['Anonymous <a@a.com>'], + ... } + >>> r = _reverse_aliases(aliases) + >>> for item in sorted(r.items()): + ... print item + ('Anonymous <a@a.com>', None) + ('J', 'J Doe <jdoe@a.com>') + ('Jingly <jjjs@b.edu>', 'JJJ Smith <jjjs@a.com>') + ('Johnny <jdoe@b.edu>', 'J Doe <jdoe@a.com>') """ - >>> aliases = [['J Doe and C, Inc.', 'J Doe <jdoe@c.com>'], - ... ['J Doe <jdoe@a.com>', 'Johnny <jdoe@b.edu>'], - ... ['JJJ Smith <jjjs@a.com>', 'Jingly <jjjs@b.edu>'], - ... [None, 'Anonymous <a@a.com>']] - >>> excludes = [['J Doe and C, Inc.', 'J Doe <jdoe@a.com>']] + 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 <jdoe@a.com>':['Johnny <jdoe@b.edu>'], + ... 'JJJ Smith <jjjs@a.com>':['Jingly <jjjs@b.edu>'], + ... None:['Anonymous <a@a.com>'], + ... } >>> _replace_aliases(['JJJ Smith <jjjs@a.com>', 'Johnny <jdoe@b.edu>', ... 'Jingly <jjjs@b.edu>', 'Anonymous <a@a.com>'], - ... with_email=True, aliases=aliases, excludes=excludes) + ... with_email=True, aliases=aliases) ['J Doe <jdoe@a.com>', 'JJJ Smith <jjjs@a.com>'] >>> _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 <jjjs@a.com>', 'Johnny <jdoe@b.edu>', - ... 'Jingly <jjjs@b.edu>', 'J Doe <jdoe@c.com>'], - ... with_email=True, aliases=aliases, excludes=excludes) - ['J Doe and C, Inc.', 'JJJ Smith <jjjs@a.com>'] + ... 'Jingly <jjjs@b.edu>', 'J Doe <jdoe@a.com>'], + ... with_email=True, aliases=aliases) + ['J Doe <jdoe@a.com>', 'JJJ Smith <jjjs@a.com>'] """ 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] + 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 alias in aliases: - if author in alias[1:]: - authors[i] = alias[0] - break - 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 <a@a.com>', 'B <b@b.edu>'] + ... authors=['A <a@a.com>', 'B <b@b.edu>'], + ... prefix='# ' ... ) # doctest: +ELLIPSIS # Copyright (C) 2005 A <a@a.com> # B <b@b.edu> # - # This program... - >>> print _copyright_string(orig_year=2005, + # This file... + >>> print _copyright_string(original_year=2005, ... final_year=2009, ... authors=['A <a@a.com>', 'B <b@b.edu>'] ... ) # doctest: +ELLIPSIS - # Copyright (C) 2005-2009 A <a@a.com> - # B <b@b.edu> - # - # This program... + Copyright (C) 2005-2009 A <a@a.com> + B <b@b.edu> + <BLANKLINE> + 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): """ @@ -215,104 +470,184 @@ 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 + <BLANKLINE> """ 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 + <BLANKLINE> + """ 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): + authors = authors_fn() + authors = _replace_aliases(authors, with_email=True, aliases=ALIASES) + new_contents = '%s was written by:\n%s\n' % ( + PROJECT_INFO['project'], + '\n'.join(authors) + ) + _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 - doctest.testmod() + doctest.testmod() 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) |