Add a tool to check license compatibility with Android

tools/licenses.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Utility for checking and processing licensing information in third_party
 directories.
 
 Usage: licenses.py <command>
 
@@ skipping 155 matching lines @@
     if filename.startswith('/'):
         # Absolute-looking paths are relative to the source root
         # (which is the directory we're run from).
         absolute_path = os.path.join(os.getcwd(), filename[1:])
     else:
         absolute_path = os.path.join(path, filename)
     if os.path.exists(absolute_path):
         return absolute_path
     return None
 
-def ParseDir(path):
-    """Examine a third_party/foo component and extract its metadata."""
+def ParseDir(path, raise_on_error):
+    """Examine a third_party/foo component and extract its metadata.
+    Args:
+      path the path to the component to examine
+      raise_on_error whether to raise an exception if an error occurs
+    Returns:
+      metadata for the component
+    """
 
     # Parse metadata fields out of README.chromium.
     # We examine "LICENSE" for the license file by default.
     metadata = {
         "License File": "LICENSE",  # Relative path to license text.
         "Name": None,               # Short name (for header on about:credits).
         "URL": None,                # Project home page.
         }
 
     # Relative path to a file containing some html we're required to place in
     # about:credits.
     optional_keys = ["Required Text"]
 
     if path in SPECIAL_CASES:
         metadata.update(SPECIAL_CASES[path])
     else:
         # Try to find README.chromium.
         readme_path = os.path.join(path, 'README.chromium')
         if not os.path.exists(readme_path):
-            raise LicenseError("missing README.chromium")
-
-        for line in open(readme_path):
-            line = line.strip()
-            if not line:
-                break
-            for key in metadata.keys() + optional_keys:
-                field = key + ": "
-                if line.startswith(field):
-                    metadata[key] = line[len(field):]
+            if raise_on_error:
+                raise LicenseError("missing README.chromium")
+        else:
+            for line in open(readme_path):
+                line = line.strip()
+                if not line:
+                    break
+                for key in metadata.keys() + optional_keys:
+                    field = key + ": "
+                    if line.startswith(field):
+                        metadata[key] = line[len(field):]
 
     # Check that all expected metadata is present.
-    for key, value in metadata.iteritems():
-        if not value:
-            raise LicenseError("couldn't find '" + key + "' line "
-                               "in README.chromium or licences.py "
-                               "SPECIAL_CASES")
+    if raise_on_error:
+        for key, value in metadata.iteritems():
+            if not value:
+                raise LicenseError("couldn't find '" + key + "' line "
+                                   "in README.chromium or licences.py "
+                                   "SPECIAL_CASES")
 
     # Check that the license file exists.
     for filename in (metadata["License File"], "COPYING"):
         license_path = AbsolutePath(path, filename)
         if license_path is not None:
             metadata["License File"] = license_path
             break
 
-    if not license_path:
+    if raise_on_error and not license_path:
         raise LicenseError("License file not found. "
                            "Either add a file named LICENSE, "
                            "import upstream's COPYING if available, "
                            "or add a 'License File:' line to README.chromium "
                            "with the appropriate path.")
 
     if "Required Text" in metadata:
         required_path = AbsolutePath(path, metadata["Required Text"])
         if required_path is not None:
             metadata["Required Text"] = required_path
-        else:
+        elif raise_on_error:
             raise LicenseError("Required text file listed but not found.")
 
     return metadata
 
 
 def FindThirdPartyDirs():
     """Find all third_party directories underneath the current directory."""
     third_party_dirs = []
     for path, dirs, files in os.walk('.'):
         path = path[len('./'):]  # Pretty up the path.
@@ skipping 26 matching lines @@
     return third_party_dirs
 
 
 def ScanThirdPartyDirs():
     """Scan a list of directories and report on any problems we find."""
     third_party_dirs = FindThirdPartyDirs()
 
     errors = []
     for path in sorted(third_party_dirs):
         try:
-            metadata = ParseDir(path)
+            metadata = ParseDir(path, True)

[Evan Martin, 2012/07/24 19:41:28]

Consider something like:
  ParseDir(path, raise_on_error=True)
to make the code more self-describing.  (here and below) 


But if the calling code really wants to swallow all LicenseErrors, why not just
wrap the call to ParseDir() with a "try" block that does so rather than passing
this bool?

[Steve Block, 2012/07/24 21:20:58]

Regarding a try block, this approach doesn't work because I need to method to
complete, even if one of the early phases fails and would otherwise raise.

         except LicenseError, e:
             errors.append((path, e.args[0]))
             continue
 
     for path, error in sorted(errors):
         print path + ": " + error
 
     return len(errors) == 0
 
 
 def GenerateCredits():
     """Generate about:credits, dumping the result to stdout."""
 
     def EvaluateTemplate(template, env, escape=True):
         """Expand a template with variables like {{foo}} using a
         dictionary of expansions."""
         for key, val in env.items():
             if escape and not key.endswith("_unescaped"):
                 val = cgi.escape(val)
             template = template.replace('{{%s}}' % key, val)
         return template
 
     third_party_dirs = FindThirdPartyDirs()
 
     entry_template = open('chrome/browser/resources/about_credits_entry.tmpl',
                           'rb').read()
     entries = []
     for path in sorted(third_party_dirs):
         try:
-            metadata = ParseDir(path)
+            metadata = ParseDir(path, True)
         except LicenseError:
             print >>sys.stderr, ("WARNING: licensing info for " + path +
                                  " is incomplete, skipping.")
             continue
         env = {
             'name': metadata['Name'],
             'url': metadata['URL'],
             'license': open(metadata['License File'], 'rb').read(),
             'license_unescaped': '',
         }
@@ skipping 20 matching lines @@
     elif command == 'credits':
         if not GenerateCredits():
             return 1
     else:
         print __doc__
         return 1
 
 
 if __name__ == '__main__':
   sys.exit(main())