Use last modified year as end of copyright year range

Use the year of the commit in which a file was most recently modified in Git
history for the end of the copyright year range. If the file hasn't been
committed yet, the current calendar year is used.

Author: calcmogul

wpiformat/test/test_licenseupdate.py

@@ -1,11 +1,29 @@
 from datetime import date
 import os
+from pathlib import Path
+import shutil
+import subprocess
+import tempfile
 
 from test.tasktest import *
 from wpiformat.config import Config
 from wpiformat.licenseupdate import LicenseUpdate
 
 
+class OpenTemporaryDirectory():
+
+    def __init__(self):
+        self.prev_dir = os.getcwd()
+
+    def __enter__(self):
+        self.temp_dir = tempfile.TemporaryDirectory()
+        os.chdir(self.temp_dir.name)
+        return self.temp_dir
+
+    def __exit__(self, type, value, traceback):
+        os.chdir(self.prev_dir)
+
+
 def test_licenseupdate():
     year = str(date.today().year)
 
@@ -173,4 +191,83 @@ def test_licenseupdate():
     config_file = Config(os.path.abspath(os.getcwd()), ".styleguide")
     assert not task.should_process_file(config_file, "./Excluded.h")
 
+    # Create git repo to test license years for commits
+    with OpenTemporaryDirectory():
+        subprocess.run(["git", "init", "-q"])
+
+        # Add base files
+        with open(".styleguide-license", "w") as file:
+            file.write("// Copyright (c) {year}")
+        with open(".styleguide", "w") as file:
+            file.write("cppSrcFileInclude {\n" + r"\.cpp$")
+        subprocess.run(["git", "add", ".styleguide-license"])
+        subprocess.run(["git", "add", ".styleguide"])
+        subprocess.run(["git", "commit", "-q", "-m", "\"Initial commit\""])
+
+        # Add file with commit date of last year and range through this year
+        with open("last-year.cpp", "w") as file:
+            file.write(f"// Copyright (c) 2017-{year}")
+        subprocess.run(["git", "add", "last-year.cpp"])
+        subprocess.run(["git", "commit", "-q", "-m", "\"Last year\""])
+        last_iso_year = f"{int(year) - 1}-01-01T00:00:00"
+        subprocess.Popen([
+            "git", "commit", "-q", "--amend", "--no-edit",
+            f"--date={last_iso_year}"
+        ],
+                         env={
+                             **os.environ, "GIT_COMMITTER_DATE": last_iso_year
+                         }).wait()
+
+        # Add file with commit date of this year and range through this year
+        with open("this-year.cpp", "w") as file:
+            file.write(f"// Copyright (c) 2017-{year}")
+        subprocess.run(["git", "add", "this-year.cpp"])
+        subprocess.run(["git", "commit", "-q", "-m", "\"This year\""])
+
+        # Add file with commit date of next year and range through this year
+        with open("next-year.cpp", "w") as file:
+            file.write(f"// Copyright (c) 2017-{year}")
+        subprocess.run(["git", "add", "next-year.cpp"])
+        subprocess.run(["git", "commit", "-q", "-m", "\"Next year\""])
+        next_iso_year = f"{int(year) + 1}-01-01T00:00:00"
+        subprocess.Popen([
+            "git", "commit", "-q", "--amend", "--no-edit",
+            f"--date={next_iso_year}"
+        ],
+                         env={
+                             **os.environ, "GIT_COMMITTER_DATE": next_iso_year
+                         }).wait()
+
+        # Create uncommitted file with no year
+        Path("no-year.cpp").touch()
+
+        # Run wpiformat on last-year.cpp
+        with open("last-year.cpp", "r") as input:
+            lines = input.read()
+        output, changed, success = task.run_pipeline(config_file,
+                                                     "last-year.cpp", lines)
+        assert output == f"// Copyright (c) 2017-{int(year) - 1}\n\n"
+
+        # Run wpiformat on this-year.cpp
+        with open("last-year.cpp", "r") as input:
+            lines = input.read()
+        output, changed, success = task.run_pipeline(config_file,
+                                                     "this-year.cpp", lines)
+        assert output == f"// Copyright (c) 2017-{year}\n\n"
+
+        # Run wpiformat on next-year.cpp
+        with open("next-year.cpp", "r") as input:
+            lines = input.read()
+        output, changed, success = task.run_pipeline(config_file,
+                                                     "next-year.cpp", lines)
+        assert output == f"// Copyright (c) 2017-{int(year) + 1}\n\n"
+
+        # Run wpiformat on no-year.cpp
+        # Should have current calendar year
+        with open("no-year.cpp", "r") as input:
+            lines = input.read()
+        output, changed, success = task.run_pipeline(config_file, "no-year.cpp",
+                                                     lines)
+        assert output == f"// Copyright (c) {year}\n\n"
+
     test.run(OutputType.FILE)

wpiformat/wpiformat/licenseupdate.py

@@ -2,6 +2,7 @@
 
 import os
 import regex
+import subprocess
 import sys
 
 from wpiformat.config import Config
@@ -26,15 +27,17 @@ def should_process_file(self, config_file, name):
         return (config_file.is_c_file(name) or config_file.is_cpp_file(name) or
                 name.endswith(".java")) and not license_regex.search(name)
 
-    def __try_regex(self, lines, license_template):
+    def __try_regex(self, lines, last_year, license_template):
         """Try finding license with regex of license template.
 
         Keyword arguments:
         lines -- lines of file
+        last_year -- last year in copyright range
         license_template -- license_template string
 
         Returns:
-        Tuple of whether license was found, year, and file contents after license.
+        Tuple of whether license was found, first year in copyright range, and
+        file contents after license.
         """
         linesep = Task.get_linesep(lines)
 
@@ -47,28 +50,29 @@ def __try_regex(self, lines, license_template):
         license_rgx = regex.compile(license_rgxstr, regex.M)
 
         # Compare license
-        year = self.__current_year
         match = license_rgx.search(lines)
         if match:
             try:
-                year = match.group("year")
+                first_year = match.group("year")
             except IndexError:
                 pass
 
             # If comment at beginning of file is non-empty license, update it
-            return (True, year, linesep + lines[match.end():].lstrip())
+            return (True, first_year, linesep + lines[match.end():].lstrip())
         else:
-            return (False, year, lines)
+            return (False, last_year, lines)
 
-    def __try_string_search(self, lines, license_template):
+    def __try_string_search(self, lines, last_year, license_template):
         """Try finding license with string search.
 
         Keyword arguments:
         lines -- lines of file
+        last_year -- last year in copyright range
         license_template -- license_template string
 
         Returns:
-        Tuple of whether license was found, year, and file contents after license.
+        Tuple of whether license was found, first year in copyright range, and
+        file contents after license.
         """
         linesep = Task.get_linesep(lines)
 
@@ -107,8 +111,9 @@ def __try_string_search(self, lines, license_template):
             else:
                 license_end += 1
 
+        first_year = last_year
+
         # If comment at beginning of file is non-empty license, update it
-        year = self.__current_year
         if first_comment_is_license and license_end > 0:
             license_part = linesep.join(stripped_lines[0:license_end])
             appendix_part = \
@@ -119,33 +124,51 @@ def __try_string_search(self, lines, license_template):
                 match = year_regex.search(line)
                 # If license contains copyright pattern, extract the first year
                 if match:
-                    year = match.group(1)
+                    first_year = match.group(1)
                     break
 
-            return (True, year, appendix_part)
+            return (True, first_year, appendix_part)
         else:
-            return (False, year, linesep + lines.lstrip())
+            return (False, first_year, linesep + lines.lstrip())
 
     def run_pipeline(self, config_file, name, lines):
         linesep = Task.get_linesep(lines)
 
         license_template = Config.read_file(
             os.path.dirname(os.path.abspath(name)), ".styleguide-license")
 
-        success, year, appendix = self.__try_regex(lines, license_template)
+        # Get year when file was most recently modified in Git history
+        #
+        # Committer date is used instead of author date (the one shown by "git
+        # log" because the year the file was last modified in the history should
+        # be used. Author dates can be older than this or even out of order in
+        # the log.
+        cmd = ["git", "log", "-n", "1", "--format=%ci", "--", name]
+        last_year = subprocess.run(cmd,
+                                   stdout=subprocess.PIPE).stdout.decode()[:4]
+
+        # If file hasn't been committed yet, use current calendar year as end of
+        # copyright year range
+        if last_year == "":
+            last_year = self.__current_year
+
+        success, first_year, appendix = self.__try_regex(
+            lines, last_year, license_template)
         if not success:
-            success, year, appendix = self.__try_string_search(
-                lines, license_template)
+            success, first_year, appendix = self.__try_string_search(
+                lines, last_year, license_template)
 
         output = ""
 
         # Determine copyright range and trailing padding
-        if year != self.__current_year:
-            year = year + "-" + self.__current_year
+        if first_year != last_year:
+            year_range = first_year + "-" + last_year
+        else:
+            year_range = first_year
 
         for line in license_template:
             # Insert copyright year range
-            line = line.replace("{year}", year)
+            line = line.replace("{year}", year_range)
 
             # Insert padding which expands to the 80th column. If there is more
             # than one padding token, the line may contain fewer than 80