text: #!/usr/bin/env python
  #
  # Copyright (c) 2013 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.
  
  """Runs Android's lint tool."""
  
  
  import argparse
  import os
  import re
  import sys
  import traceback
  from xml.dom import minidom
  
  from util import build_utils
  
  _LINT_MD_URL = 'https://chromium.googlesource.com/chromium/src/+/master/build/android/docs/lint.md' # pylint: disable=line-too-long
  _SRC_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__),
                                           '..', '..', '..'))
  
  
  def _OnStaleMd5(lint_path, config_path, processed_config_path,
                  manifest_path, result_path, product_dir, sources, jar_path,
                  cache_dir, android_sdk_version, resource_dir=None,
                  classpath=None, can_fail_build=False, silent=False):
    def _RelativizePath(path):
      """Returns relative path to top-level src dir.
  
      Args:
        path: A path relative to cwd.
      """
      return os.path.relpath(os.path.abspath(path), _SRC_ROOT)
  
    def _ProcessConfigFile():
      if not config_path or not processed_config_path:
        return
      if not build_utils.IsTimeStale(processed_config_path, [config_path]):
        return
  
      with open(config_path, 'rb') as f:
        content = f.read().replace(
            'PRODUCT_DIR', _RelativizePath(product_dir))
  
      with open(processed_config_path, 'wb') as f:
        f.write(content)
  
    def _ProcessResultFile():
      with open(result_path, 'rb') as f:
        content = f.read().replace(
            _RelativizePath(product_dir), 'PRODUCT_DIR')
  
      with open(result_path, 'wb') as f:
        f.write(content)
  
    def _ParseAndShowResultFile():
      dom = minidom.parse(result_path)
      issues = dom.getElementsByTagName('issue')
      if not silent:
        print >> sys.stderr
        for issue in issues:
          issue_id = issue.attributes['id'].value
          message = issue.attributes['message'].value
          location_elem = issue.getElementsByTagName('location')[0]
          path = location_elem.attributes['file'].value
          line = location_elem.getAttribute('line')
          if line:
            error = '%s:%s %s: %s [warning]' % (path, line, message, issue_id)
          else:
            # Issues in class files don't have a line number.
            error = '%s %s: %s [warning]' % (path, message, issue_id)
          print >> sys.stderr, error.encode('utf-8')
          for attr in ['errorLine1', 'errorLine2']:
            error_line = issue.getAttribute(attr)
            if error_line:
              print >> sys.stderr, error_line.encode('utf-8')
      return len(issues)
  
    with build_utils.TempDir() as temp_dir:
      _ProcessConfigFile()
  
      cmd = [
          _RelativizePath(lint_path), '-Werror', '--exitcode', '--showall',
          '--xml', _RelativizePath(result_path),
      ]
      if jar_path:
        # --classpath is just for .class files for this one target.
        cmd.extend(['--classpath', _RelativizePath(jar_path)])
      if processed_config_path:
        cmd.extend(['--config', _RelativizePath(processed_config_path)])
      if resource_dir:
        cmd.extend(['--resources', _RelativizePath(resource_dir)])
      if classpath:
        # --libraries is the classpath (excluding active target).
        cp = ':'.join(_RelativizePath(p) for p in classpath)
        cmd.extend(['--libraries', cp])
  
      # There may be multiple source files with the same basename (but in
      # different directories). It is difficult to determine what part of the path
      # corresponds to the java package, and so instead just link the source files
      # into temporary directories (creating a new one whenever there is a name
      # conflict).
      src_dirs = []
      def NewSourceDir():
        new_dir = os.path.join(temp_dir, str(len(src_dirs)))
        os.mkdir(new_dir)
        src_dirs.append(new_dir)
        return new_dir
  
      def PathInDir(d, src):
        return os.path.join(d, os.path.basename(src))
  
      for src in sources:
        src_dir = None
        for d in src_dirs:
          if not os.path.exists(PathInDir(d, src)):
            src_dir = d
            break
        if not src_dir:
          src_dir = NewSourceDir()
          cmd.extend(['--sources', _RelativizePath(src_dir)])
        os.symlink(os.path.abspath(src), PathInDir(src_dir, src))
  
      project_dir = NewSourceDir()
      if android_sdk_version:
        # Create dummy project.properies file in a temporary "project" directory.
        # It is the only way to add Android SDK to the Lint's classpath. Proper
        # classpath is necessary for most source-level checks.
        with open(os.path.join(project_dir, 'project.properties'), 'w') \
            as propfile:
          print >> propfile, 'target=android-{}'.format(android_sdk_version)
  
      # Put the manifest in a temporary directory in order to avoid lint detecting
      # sibling res/ and src/ directories (which should be pass explicitly if they
      # are to be included).
      if manifest_path:
        os.symlink(os.path.abspath(manifest_path),
                   PathInDir(project_dir, manifest_path))
      cmd.append(project_dir)
  
      if os.path.exists(result_path):
        os.remove(result_path)
  
      env = {}
      stderr_filter = None
      if cache_dir:
        env['_JAVA_OPTIONS'] = '-Duser.home=%s' % _RelativizePath(cache_dir)
        # When _JAVA_OPTIONS is set, java prints to stderr:
        # Picked up _JAVA_OPTIONS: ...
        #
        # We drop all lines that contain _JAVA_OPTIONS from the output
        stderr_filter = lambda l: re.sub(r'.*_JAVA_OPTIONS.*\n?', '', l)
  
      try:
        build_utils.CheckOutput(cmd, cwd=_SRC_ROOT, env=env or None,
                                stderr_filter=stderr_filter)
      except build_utils.CalledProcessError:
        # There is a problem with lint usage
        if not os.path.exists(result_path):
          raise
  
        # Sometimes produces empty (almost) files:
        if os.path.getsize(result_path) < 10:
          if can_fail_build:
            raise
          elif not silent:
            traceback.print_exc()
          return
  
        # There are actual lint issues
        try:
          num_issues = _ParseAndShowResultFile()
        except Exception: # pylint: disable=broad-except
          if not silent:
            print 'Lint created unparseable xml file...'
            print 'File contents:'
            with open(result_path) as f:
              print f.read()
          if not can_fail_build:
            return
  
        if can_fail_build and not silent:
          traceback.print_exc()
  
        # There are actual lint issues
        try:
          num_issues = _ParseAndShowResultFile()
        except Exception: # pylint: disable=broad-except
          if not silent:
            print 'Lint created unparseable xml file...'
            print 'File contents:'
            with open(result_path) as f:
              print f.read()
          raise
  
        _ProcessResultFile()
        msg = ('\nLint found %d new issues.\n'
               ' - For full explanation, please refer to %s\n'
               ' - For more information about lint and how to fix lint issues,'
               ' please refer to %s\n' %
               (num_issues,
                _RelativizePath(result_path),
                _LINT_MD_URL))
        if not silent:
          print >> sys.stderr, msg
        if can_fail_build:
          raise Exception('Lint failed.')
  
  
  def main():
    parser = argparse.ArgumentParser()
    build_utils.AddDepfileOption(parser)
  
    parser.add_argument('--lint-path', required=True,
                        help='Path to lint executable.')
    parser.add_argument('--product-dir', required=True,
                        help='Path to product dir.')
    parser.add_argument('--result-path', required=True,
                        help='Path to XML lint result file.')
    parser.add_argument('--cache-dir', required=True,
                        help='Path to the directory in which the android cache '
                             'directory tree should be stored.')
    parser.add_argument('--platform-xml-path', required=True,
                        help='Path to api-platforms.xml')
    parser.add_argument('--android-sdk-version',
                        help='Version (API level) of the Android SDK used for '
                             'building.')
    parser.add_argument('--create-cache', action='store_true',
                        help='Mark the lint cache file as an output rather than '
                        'an input.')
    parser.add_argument('--can-fail-build', action='store_true',
                        help='If set, script will exit with nonzero exit status'
                             ' if lint errors are present')
    parser.add_argument('--config-path',
                        help='Path to lint suppressions file.')
    parser.add_argument('--enable', action='store_true',
                        help='Run lint instead of just touching stamp.')
    parser.add_argument('--jar-path',
                        help='Jar file containing class files.')
    parser.add_argument('--java-files',
                        help='Paths to java files.')
    parser.add_argument('--manifest-path',
                        help='Path to AndroidManifest.xml')
    parser.add_argument('--classpath', default=[], action='append',
                        help='GYP-list of classpath .jar files')
    parser.add_argument('--processed-config-path',
                        help='Path to processed lint suppressions file.')
    parser.add_argument('--resource-dir',
                        help='Path to resource dir.')
    parser.add_argument('--silent', action='store_true',
                        help='If set, script will not log anything.')
    parser.add_argument('--src-dirs',
                        help='Directories containing java files.')
    parser.add_argument('--stamp',
                        help='Path to touch on success.')
  
    args = parser.parse_args(build_utils.ExpandFileArgs(sys.argv[1:]))
  
    if args.enable:
      sources = []
      if args.src_dirs:
        src_dirs = build_utils.ParseGypList(args.src_dirs)
        sources = build_utils.FindInDirectories(src_dirs, '*.java')
      elif args.java_files:
        sources = build_utils.ParseGypList(args.java_files)
  
      if args.config_path and not args.processed_config_path:
        parser.error('--config-path specified without --processed-config-path')
      elif args.processed_config_path and not args.config_path:
        parser.error('--processed-config-path specified without --config-path')
  
      input_paths = [
          args.lint_path,
          args.platform_xml_path,
      ]
      if args.config_path:
        input_paths.append(args.config_path)
      if args.jar_path:
        input_paths.append(args.jar_path)
      if args.manifest_path:
        input_paths.append(args.manifest_path)
      if args.resource_dir:
        input_paths.extend(build_utils.FindInDirectory(args.resource_dir, '*'))
      if sources:
        input_paths.extend(sources)
      classpath = []
      for gyp_list in args.classpath:
        classpath.extend(build_utils.ParseGypList(gyp_list))
      input_paths.extend(classpath)
  
      input_strings = []
      if args.android_sdk_version:
        input_strings.append(args.android_sdk_version)
      if args.processed_config_path:
        input_strings.append(args.processed_config_path)
  
      output_paths = [ args.result_path ]
  
      build_utils.CallAndWriteDepfileIfStale(
          lambda: _OnStaleMd5(args.lint_path,
                              args.config_path,
                              args.processed_config_path,
                              args.manifest_path, args.result_path,
                              args.product_dir, sources,
                              args.jar_path,
                              args.cache_dir,
                              args.android_sdk_version,
                              resource_dir=args.resource_dir,
                              classpath=classpath,
                              can_fail_build=args.can_fail_build,
                              silent=args.silent),
          args,
          input_paths=input_paths,
          input_strings=input_strings,
          output_paths=output_paths,
          depfile_deps=classpath)
  
  
  if __name__ == '__main__':
    sys.exit(main())
  